Apriori算法

最新推荐文章于 2024-05-18 15:53:33 发布
最新推荐文章于 2024-05-18 15:53:33 发布
阅读量2.3k 收藏 8
点赞数
分类专栏： 大数据与人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangliu_w/article/details/80377407
版权

目录

Apriori算法实现... 2

一、实验背景... 2

二、算法描述... 2

1.Apriori介绍... 2

2.连接步和剪枝步... 2

3.Apriori算法的步骤... 3

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

三、 实验目的... 4

1.4

2.4

四、 实验要求... 4

五、 实验环境... 4

1.操作系统：... 4

2.编译环境：... 4

3.编程语言：... 4

六、实验实现... 5

1.程序：... 5

2.结果截屏：... 19

七、实验总结... 19

 

  Apriori算法实现 

一、实验背景 

现在, 数据挖掘作为从数据中获取信息的有效方法, 越来越受到人们的重视。1993年，Agrawal等人首先提出关联规则概念，关联规则挖掘便迅速受到数据挖掘领域专家的广泛关注.迄今关联规则挖掘技术得到了较为深入的发展。Apriori算法是关联规则挖掘经典算法。关联规则是数据挖掘的重要研究方向,它是要找出隐藏在数据间的相互关系。关联规则的挖掘问题就是在事务数据库T中找出具有用户给定的满足一定条件的最小支持度MinS和最小置信度MinC的关联规则。

二、算法描述 

1.Apriori介绍 

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

2.连接步和剪枝步 

在上述的关联规则挖掘过程的两个步骤中，第一步往往是总体性能的瓶颈。Apriori算法采用连接步和剪枝步两种方式来找出所有的频繁项集。 

连接步为找出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]}。剪枝步 CK是LK的超集，也就是说，CK的成员可能是也可能不是频繁的。通过扫描所有的事务，确定CK中每个候选的计数，判断是否小于最小支持度计数，如果不是，则认为该候选是频繁的。

3.Apriori算法的步骤 

第一步：设定最小支持度MinS和最小置信度MinC； 

第二步：Apriori算法使用候选项集。首先产生出候选的项的集合,即候选项集,若候选项集的支持度大于或等于最小支持度,则该候选项集为频繁项集； 

第三步：在Apriori算法的过程中,首先从数据库读入所有的事务,每个项都被看作候选1-项集,得出各项的支持度,再使用频繁1-项集集合来产生候选2-项集集合,因为先验原理保证所有非频繁的1-项集的超集都是非频繁的； 

第四步：再扫描数据库,得出候选2-项集集合,再找出频繁2-项集,并利用这些频繁2-项集集合来产生候选3-项集； 

第五步：重复扫描数据库,与最小支持度比较,产生更高层次的频繁项集,再从该集合里产生下一级候选项集,直到不再产生新的候选项集为止。 

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

Confidence(X->Y)=P(B|A)=support(XY)/suppor(X) 关联规则产生步骤如下： 

第一步：对于每个频繁项集l，产生其所有非空真子集； 

第二步：对于每个非空真子集s,如果support(l)/support (s)>=MinC，则输出 s->(l-s)，其中，MinC是最小置信度阈值。

三、 实验目的 

1. 学会用Apriori算法对数据进行发现频繁项集和生成关联规则的挖掘，加强对Apriori算法的理解。

2.锻炼分析问题、解决问题并动手实践的能力。

四、 实验要求 

使用一种你熟悉的程序设计语言，如C++或Java，实现Apriori算法。

五、 实验环境 

1.操作系统：

Win10 操作系统

2.编译环境：

编译器eclipse、jdk 9

3.编程语言：

Java面向对象的程序设计语言

六、实验实现

1.程序：

package com.apriori;

 

importjava.util.ArrayList;

importjava.util.Collections;

importjava.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

 

