Apriori算法例子

1 Apriori介绍

Apriori算法使用频繁项集的先验知识，使用一种称作逐层搜索的迭代方法，k项集用于探索(k+1)项集。首先，通过扫描事务（交易）记录，找出所有的频繁1项集，该集合记做L1，然后利用L1找频繁2项集的集合L2，L2找L3，如此下去，直到不能再找到任何频繁k项集。最后再在所有的频繁集中找出强规则，即产生用户感兴趣的关联规则。

其中，Apriori算法具有这样一条性质：任一频繁项集的所有非空子集也必须是频繁的。因为假如P(I)< 最小支持度阈值，当有元素A添加到I中时，结果项集（A∩I）不可能比I出现次数更多。因此A∩I也不是频繁的。

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加入了所谓的剪枝步，事先对候选集进行过滤，以减少访问外存的次数。）

3   Apriori算法实例


交易ID
商品ID列表

T100
I1，I2，I5

T200
I2，I4

T300
I2，I3

T400
I1，I2，I4

T500
I1，I3

T600
I2，I3

T700
I1，I3

T800
I1，I2，I3，I5

T900
I1，I2，I3

上图为某商场的交易记录，共有9个事务，利用Apriori算法寻找所有的频繁项集的过程如下:

详细介绍下候选3项集的集合C3的产生过程：从连接步，首先C3={{I1,I2,I3}，{I1,I2,I5}，{I1,I3,I5}，{I2,I3,I4}，{I2,I3,I5}，{I2,I4,I5}}（C3是由L2与自身连接产生）。根据Apriori性质，频繁项集的所有子集也必须频繁的，可以确定有4个候选集{I1,I3,I5}，{I2,I3,I4}，{I2,I3,I5}，{I2,I4,I5}}不可能时频繁的，因为它们存在子集不属于频繁集，因此将它们从C3中删除。注意，由于Apriori算法使用逐层搜索技术，给定候选k项集后，只需检查它们的（k-1）个子集是否频繁。

3． 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;

 

4． 由频繁项集产生关联规则

Confidence(A->B)=P(B|A)=support_count(AB)/support_count(A)

关联规则产生步骤如下：

1）  对于每个频繁项集l，产生其所有非空真子集；

2）  对于每个非空真子集s,如果support_count(l)/support_count(s)>=min_conf，则输出 s->(l-s)，其中，min_conf是最小置信度阈值。

例如，在上述例子中，针对频繁集{I1，I2，I5}。可以产生哪些关联规则？该频繁集的非空真子集有{I1，I2}，{I1，I5}，{I2，I5}，{I1 }，{I2}和{I5}，对应置信度如下：

I1&&I2->I5            confidence=2/4=50%

I1&&I5->I2            confidence=2/2=100%

I2&&I5->I1            confidence=2/2=100%

I1 ->I2&&I5            confidence=2/6=33%

I2 ->I1&&I5            confidence=2/7=29%

I5 ->I1&&I2            confidence=2/2=100%

如果min_conf=70%,则强规则有I1&&I5->I2，I2&&I5->I1，I5 ->I1&&I2。

5． Apriori Java代码

package com.apriori;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