publicclass Apriori {

 

         privatefinalstaticintSUPPORT = 2; // 支持度阈值

         privatefinalstaticdoubleCONFIDENCE = 0.7; // 置信度阈值

 

         privatefinalstatic String ITEM_SPLIT=","; // 项之间的分隔符

         privatefinalstatic String CON="->"; // 项之间的分隔符

 

         privatefinalstaticList<String> transList=newArrayList<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("1,2,3,");

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

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

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

         }

 

       

         publicMap<String,Integer> getFC(){

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

 

        frequentCollectionMap.putAll(getItem1FC());

 

        Map<String,Integer> itemkFcMap=newHashMap<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){

                      booleanflag=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);

 

        }

 

        returnfrequentCollectionMap;

         }

 

       

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

                   Map<String,Integer> candidateCollection=newHashMap<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{

                                               booleanflag=true;

                    for(inti=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;

                    }

                                     }

 

                                     //进行剪枝

                                     booleanhasInfrequentSubSet = false;

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

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

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

                                                       String subC = "";

                                                       for (intj = 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);

                                     }

                            }

                   }

 

                   returncandidateCollection;

         }

 

       

         privateMap<String,Integer> getItem1FC(){

                   Map<String,Integer> sItem1FcMap=newHashMap<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);

                            }

                   }

                   returnrItem1FcMap;

         }

 

  

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

                   Map<String,Double> relationRules=newHashMap<String,Double>();

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

                   for (String key : keySet) {

                            doublecountAll=frequentCollectionMap.get(key);

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

                            if(keyItems.length>1){

                                    List<String> source=newArrayList<String>();

                                    Collections.addAll(source, keyItems);

                                    List<List<String>> result=newArrayList<List<String>>();

 

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

 

                                     for(List<String>itemList:result){

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

                           List<String> otherList=newArrayList<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;

                        }

 

                        doublecountReason=frequentCollectionMap.get(reasonStr);

                        doubleitemConfidence=countAll/countReason;//计算置信度

                        if(itemConfidence>=CONFIDENCE){

                                String rule=reasonStr+CON+resultStr;

                                relationRules.put(rule, itemConfidence);

                        }

                    }

                                     }

                            }

                   }

 

                   returnrelationRules;

         }

 

       

         private  voidbuildSubSet(List<String> sourceSet,List<List<String>> result) {

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

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

                            List<String> set = newArrayList<String>();

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

                            result.add(set);

                   } elseif (sourceSet.size() > 1){

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

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

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

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

                            List<String> single = newArrayList<String>();

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

                            result.add(single);

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

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

                            List<String> clone;

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

                                     clone = newArrayList<String>();

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

                                               clone.add(str);

                                     }

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

 

                                     result.add(clone);

                            }

                   }

         }

 

         publicstaticvoid main(String[] args){

                   Apriori apriori=new Apriori();

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

                   System.out.println("----------------------------------------");

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

                   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("----------------------------------------");

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

        System.out.println("----------------------------------------");

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

        for(String rrKey:rrKeySet){

                            System.out.println(rrKey+"  : "+"支持数："+relationRulesMap.get(rrKey));

                   }

         }

}

 

2.结果截屏：

 

七、实验总结

通过这次试验让我对数据挖掘有了进一步的认识，对数据挖掘中要解决的问题，和面临的困难有了进一步的体会，同时学会了最基本的Apriori算法，掌握了发现发现频繁集和生成关联规则的方法。关联算法基本原理学习思路简单，只需一步一步找出频集。再通过支持度算出可信度。同时也了解了一些写数据挖掘算法的一般过程，提高了自己的实践动手能和加深对java的熟练程度。

 

 目录

Apriori算法实现... 2

一、实验背景... 2

二、算法描述... 2

1.Apriori介绍... 2

2.连接步和剪枝步... 2

3.Apriori算法的步骤... 3

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

三、 实验目的... 4

1.4

2.4

四、 实验要求... 4

五、 实验环境... 4

1.操作系统：... 4

2.编译环境：... 4

3.编程语言：... 4

六、实验实现... 5

1.程序：... 5

2.结果截屏：... 19

七、实验总结... 19

 

  Apriori算法实现 

一、实验背景 

现在, 数据挖掘作为从数据中获取信息的有效方法, 越来越受到人们的重视。1993年，Agrawal等人首先提出关联规则概念，关联规则挖掘便迅速受到数据挖掘领域专家的广泛关注.迄今关联规则挖掘技术得到了较为深入的发展。Apriori算法是关联规则挖掘经典算法。关联规则是数据挖掘的重要研究方向,它是要找出隐藏在数据间的相互关系。关联规则的挖掘问题就是在事务数据库T中找出具有用户给定的满足一定条件的最小支持度MinS和最小置信度MinC的关联规则。

二、算法描述 

1.Apriori介绍 

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

2.连接步和剪枝步 

在上述的关联规则挖掘过程的两个步骤中，第一步往往是总体性能的瓶颈。Apriori算法采用连接步和剪枝步两种方式来找出所有的频繁项集。 

连接步为找出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]}。剪枝步 CK是LK的超集，也就是说，CK的成员可能是也可能不是频繁的。通过扫描所有的事务，确定CK中每个候选的计数，判断是否小于最小支持度计数，如果不是，则认为该候选是频繁的。

3.Apriori算法的步骤 

第一步：设定最小支持度MinS和最小置信度MinC； 