public class Apriori {

private final static int SUPPORT = 2; // 支持度阈值

private final static double CONFIDENCE = 0.7; // 置信度阈值

private final static String ITEM_SPLIT=";"; // 项之间的分隔符

private final static String CON="->"; // 项之间的分隔符

private final static List<String> transList=new ArrayList<String>(); //所有交易

static{//初始化交易记录

transList.add("1;2;5;");

transList.add("2;4;");

transList.add("2;3;");

transList.add("1;2;4;");

transList.add("1;3;");

transList.add("2;3;");

transList.add("1;3;");

transList.add("1;2;3;5;");

transList.add("1;2;3;");

}

public Map<String,Integer> getFC(){

Map<String,Integer> frequentCollectionMap=new HashMap<String,Integer>();//所有的频繁集

frequentCollectionMap.putAll(getItem1FC());

Map<String,Integer> itemkFcMap=new HashMap<String,Integer>();

itemkFcMap.putAll(getItem1FC());

while(itemkFcMap!=null&&itemkFcMap.size()!=0){

Map<String,Integer> candidateCollection=getCandidateCollection(itemkFcMap);

Set<String> ccKeySet=candidateCollection.keySet();

//对候选集项进行累加计数

for(String trans:transList){

for(String candidate:ccKeySet){

boolean flag=true;// 用来判断交易中是否出现该候选项，如果出现，计数加1

String[] candidateItems=candidate.split(ITEM_SPLIT);

for(String candidateItem:candidateItems){

if(trans.indexOf(candidateItem+ITEM_SPLIT)==-1){

flag=false;

break;

}

}

if(flag){

Integer count=candidateCollection.get(candidate);

candidateCollection.put(candidate, count+1);

}

}

}

//从候选集中找到符合支持度的频繁集项

itemkFcMap.clear();

for(String candidate:ccKeySet){

Integer count=candidateCollection.get(candidate);

if(count>=SUPPORT){

itemkFcMap.put(candidate, count);

}

}

//合并所有频繁集

frequentCollectionMap.putAll(itemkFcMap);

}

return frequentCollectionMap;

}

private Map<String,Integer> getCandidateCollection(Map<String,Integer> itemkFcMap){

Map<String,Integer> candidateCollection=new HashMap<String,Integer>();

Set<String> itemkSet1=itemkFcMap.keySet();

Set<String> itemkSet2=itemkFcMap.keySet();

for(String itemk1:itemkSet1){

for(String itemk2:itemkSet2){

//进行连接

String[] tmp1=itemk1.split(ITEM_SPLIT);

String[] tmp2=itemk2.split(ITEM_SPLIT);

String c="";

if(tmp1.length==1){

if(tmp1[0].compareTo(tmp2[0])<0){

c=tmp1[0]+ITEM_SPLIT+tmp2[0]+ITEM_SPLIT;

}

}else{

boolean flag=true;

for(int i=0;i<tmp1.length-1;i++){

if(!tmp1[i].equals(tmp2[i])){

flag=false;

break;

}

}

if(flag&&(tmp1[tmp1.length-1].compareTo(tmp2[tmp2.length-1])<0)){

c=itemk1+tmp2[tmp2.length-1]+ITEM_SPLIT;

}

}

//进行剪枝

boolean hasInfrequentSubSet = false;

if (!c.equals("")) {

String[] tmpC = c.split(ITEM_SPLIT);

for (int i = 0; i < tmpC.length; i++) {

String subC = "";

for (int j = 0; j < tmpC.length; j++) {

if (i != j) {

subC = subC+tmpC[j]+ITEM_SPLIT;

}

}

if (itemkFcMap.get(subC) == null) {

hasInfrequentSubSet = true;

break;

}

}

}else{

hasInfrequentSubSet=true;

}

if(!hasInfrequentSubSet){

candidateCollection.put(c, 0);

}

}

}

return candidateCollection;

}

private Map<String,Integer> getItem1FC(){

Map<String,Integer> sItem1FcMap=new HashMap<String,Integer>();

Map<String,Integer> rItem1FcMap=new HashMap<String,Integer>();//频繁1项集

for(String trans:transList){

String[] items=trans.split(ITEM_SPLIT);

for(String item:items){

Integer count=sItem1FcMap.get(item+ITEM_SPLIT);

if(count==null){

sItem1FcMap.put(item+ITEM_SPLIT, 1);

}else{

sItem1FcMap.put(item+ITEM_SPLIT, count+1);

}

}

}

Set<String> keySet=sItem1FcMap.keySet();

for(String key:keySet){

Integer count=sItem1FcMap.get(key);

if(count>=SUPPORT){

rItem1FcMap.put(key, count);

}

}

return rItem1FcMap;

}

public Map<String,Double> getRelationRules(Map<String,Integer> frequentCollectionMap){

Map<String,Double> relationRules=new HashMap<String,Double>();

Set<String> keySet=frequentCollectionMap.keySet();

for (String key : keySet) {

double countAll=frequentCollectionMap.get(key);

String[] keyItems = key.split(ITEM_SPLIT);

if(keyItems.length>1){

List<String> source=new ArrayList<String>();

Collections.addAll(source, keyItems);

List<List<String>> result=new ArrayList<List<String>>();

buildSubSet(source,result);//获得source的所有非空子集

for(List<String> itemList:result){

if(itemList.size()<source.size()){//只处理真子集

List<String> otherList=new ArrayList<String>();

for(String sourceItem:source){

if(!itemList.contains(sourceItem)){

otherList.add(sourceItem);

}

}

String reasonStr="";//前置

String resultStr="";//结果

for(String item:itemList){

reasonStr=reasonStr+item+ITEM_SPLIT;

}

for(String item:otherList){

resultStr=resultStr+item+ITEM_SPLIT;

}

double countReason=frequentCollectionMap.get(reasonStr);

double itemConfidence=countAll/countReason;//计算置信度

if(itemConfidence>=CONFIDENCE){

String rule=reasonStr+CON+resultStr;

relationRules.put(rule, itemConfidence);

}

}

}

}

}

return relationRules;

}

private  void buildSubSet(List<String> sourceSet, List<List<String>> result) {

// 仅有一个元素时，递归终止。此时非空子集仅为其自身，所以直接添加到result中

if (sourceSet.size() == 1) {

List<String> set = new ArrayList<String>();

set.add(sourceSet.get(0));

result.add(set);

} else if (sourceSet.size() > 1) {

// 当有n个元素时，递归求出前n-1个子集，在于result中

buildSubSet(sourceSet.subList(0, sourceSet.size() - 1), result);

int size = result.size();// 求出此时result的长度，用于后面的追加第n个元素时计数

// 把第n个元素加入到集合中

List<String> single = new ArrayList<String>();

single.add(sourceSet.get(sourceSet.size() - 1));

result.add(single);

// 在保留前面的n-1子集的情况下，把第n个元素分别加到前n个子集中，并把新的集加入到result中;

// 为保留原有n-1的子集，所以需要先对其进行复制

List<String> clone;

for (int i = 0; i < size; i++) {

clone = new ArrayList<String>();

for (String str : result.get(i)) {

clone.add(str);

}

clone.add(sourceSet.get(sourceSet.size() - 1));

result.add(clone);

}

}

}

public static void main(String[] args){

Apriori apriori=new Apriori();

Map<String,Integer> frequentCollectionMap=apriori.getFC();

System.out.println("----------------频繁集"+"----------------");

Set<String> fcKeySet=frequentCollectionMap.keySet();

for(String fcKey:fcKeySet){

System.out.println(fcKey+"  :  "+frequentCollectionMap.get(fcKey));

}

Map<String,Double> relationRulesMap=apriori.getRelationRules(frequentCollectionMap);

System.out.println("----------------关联规则"+"----------------");

Set<String> rrKeySet=relationRulesMap.keySet();

for(String rrKey:rrKeySet){

System.out.println(rrKey+"  :  "+relationRulesMap.get(rrKey));

}

}

}