第二步：Apriori算法使用候选项集。首先产生出候选的项的集合,即候选项集,若候选项集的支持度大于或等于最小支持度,则该候选项集为频繁项集； 

第三步：在Apriori算法的过程中,首先从数据库读入所有的事务,每个项都被看作候选1-项集,得出各项的支持度,再使用频繁1-项集集合来产生候选2-项集集合,因为先验原理保证所有非频繁的1-项集的超集都是非频繁的； 

第四步：再扫描数据库,得出候选2-项集集合,再找出频繁2-项集,并利用这些频繁2-项集集合来产生候选3-项集； 

第五步：重复扫描数据库,与最小支持度比较,产生更高层次的频繁项集,再从该集合里产生下一级候选项集,直到不再产生新的候选项集为止。 

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

Confidence(X->Y)=P(B|A)=support(XY)/suppor(X) 关联规则产生步骤如下： 

第一步：对于每个频繁项集l，产生其所有非空真子集； 

第二步：对于每个非空真子集s,如果support(l)/support (s)>=MinC，则输出 s->(l-s)，其中，MinC是最小置信度阈值。

三、 实验目的 

1. 学会用Apriori算法对数据进行发现频繁项集和生成关联规则的挖掘，加强对Apriori算法的理解。

2.锻炼分析问题、解决问题并动手实践的能力。

四、 实验要求 

使用一种你熟悉的程序设计语言，如C++或Java，实现Apriori算法。

五、 实验环境 

1.操作系统：

Win10 操作系统

2.编译环境：

编译器eclipse、jdk 9

3.编程语言：

Java面向对象的程序设计语言

六、实验实现

1.程序：

package com.apriori;

 

importjava.util.ArrayList;

importjava.util.Collections;

importjava.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

 

publicclass Apriori {

 

         privatefinalstaticintSUPPORT = 2; // 支持度阈值

         privatefinalstaticdoubleCONFIDENCE = 0.7; // 置信度阈值

 

         privatefinalstatic String ITEM_SPLIT=","; // 项之间的分隔符

         privatefinalstatic String CON="->"; // 项之间的分隔符

 

         privatefinalstaticList<String> transList=newArrayList<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("1,2,3,");

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

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

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

         }

 

       

         publicMap<String,Integer> getFC(){

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

 

        frequentCollectionMap.putAll(getItem1FC());

 

        Map<String,Integer> itemkFcMap=newHashMap<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){

                      booleanflag=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);

 

        }

 

        returnfrequentCollectionMap;

         }

 

       

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

                   Map<String,Integer> candidateCollection=newHashMap<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{

                                               booleanflag=true;

                    for(inti=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;

                    }

                                     }

 

                                     //进行剪枝

                                     booleanhasInfrequentSubSet = false;

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

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

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

                                                       String subC = "";

                                                       for (intj = 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);

                                     }

                            }

                   }

 

                   returncandidateCollection;

         }

 

       

         privateMap<String,Integer> getItem1FC(){

                   Map<String,Integer> sItem1FcMap=newHashMap<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);

                            }

                   }

                   returnrItem1FcMap;

         }

 

  

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

                   Map<String,Double> relationRules=newHashMap<String,Double>();

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

                   for (String key : keySet) {

                            doublecountAll=frequentCollectionMap.get(key);

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

                            if(keyItems.length>1){

                                    List<String> source=newArrayList<String>();

                                    Collections.addAll(source, keyItems);

                                    List<List<String>> result=newArrayList<List<String>>();

 

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

 

                                     for(List<String>itemList:result){

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

                           List<String> otherList=newArrayList<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;

                        }

 

                        doublecountReason=frequentCollectionMap.get(reasonStr);

                        doubleitemConfidence=countAll/countReason;//计算置信度

                        if(itemConfidence>=CONFIDENCE){

                                String rule=reasonStr+CON+resultStr;

                                relationRules.put(rule, itemConfidence);

                        }

                    }

                                     }

                            }

                   }

 

                   returnrelationRules;

         }

 

       

         private  voidbuildSubSet(List<String> sourceSet,List<List<String>> result) {

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

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

                            List<String> set = newArrayList<String>();

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

                            result.add(set);

                   } elseif (sourceSet.size() > 1){

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

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

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

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

                            List<String> single = newArrayList<String>();

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

                            result.add(single);

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

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

                            List<String> clone;

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

                                     clone = newArrayList<String>();

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

                                               clone.add(str);

                                     }

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

 

                                     result.add(clone);

                            }

                   }

         }

 

         publicstaticvoid main(String[] args){

                   Apriori apriori=new Apriori();

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

                   System.out.println("----------------------------------------");

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

                   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("----------------------------------------");

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

        System.out.println("----------------------------------------");

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

        for(String rrKey:rrKeySet){

                            System.out.println(rrKey+"  : "+"支持数："+relationRulesMap.get(rrKey));

                   }

         }

}

 

2.结果截屏：

 

七、实验总结

通过这次试验让我对数据挖掘有了进一步的认识，对数据挖掘中要解决的问题，和面临的困难有了进一步的体会，同时学会了最基本的Apriori算法，掌握了发现发现频繁集和生成关联规则的方法。关联算法基本原理学习思路简单，只需一步一步找出频集。再通过支持度算出可信度。同时也了解了一些写数据挖掘算法的一般过程，提高了自己的实践动手能和加深对java的熟练程度。

 

 目录

Apriori算法实现... 2

一、实验背景... 2

二、算法描述... 2

1.Apriori介绍... 2

2.连接步和剪枝步... 2

3.Apriori算法的步骤... 3

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

三、 实验目的... 4

1.4

2.4

四、 实验要求... 4

五、 实验环境... 4

1.操作系统：... 4

2.编译环境：... 4

3.编程语言：... 4

六、实验实现... 5

1.程序：... 5

2.结果截屏：... 19

七、实验总结... 19

 

  Apriori算法实现 

一、实验背景 

现在, 数据挖掘作为从数据中获取信息的有效方法, 越来越受到人们的重视。1993年，Agrawal等人首先提出关联规则概念，关联规则挖掘便迅速受到数据挖掘领域专家的广泛关注.迄今关联规则挖掘技术得到了较为深入的发展。Apriori算法是关联规则挖掘经典算法。关联规则是数据挖掘的重要研究方向,它是要找出隐藏在数据间的相互关系。关联规则的挖掘问题就是在事务数据库T中找出具有用户给定的满足一定条件的最小支持度MinS和最小置信度MinC的关联规则。

二、算法描述 

1.Apriori介绍 

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

2.连接步和剪枝步 

在上述的关联规则挖掘过程的两个步骤中，第一步往往是总体性能的瓶颈。Apriori算法采用连接步和剪枝步两种方式来找出所有的频繁项集。 

连接步为找出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]}。剪枝步 CK是LK的超集，也就是说，CK的成员可能是也可能不是频繁的。通过扫描所有的事务，确定CK中每个候选的计数，判断是否小于最小支持度计数，如果不是，则认为该候选是频繁的。

3.Apriori算法的步骤 

第一步：设定最小支持度MinS和最小置信度MinC； 

第二步：Apriori算法使用候选项集。首先产生出候选的项的集合,即候选项集,若候选项集的支持度大于或等于最小支持度,则该候选项集为频繁项集； 

第三步：在Apriori算法的过程中,首先从数据库读入所有的事务,每个项都被看作候选1-项集,得出各项的支持度,再使用频繁1-项集集合来产生候选2-项集集合,因为先验原理保证所有非频繁的1-项集的超集都是非频繁的； 

第四步：再扫描数据库,得出候选2-项集集合,再找出频繁2-项集,并利用这些频繁2-项集集合来产生候选3-项集； 

第五步：重复扫描数据库,与最小支持度比较,产生更高层次的频繁项集,再从该集合里产生下一级候选项集,直到不再产生新的候选项集为止。 

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

Confidence(X->Y)=P(B|A)=support(XY)/suppor(X) 关联规则产生步骤如下： 

第一步：对于每个频繁项集l，产生其所有非空真子集； 

第二步：对于每个非空真子集s,如果support(l)/support (s)>=MinC，则输出 s->(l-s)，其中，MinC是最小置信度阈值。

三、 实验目的 

1. 学会用Apriori算法对数据进行发现频繁项集和生成关联规则的挖掘，加强对Apriori算法的理解。

2.锻炼分析问题、解决问题并动手实践的能力。

四、 实验要求 

使用一种你熟悉的程序设计语言，如C++或Java，实现Apriori算法。

五、 实验环境 

1.操作系统：

Win10 操作系统

2.编译环境：

编译器eclipse、jdk 9

3.编程语言：

Java面向对象的程序设计语言

六、实验实现

1.程序：

package com.apriori;

 

importjava.util.ArrayList;

importjava.util.Collections;

importjava.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

 