时间： 2024-11-08 23:05:29

Apriori算法例子的相关文章

关于apriori算法的一个简单的例子

apriori算法是关联规则挖掘中很基础也很经典的一个算法,我认为很多教程出现大堆的公式不是很适合一个初学者理解.因此,本文列举一个简单的例子来演示下apriori算法的整个步骤. 下面这个表格是代表一个事务数据库D,其中最小支持度为50%,最小置信度为70%,求事务数据库中的频繁关联规则. Tid 项目集 1  面包,牛奶,啤酒,尿布 2  面包,牛奶,啤酒 3  啤酒,尿布 4  面包,牛奶,花生 apriori算法的步骤如下所示: (1)生成候选频繁1-项目集C1={{面包},{牛奶},{

机器学习（八）—Apriori算法

摘要:本文对Apriori算法进行了简单介绍,并通过Python进行实现,进而结合UCI数据库中的肋形蘑菇数据集对算法进行验证. “啤酒与尿布”的例子相信很多人都听说过吧,故事是这样的:在一家超市中,人们发现了一个特别有趣的现象,尿布与啤酒这两种风马牛不相及的商品居然摆在一起.但这一奇怪的举措居然使尿布和啤酒的销量大幅增加了.这可不是一个笑话,而是一直被商家所津津乐道的发生在美国沃尔玛连锁超市的真实案例.原来,美国的妇女通常在家照顾孩子,所以她们经常会嘱咐丈夫在下班回家的路上为孩子买尿布,而丈夫

关联规则挖掘(基本概念和Apriori算法)

关联规则挖掘的研究一直是数据挖掘领域的一个重要方向. 关联规则挖掘的目的是从大型事务数据库中挖掘出不同项目之间的关联关系 ,找出潜在的行为模式. 关联规则概念是由 Agrawal 等人在1993年率先提出的, 并随后提出了Apriori算法. 基本概念: 定义1  关联规则挖掘的事务数据库记为TDB,TDB={T1,T2,…,Tk},Tk={i1,i2,…,ip},Tk称为事务,ip称为项目. 定义2  设I={i1,i2,…,im}是TDB中全体项目组成的集合.每一个事务T是I中一组项目的集合

Apriori算法关联分析与pyhon实现

算法中核心性质:频繁项集的所有非空子集也必须是频繁的.逆反命题 也成立:如果一个项集是非频繁的,那么所有它的超集也是非频繁. 一.Apriori算法简介:  Apriori算法是一种挖掘关联规则的频繁项集算法,其核心思想是通过候选集生成和情节的向下封闭检测两个阶段来挖掘频繁项集. Apriori(先验的,推测的)算法应用广泛,可用于消费市场价格分析,猜测顾客的消费习惯:网络安全领域中的入侵检测技术:可用在用于高校管理中,根据挖掘规则可以有效地辅助学校管理部门有针对性的开展贫困助学工作:也可用在移

数据挖掘中的模式发现（二）Apriori算法

基本概念 对于A→B 支持度(support): P(A∩B),既有A又有B的概率 置信度(Confidence Strength): conf(A→B)=sup(A∪B)sup(A)=P(B|A) 即,在A发生的事件中同时发生B的概率 例如购物篮分析:牛奶?面包 例子:[支持度:3%,置信度:40%] 支持度3%:意味着3%顾客同时购买牛奶和面包 置信度40%:意味着购买牛奶的顾客40%也购买面包 候选集(Candidate itemset): 通过向下合并得出的项集. 定义为C[k]. 频繁

机器学习day16 机器学习实战Apriori算法进行关联分析

上一章学习了非监督学习的聚类,聚类算法可以将不同性质的分类分开.这两天学习了apriori算法进行关联分析,感觉是目前最难理解的一章了,并且书中还有个很坑爹的错误,作者存在很大的疏忽. Apriori算法关联分析:从大规模数据集中寻找物品间的隐含关系被称作关联分析或者关联规则学习. 关联分析应用1:我们以前学习的是根据特性进行分类或者回归预测,并没有挖掘特性之间的关系,关联分析可以用于分析数据集中特性之间的关系,可以得到哪些特性频繁的共同出现或者特性之间的关系(比如出现特性A就会很大几率出现特性

【数据挖掘技术】关联规则（Apriori算法）

一.关联规则中的频繁模式   关联规则(Association Rule)是在数据库和数据挖掘领域中被发明并被广泛研究的一种重要模型,关联规则数据挖掘的主要目的是找出: [频繁模式]: Frequent Pattern,即多次重复出现的模式和并发关系(Cooccurrence Relationships),即同时出现的关系,频繁和并发关系也称为关联(Association). 二.应用关联规则的经典案例:沃尔玛超市中“啤酒和尿不湿”的经典营销案例 购物篮分析(Basket Analysis):通

数据挖掘算法之关联规则挖掘（一）---apriori算法

关联规则挖掘算法在生活中的应用处处可见,几乎在各个电子商务网站上都可以看到其应用 举个简单的例子 如当当网,在你浏览一本书的时候,可以在页面中看到一些套餐推荐,本书+有关系的书1+有关系的书2+...+其他物品=多少￥ 而这些套餐就很有可能符合你的胃口,原本只想买一本书的你可能会因为这个推荐而买了整个套餐 这与userCF和itemCF不同的是,前两种是推荐类似的,或者你可能喜欢的商品列表 而关联规则挖掘的是n个商品是不是经常一起被购买,如果是,那个n个商品之中,有一个商品正在被浏览(有被购买的

数据挖掘十大算法--Apriori算法

一.Apriori 算法概述 Apriori 算法是一种最有影响力的挖掘布尔关联规则的频繁项集的 算法,它是由Rakesh Agrawal 和RamakrishnanSkrikant 提出的.它使用一种称作逐层搜索的迭代方法,k- 项集用于探索(k+1)- 项集.首先,找出频繁 1- 项集的集合.该集合记作L1.L1 用于找频繁2- 项集的集合 L2,而L2 用于找L2,如此下去,直到不能找到 k- 项集.每找一个 Lk 需要一次数据库扫描.为提高频繁项集逐层产生的效率,一种称作Apriori