publicclass Apriori {

 

         privatefinalstaticintSUPPORT = 2; // 支持度阈值

         privatefinalstaticdoubleCONFIDENCE = 0.7; // 置信度阈值

 

         privatefinalstatic String ITEM_SPLIT=","; // 项之间的分隔符

         privatefinalstatic String CON="->"; // 项之间的分隔符

 

         privatefinalstaticList<String> transList=newArrayList<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("1,2,3,");

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

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

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

         }

 

       

         publicMap<String,Integer> getFC(){

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

 

        frequentCollectionMap.putAll(getItem1FC());

 

        Map<String,Integer> itemkFcMap=newHashMap<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){

                      booleanflag=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);

 

        }

 

        returnfrequentCollectionMap;

         }

 

       

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

                   Map<String,Integer> candidateCollection=newHashMap<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{

                                               booleanflag=true;

                    for(inti=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;

                    }

                                     }

 

                                     //进行剪枝

                                     booleanhasInfrequentSubSet = false;

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

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

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

                                                       String subC = "";

                                                       for (intj = 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);

                                     }

                            }

                   }

 

                   returncandidateCollection;

         }

 

       

         privateMap<String,Integer> getItem1FC(){

                   Map<String,Integer> sItem1FcMap=newHashMap<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);

                            }

                   }

                   returnrItem1FcMap;

         }

 

  

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

                   Map<String,Double> relationRules=newHashMap<String,Double>();

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

                   for (String key : keySet) {

                            doublecountAll=frequentCollectionMap.get(key);

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

                            if(keyItems.length>1){

                                    List<String> source=newArrayList<String>();

                                    Collections.addAll(source, keyItems);

                                    List<List<String>> result=newArrayList<List<String>>();

 

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

 

                                     for(List<String>itemList:result){

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

                           List<String> otherList=newArrayList<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;

                        }

 

                        doublecountReason=frequentCollectionMap.get(reasonStr);

                        doubleitemConfidence=countAll/countReason;//计算置信度

                        if(itemConfidence>=CONFIDENCE){

                                String rule=reasonStr+CON+resultStr;

                                relationRules.put(rule, itemConfidence);

                        }

                    }

                                     }

                            }

                   }

 

                   returnrelationRules;

         }

 

       

         private  voidbuildSubSet(List<String> sourceSet,List<List<String>> result) {

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

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

                            List<String> set = newArrayList<String>();

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

                            result.add(set);

                   } elseif (sourceSet.size() > 1){

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

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

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

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

                            List<String> single = newArrayList<String>();

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

                            result.add(single);

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

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

                            List<String> clone;

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

                                     clone = newArrayList<String>();

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

                                               clone.add(str);

                                     }

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

 

                                     result.add(clone);

                            }

                   }

         }

 

         publicstaticvoid main(String[] args){

                   Apriori apriori=new Apriori();

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

                   System.out.println("----------------------------------------");

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

                   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("----------------------------------------");

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

        System.out.println("----------------------------------------");

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

        for(String rrKey:rrKeySet){

                            System.out.println(rrKey+"  : "+"支持数："+relationRulesMap.get(rrKey));

                   }

         }

}

 

2.结果截屏：

 

七、实验总结

通过这次试验让我对数据挖掘有了进一步的认识，对数据挖掘中要解决的问题，和面临的困难有了进一步的体会，同时学会了最基本的Apriori算法，掌握了发现发现频繁集和生成关联规则的方法。关联算法基本原理学习思路简单，只需一步一步找出频集。再通过支持度算出可信度。同时也了解了一些写数据挖掘算法的一般过程，提高了自己的实践动手能和加深对java的熟练程度。

 

 

目录

Apriori算法实现... 2

一、实验背景... 2

二、算法描述... 2

1.Apriori介绍... 2

2.连接步和剪枝步... 2

3.Apriori算法的步骤... 3

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

三、 实验目的... 4

1.4

2.4

四、 实验要求... 4

五、 实验环境... 4

1.操作系统：... 4

2.编译环境：... 4

3.编程语言：... 4

六、实验实现... 5

1.程序：... 5

2.结果截屏：... 19

七、实验总结... 19

 

  Apriori算法实现 

一、实验背景 

现在, 数据挖掘作为从数据中获取信息的有效方法, 越来越受到人们的重视。1993年，Agrawal等人首先提出关联规则概念，关联规则挖掘便迅速受到数据挖掘领域专家的广泛关注.迄今关联规则挖掘技术得到了较为深入的发展。Apriori算法是关联规则挖掘经典算法。关联规则是数据挖掘的重要研究方向,它是要找出隐藏在数据间的相互关系。关联规则的挖掘问题就是在事务数据库T中找出具有用户给定的满足一定条件的最小支持度MinS和最小置信度MinC的关联规则。

二、算法描述 

1.Apriori介绍 

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

2.连接步和剪枝步 

在上述的关联规则挖掘过程的两个步骤中，第一步往往是总体性能的瓶颈。Apriori算法采用连接步和剪枝步两种方式来找出所有的频繁项集。 

连接步为找出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]}。剪枝步 CK是LK的超集，也就是说，CK的成员可能是也可能不是频繁的。通过扫描所有的事务，确定CK中每个候选的计数，判断是否小于最小支持度计数，如果不是，则认为该候选是频繁的。

3.Apriori算法的步骤 

第一步：设定最小支持度MinS和最小置信度MinC； 

第二步：Apriori算法使用候选项集。首先产生出候选的项的集合,即候选项集,若候选项集的支持度大于或等于最小支持度,则该候选项集为频繁项集； 

第三步：在Apriori算法的过程中,首先从数据库读入所有的事务,每个项都被看作候选1-项集,得出各项的支持度,再使用频繁1-项集集合来产生候选2-项集集合,因为先验原理保证所有非频繁的1-项集的超集都是非频繁的； 

第四步：再扫描数据库,得出候选2-项集集合,再找出频繁2-项集,并利用这些频繁2-项集集合来产生候选3-项集； 

第五步：重复扫描数据库,与最小支持度比较,产生更高层次的频繁项集,再从该集合里产生下一级候选项集,直到不再产生新的候选项集为止。 

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

Confidence(X->Y)=P(B|A)=support(XY)/suppor(X) 关联规则产生步骤如下： 

第一步：对于每个频繁项集l，产生其所有非空真子集； 

第二步：对于每个非空真子集s,如果support(l)/support (s)>=MinC，则输出 s->(l-s)，其中，MinC是最小置信度阈值。

三、 实验目的 

1. 学会用Apriori算法对数据进行发现频繁项集和生成关联规则的挖掘，加强对Apriori算法的理解。

2.锻炼分析问题、解决问题并动手实践的能力。

四、 实验要求 

使用一种你熟悉的程序设计语言，如C++或Java，实现Apriori算法。

五、 实验环境 

1.操作系统：

Win10 操作系统

2.编译环境：

编译器eclipse、jdk 9

3.编程语言：

Java面向对象的程序设计语言

六、实验实现

1.程序：

package com.apriori;

 

importjava.util.ArrayList;

importjava.util.Collections;

importjava.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

 

publicclass Apriori {

 

         privatefinalstaticintSUPPORT = 2; // 支持度阈值

         privatefinalstaticdoubleCONFIDENCE = 0.7; // 置信度阈值

 

         privatefinalstatic String ITEM_SPLIT=","; // 项之间的分隔符

         privatefinalstatic String CON="->"; // 项之间的分隔符

 

         privatefinalstaticList<String> transList=newArrayList<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("1,2,3,");

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

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

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

         }

 

       

         publicMap<String,Integer> getFC(){

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

 

        frequentCollectionMap.putAll(getItem1FC());

 

        Map<String,Integer> itemkFcMap=newHashMap<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){

                      booleanflag=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);

 

        }

 

        returnfrequentCollectionMap;

         }

 

       

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

                   Map<String,Integer> candidateCollection=newHashMap<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{

                                               booleanflag=true;

                    for(inti=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;

                    }

                                     }

 

                                     //进行剪枝

                                     booleanhasInfrequentSubSet = false;

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

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

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

                                                       String subC = "";

                                                       for (intj = 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);

                                     }

                            }

                   }

 

                   returncandidateCollection;

         }

 

       

         privateMap<String,Integer> getItem1FC(){

                   Map<String,Integer> sItem1FcMap=newHashMap<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);

                            }

                   }

                   returnrItem1FcMap;

         }

 

  

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

                   Map<String,Double> relationRules=newHashMap<String,Double>();

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

                   for (String key : keySet) {

                            doublecountAll=frequentCollectionMap.get(key);

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

                            if(keyItems.length>1){

                                    List<String> source=newArrayList<String>();

                                    Collections.addAll(source, keyItems);

                                    List<List<String>> result=newArrayList<List<String>>();

 

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

 

                                     for(List<String>itemList:result){

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

                           List<String> otherList=newArrayList<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;

                        }

 

                        doublecountReason=frequentCollectionMap.get(reasonStr);

                        doubleitemConfidence=countAll/countReason;//计算置信度

                        if(itemConfidence>=CONFIDENCE){

                                String rule=reasonStr+CON+resultStr;

                                relationRules.put(rule, itemConfidence);

                        }

                    }

                                     }

                            }

                   }

 

                   returnrelationRules;

         }

 

       

         private  voidbuildSubSet(List<String> sourceSet,List<List<String>> result) {

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

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

                            List<String> set = newArrayList<String>();

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

                            result.add(set);

                   } elseif (sourceSet.size() > 1){

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

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

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

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

                            List<String> single = newArrayList<String>();

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

                            result.add(single);

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

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

                            List<String> clone;

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

                                     clone = newArrayList<String>();

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

                                               clone.add(str);

                                     }

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

 

                                     result.add(clone);

                            }

                   }

         }

 

         publicstaticvoid main(String[] args){

                   Apriori apriori=new Apriori();

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

                   System.out.println("----------------------------------------");

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

                   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("----------------------------------------");

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

        System.out.println("----------------------------------------");

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

        for(String rrKey:rrKeySet){

                            System.out.println(rrKey+"  : "+"支持数："+relationRulesMap.get(rrKey));

                   }

         }

}

 

2.结果截屏：

 

七、实验总结

通过这次试验让我对数据挖掘有了进一步的认识，对数据挖掘中要解决的问题，和面临的困难有了进一步的体会，同时学会了最基本的Apriori算法，掌握了发现发现频繁集和生成关联规则的方法。关联算法基本原理学习思路简单，只需一步一步找出频集。再通过支持度算出可信度。同时也了解了一些写数据挖掘算法的一般过程，提高了自己的实践动手能和加深对java的熟练程度。

 

 

_4444yl
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
apriori算法
04-30
综上所述，Apriori算法是数据挖掘中的基础工具，它在关联规则挖掘中发挥着关键作用，而Java作为一门广泛应用的编程语言，为实现和优化Apriori算法提供了便利。了解并掌握这一算法及其应用，对于理解数据驱动决策的...
Apriori 算法
m0_55830167的博客
05-06 640
关联规则研究的是事务集合内部的项集与项集之间的关系，这种关系有要有两种表现形式。（3） 提升度反映了X与Y的相关性，提升度>1且越高表明正相关性越高，提升度
【机器学习】Apriori算法详解（关联规则挖掘）
最新发布
酒酿小圆子呀～
05-18 831
Apriori 算法是最为经典的关联规则挖掘算法之一。关于关联规则有个很常见的例子：啤酒与尿布。沃尔玛在分析销售记录时，发现啤酒和尿布经常一起被购买，于是他们调整了货架，把两者放在一起，结果真的提升了啤酒的销量。关联规则分析也称为购物篮分析，最早是为了发现超市销售数据库中不同的商品之间的关联关系。关联规则是反映一个事物与其他事物之间的关联性，若多个事物之间存在着某种关联关系，那么其中的一个事物就能通过其他事物预测到。这里要注意，关联规则不是因果关系，有可能有因果关系，有可能没有。定义 1。
【Apriori算法】
欢迎来到zrh的博客
09-12 561
在计算机科学以及数据挖掘领域中，先验算法（Apriori Algorithm）是关联规则学习的经典算法之一。先验算法采用广度优先搜索算法进行搜索并采用树结构来对候选项集进行高效计数。通过长度为k-1的候选项集来产生长度为k的候选项集，然后从中删除包含不常见子模式的候选项。根据向下封闭性引理，该候选项目集包含所有长度为k的频繁项目集。之后，就可以通过扫描交易数据库来决定候选项目集中的频繁项目集。
apriori算法 c语言,数据挖掘算法——Apriori算法
weixin_35697651的博客
05-20 2830
Apriori算法首先，Apriori算法是关联规则挖掘中很基础也很经典的一个算法。转载来自：链接：https://www.jianshu.com/p/26d61b83492e所以做如下补充：关联规则：形如X→Y的蕴涵式，其中， X和Y分别称为关联规则的先导(antecedent或left-hand-side, LHS)和后继(consequent或right-hand-side, RHS) 。...
Apriori算法原理
weixin_56273009的博客
05-28 2175
实验环境 python 3.6.5 jupyter 【原理】Apriori算法原理 Apriori算法是一种用于关联规则挖掘的代表性算法。从本节开始，我们已经进入了机器学习和数据挖掘相交叉的地带。 数据挖掘与机器学习 数据挖掘和机器学习的关系就好比，机器学习是数据挖掘的弹药库中一类相当庞大的弹药集。既然是一类弹药，其实也就是在说数据挖掘中肯定还有其他非机器学习范畴的技术存在。Apriori算法就属于一种非机器学习的数据挖掘技术。 在非机器学习的数据挖掘技术中，我们并不会去建立
Apriori算法详解
ZHT2016iot的博客
06-06 9170
一 相关概念 1.频繁项集挖掘 支持率： 一个项集III在事务集合Γ={T1,T2,…,Tn}\Gamma=\begin{Bmatrix}T_1,T_2,\ldots,T_n\end{Bmatrix}Γ={T1​,T2​,…,Tn​​}中包含子集III的事务占全体事务的比例称之为支持率。 事务序号 项集 1 {A,B,E} 2 {D,E,F} 3 {A,C,D,E} 4 {D,E,F} 5 {C,E,F} 在上述事务集合中，项集{A,E}的支持率是2/5=0.4,项集{E
Apriori算法实现
ZShiJ的博客
02-07 1263
大多数关联规则挖掘算法通常采用的一种策略是，将关联规则挖掘任务分解为如下两个主要的子任务：①频繁项集产生（Frequent Itemset Generation），其目标是发现满足最小支持度阈值的所有项集，这些项集称作频繁项集。②规则的产生（Rule Generation），其目标是从上一步发现的频繁项集中提取所有高置信度的规则，这些规则称作强规则。关联分析的目标：发现频繁项集和由频繁项集产生强关联规则，这些规则必须大于或等于最小支持度和最小置信度。
python apriori算法实例
12-25
Apriori算法是关联规则学习中最经典的算法之一，它由R. Agrawal和R. Srikant于1994年提出。本实例将探讨如何在Python中实现Apriori算法，以发现给定数据集中频繁项集。 **Apriori算法的核心思想：** Apriori算法...
APRIORI算法带数据集.rar_Apriori_Apriori算法_amountaps_matlab
07-14
利用APRIORI算法找出频繁集，计算置信度与支持度，支持多种格式的数据
Apriori算法python实现含数据集
04-01
在数据分析和数据挖掘领域，Apriori算法是一个经典且重要的概念。它主要用于发现数据库中物品集之间的关联规则，这些规则可以揭示项目之间的隐藏关系。在本篇内容中，我们将深入探讨Apriori算法的原理、Python实现...
Apriori算法讲解
07-09
Apriori算法应用于网络安全领域，比如入侵检测技术中。早期中大型的电脑系统中都收集审计信息来建立跟踪档，这些审计跟踪的目的多是为了性能测试或计费，因此对攻击检测提供的有用信息比较少。它通过模式的学习和...
Apriori算法python实现
08-07
Apriori算法是一种经典的关联规则学习算法，广泛应用于数据挖掘中的频繁项集发现。这个算法由R. Agrawal和R. Srikant在1994年提出，主要用于找出数据库中项集之间的有趣关系，比如购物篮分析中的商品组合。Python...
Apriori算法完整Java代码
11-19
Apriori算法是一种经典的关联规则学习算法，最早由R Agrawal和R Srikant在1994年提出。它的主要目标是从交易数据库中发现有趣的频繁项集和关联规则。这些规则可以揭示不同商品之间的购买行为关联，帮助商家制定营销...
Apriori算法及其实现
04-16
Apriori算法是一种经典的关联规则挖掘算法，它主要用于发现数据集中项集之间的频繁模式和强关联规则。在商业智能、市场分析、医学诊断等领域，Apriori算法的应用极为广泛，因为它能够帮助决策者从海量数据中提取出有...
Apriori_Apriori算法_
09-29
Apriori算法是一种在数据挖掘领域广泛使用的关联规则学习算法，尤其在市场篮子分析中十分常见。这个算法的核心思想是发现数据库中频繁项集，进而挖掘出有趣的关联规则。在给定的压缩包文件中，包含了一个名为`...
Apriori算法（基于Python编程语言实现）
04-06
Apriori算法是一种挖掘关联规则的频繁项集算法，其核心思想是通过候选集生成和情节的向下封闭检测两个阶段来挖掘频繁项集。而且算法已经被广泛的应用到商业、网络安全等各个领域。 该算法的基本思想 是:首先找出所有...
apriori 算法
09-10
Apriori算法是一种经典的挖掘频繁项集和关联规则的数据挖掘算法。其名字来源于拉丁语中的"来自以前"，因为该算法使用了频繁项集的先验性质。Apriori算法通过扫描数据库，累计每个项的计数，并收集满足最小支持度的项，找出频繁1项集的集合L1。然后，使用L1找出频繁2项集的集合L2，使用L2找出L3，如此下去，直到不能再找到频繁k项集。每找出一个Lk需要一次数据库的完整扫描。Apriori算法使用频繁项集的先验性质来压缩搜索空间。 Apriori算法的优点是易于编码实现。然而，它也有一些缺点。在大数据集上，Apriori算法可能相对较慢。另外，它适用于数值型或者标称型数据。 总之，Apriori算法是一种经典的关联分析算法，用于挖掘频繁项集和关联规则。它使用频繁项集的先验性质来进行搜索，通过逐层搜索的迭代方法找出频繁项集。虽然Apriori算法易于实现，但在大数据集上可能较慢，并且适用于数值型或标称型数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值