Apriori算法实验报告及程序

合集下载

Apriori算法研究

Apriori算法研究

精心整理Apriori算法研究Apriori算法是一个挖掘关联规则的算法,是Agrawal等设计的一个基本算法。

它采用两阶段挖掘的思想,并且基于多次扫描事务数据库来执行。

1.关联规则1.1.Y ,其中BA 满1.2.第一,找出所有的频繁项集;其目标是发现满足最小支持度阈值的所有项集,这些项集称作频繁项集。

第二,由频繁项集产生强规则。

其目标是从上一步发现的频繁项集中提取所有高置信度的规则,这些规则称为强规则。

通常,频繁项集产生的计算开销远大于产生规则所需的计算开销。

2.Apriori算法思想Apriori 算法使用频繁项集的先验知识,使用一种称作逐层搜索的迭代方法,k 项集用于探索(k+1) 项集。

首先,通过扫描事务(交易)记录,找出所有的频繁 1 项集,该集合记做L1 ,然后利用L1 找频繁 2 项集的集合L2 ,L2 找L3 ,如此下去,直到不能再找到任何频繁k 项集。

最后再在所有的频繁集中找出强规则,即(3.1.1.从事务数据库(D)中挖掘出所有频繁项集。

支持度大于最小支持度minSup的项集(Itemset)称为频集(Frequent Itemset)。

首先需要挖掘出频繁1-项集;然后,继续采用递推的方式来挖掘频繁k-项集(k>1),具体做法是:在挖掘出候选频繁k-项集(Ck)之后,根据最小置信度minSup 来筛选,得到频繁k-项集。

最后合并全部的频繁k-项集(k>0)。

挖掘频繁项集的算法描述如下:算法Apriori算法的频繁集产生1:L1 = find_frequent_1-itemsets(D); // 挖掘频繁1-项集,比较容易2:f or (k=2;Lk-1 ≠Φ;k++) {3:Ck = apriori_gen(Lk-1 ,min_sup); // 调用apriori_gen方法生成候选频繁k-项集4:for each transaction t ∈D { // 扫描事务数据库D5:Ct = subset(Ck,t);6:for each candidate c ∈Ct7: c.count++; // 统计候选频繁k-项集的计数8:}9:Lk ={c ∈Ck|c.count≥min_sup} // 满足最小支持度的k-项集即为频繁k-项集10:}11:r eturn L= ∪k Lk; // 合并频繁k-项集(k>0)Apriori算法的频繁项集产生的部分有两个重要的特点:第一,它是一个逐层算法,即从频繁1-项集到最长的频繁项集,它每次遍历项集格中的一层;第二,它使用产生-测试策略来发现频繁项集。

Apriori算法实验报告及程序

Apriori算法实验报告及程序

Apriori算法实验陈述之五兆芳芳创作学号:姓名:专业:计较机应用技巧教师:计较机学院目录1 Apriori实验1.1 实验布景现在, 数据挖掘作为从数据中获得信息的有效办法, 越来越受到人们的重视.联系关系法则挖掘首先是用来发明购物篮数据事务中各项之间的有趣联系.从那以后, 联系关系法则就成为数据挖掘的重要研究标的目的,它是要找出隐藏在数据间的相互关系.目前联系关系法则挖掘的研究任务主要包含:Apriori算法的扩展、数量联系关系法则挖掘、联系关系法则增量式更新、无须生成候选项目集的联系关系法则挖掘、最大频繁项目集挖掘、约束性联系关系法则挖掘以及并行及散布联系关系法则挖掘算法等.联系关系法则的挖掘问题就是在事务数据库D中找出具有用户给定的满足一定条件的最小支持度Minsup和最小置信度Minconf的联系关系法则.1.1.1 国际外研究概略1993年,Agrawal等人首先提出联系关系法则概念,联系关系法则挖掘便迅速受到数据挖掘领域专家的普遍存眷.迄今联系关系法则挖掘技巧得到了较为深入的成长.Apriori算法是联系关系法则挖掘经典算法.针对该算法的缺点,许多学者提出了改良算法,主要有基于哈希优化和基于事务压缩等.1.1.2 成长趋势联系关系法则挖掘作为数据挖掘的重要研究内容之一, 主要研究事务数据库、关系数据库和其他信息存储中的大量数据项之间隐藏的、有趣的纪律.联系关系法则挖掘最初仅限于事务数据库的布尔型联系关系法则, 近年来普遍应用于关系数据库, 因此, 积极开展在关系数据库中挖掘联系关系法则的相关研究具有重要的意义.近年来,已经有良多基于Apriori算法的改良和优化.研究者还对数据挖掘的理论进行了有益的探索,将概念格和粗糙集应用于联系关系法则挖掘中,取得了显著的效果.到目前为止,联系关系法则的挖掘已经取得了令人瞩目的成绩,包含:单机情况下的联系关系法则挖掘算法;多值属性联系关系法则挖掘;联系关系法则更新算法;基于约束条件的联系关系法则挖掘;联系关系法则并行及散布挖掘算法等.1.2 实验内容与要求1.2.1 实验内容编程实现Apriori算法:要求使用‘a’,‘b’,‘c’,‘d’,‘e’,‘f’,‘g’,‘h’,‘i’,‘j’10个项目随机产生数据记实并存入数据库.从数据库读取记实进行Apriori实验,取得频繁集以及联系关系法则,实现可视化.并用课堂上PPT的实例测试其正确性.1.2.2 实验要求1、程序结构:包含前台东西和数据库;2、设定项目种类为10个,随机产生事务,生成数据库;3、正确性验证(可用课堂上的例子);4、算法效率的研究:在支持度固定数据量不合的时候丈量运行时间;在数据量固定,支持度不合的时候丈量运行时间;5、注意界面的设计,输入最小支持度和最小可信度,能够输出并显示频繁项目集以及联系关系法则.1.2.3 实验目的1、增强对Apriori算法的理解;2、锻炼阐发问题、解决问题并动手实践的能力.2 Apriori算法阐发与实验情况2.1 Apriori算法的描述Apriori算法是一种找频繁项目集的根本算法.其基来源根底理是逐层搜索的迭代:频繁K项Lk 集用于搜索频繁(K+1)项集Lk+1,如此下去,直到不克不及找到维度更高的频繁项集为止.这种办法依赖连接和剪枝这两步来实现.算法的第一次遍历仅仅计较每个项目的具体值的数量,以确定大型l项集.随后的遍历,第k次遍历,包含两个阶段.首先,使用在第(k-1)次遍历中找到的大项集Lk-1和产生候选项集Ck.接着扫描数据库,计较Ck中候选的支持度.用Hash树可以有效地确定Ck中包含在一个给定的事务t中的候选.如果某项集满足最小支持度, 则称它为频繁项集.2.2 Apriori算法的步调步调如下:1、设定最小支持度s和最小置信度c;2、Apriori算法使用候选项集.首先产生出候选的项的荟萃,即候选项集,若候选项集的支持度大于或等于最小支持度,则该候选项集为频繁项集;3、在Apriori算法的进程中,首先从数据库读入所有的事务,每个项都被看作候选1-项集,得出各项的支持度,再使用频繁1-项集荟萃来产生候选2-项集荟萃,因为先验原理包管所有非频繁的1-项集的超集都是非频繁的;4、再扫描数据库,得出候选2-项集荟萃,再找出频繁2-项集,并利用这些频繁2-项集荟萃来产生候选3-项集;5、重复扫描数据库,与最小支持度比较,产生更高条理的频繁项集,再从该荟萃里产生下一级候选项集,直到不再产生新的候选项集为止.2.3 开发情况2.3.1 软件情况(1)编程软件:Jdk开发包+eclipse集成开发情况Eclipse 是一个开放源代码的、基于Java的可扩展开发平台.就其自己而言,它只是一个框架和一组办事,用于通过插件组件构建开发情况.幸运的是,Eclipse 附带了一个尺度的插件集,包含Java开发东西(Java Development Kit,JDK).(2)数据库软件:SQL Server 2008SQL Server 2008 在Microsoft的数据平台上宣布,可以组织办理任何数据.可以将结构化、半结构化和非结构化文档的数据直接存储到数据库中.可以对数据进行查询、搜索、同步、陈述和阐发之类的操纵.数据可以存储在各类设备上,从数据中心最大的办事器一直到桌面计较机和移动设备,它都可以控制数据而不必管数据存储在哪里.(3)办公软件:Excel 2010Excel是一款办公软件.它是微软办公套装软件office的重要的组成部分,它是集统计阐发、数据处理和帮助决策等功效于一身,现在金融、统计财经、办理等众多领域普遍应用.本实验主要用来为固定数据量改动最小支持数以及固定最小支持数改动数据量两种情况进行时间阐发提供可视化图表.2.3.2 硬件情况装有Windows 7 旗舰版电脑.2.4 本章小结本章的内容主要是为了引出本实验的主要算法以及对算法的实现情况做了介绍.3 算法的设计3.1 Apriori图3.1 Apriori实验流程图3.2 主要的数据结构与函数3.2.1 数据结构class Transaction{public int pid;public String itemset;}该类暗示表中的一条记实.class Dao{public ArrayList<Transaction> Query(String sql)}该类用于拜访数据库操纵.class Kfp{public char kfpstr[]=new char[Apriori.ITEMSIZE];public int index=-1;public int support=0;public boolean isfp=true;}该类代表一个频繁项目.3.2.2 主要的程序Java 中最经常使用的荟萃类是List 和Map. List 的具体实现包含ArrayList 和Vector,它们是可变大小的列表,比较适合构建、存储和操纵任何类型对象的元素列表. List 适用于按数值索引拜访元素的情形.HashMap:Map接口的经常使用实现类,系统<key,value>当成一个整体进行处理,系统总是按照Hash算法来计较<key,value>的存储位置,这样可以包管能快速存、取 Map的<key,value>对.ArrayList<Transaction> alTransactions:保管表中的所有记实ArrayList<Kfp> alKfpsl:临时存储频繁项目的荟萃,存储连接后的结果ArrayList<Kfp> SureFpset:保管频繁k项集ArrayList<Kfp> SureFpsetPrio:保管频繁k-1项集ArrayList<String> notFpList:保管一定不是频繁项目的荟萃,用于剪枝HashMap<String, Integer> KfpSuppor:频繁项目集及其对应的支持数HashMap<String,Double> guanlianguize:联系关系法则及其置信度3.2.3 连接与剪枝操纵对于连接操纵的两个字符串(长度为k),它们必须有k-1个相同的字符才干做连接操纵.例如:abc和abd可以连接成abcd,abd和bcd可以连接成abcd,而abc和ade就不成以做连接操纵.整个连接进程类似合并排序中的合并操纵对于任一频繁项目集的所有非空子集也必须是频繁的,反之,如果某个候选的非空子集不是频繁的,那么该候选集肯定不是频繁的,将其剪枝.3.3 本章小结本章主要介绍了算法设计的整体流程并且也对主要程序和操纵作了扼要的说明.4 数据库的设计与数据的来源本实验的数据均存储于数据库中.数据库yuzm中共产生6张表.表test为测试用表,用于程序的正确性验证.还有5张表存储随机产生的实验数据.其中数据库的结构如下图所示.图4.1 数据库结构表test为PPT上的实例,用于正确性验证.数据的item个数为5,其中的九行数据均由SQL语句产生,表的每一行都是一个“0”“1”的字符串,字符串长度等于商品种类,其中“0”暗示该商品不存在,“1”暗示该商品存在.表的全部数据如图4.2.图4.2 表test4.2 实验数据5张表是通过算法随机产生的具有不合数据量的数据集,假定商品种类为10种,表的每一行都是一个“0”“1”的字符串,字符串长度等于商品种类,其中“0”暗示该商品不存在,“1”暗示该商品存在.其中表data1共随机产生1万行数据,表data2产生5万行数据,表data3产生25万行数据,表data4产生50万行数据,表data5产生75万行数据.部分数据如图4.3.图4.3 实验用表(部分)4.3 本章小结本章主要对数据库的设计与数据来源做出了说明.5 实验结果与性能阐发5.1 Apriori实验界面其中可信度可自由设置,默认为0.7.而支持度记为最小支持度与数据量的比例.实验数据可以下拉选择6张表中的任意一张.如下图所示:5.2 实验的正确性验证运行程序,我们选择表test,便可进行正确性验证,实验结果如下图:最终实验结果与ppt的结果相吻合,标明程序编写正确.5.3 实验性能阐发为了对本程序的实验进行性能阐发,我们辨别采取固定数据量改动最小支持数以及固定最小支持数改动数据量两种情况进行时间阐发,其中最小置信度设为0.7不变.设支持度为0.2,最小可信度为0.7.具体实验数据量与执行时间如下:数据量(万行) 1 5 25 50 75时间(秒)图5.3 数据量对性能的影响设实验数据量固定改动最小支持度,具体如下所示:最小支持度49时间(秒/ 1万)时间(秒/ 5万)时间(秒/ 25万)图5.4 最小支持度对性能的影响由以上实验我们可以看出,实验时间会随着数据量的增大而增大,并且随着最小支持度的增大而减小.并且他们之间的变更类似于某种指数函数的变更趋势.Apriori的时间主要消耗在4个方面:1、利用K频繁集连接产生K+1候选集时,判断连接的条件时比较的次数太多.假定项集个数为m的频繁荟萃Lk,判断连接条件时比较的时间庞杂度为O(K*m2).并且本实验的m都很大;2、对Ck中任意的一个c的k个(k-1)子集是否都在Lk-1中.在平均情况下,对所有候选k项集需要扫描次数为|Ck|*|Lk-1|*k/2;3、为了得到所有的候选频集的支持度,需要扫描N次;4、扫描一次数据库需时间O(k|T|).|T|为买卖数量,k买卖长度5.4 本章小结Apriori算法因自身需要多次扫描数据库,并且经过庞杂的连接剪枝操纵而产生大量候选集以及进行大量的模式匹配计较的缺陷,使得其在I/O上的破费时间良多,从而导致算法的效率不是太高.6 总结与体会通过本次实验,让我明白了什么是Apriori算法和数据之间的联系关系性,Apriori 算法是一种最有影响的挖掘布尔联系关系法则频繁项集的算法,为以落后步学习数据挖掘知识打下了良好的根本.同时我也加倍深刻理解了Apriori算法的原理及其实现的内部细节,同时通过实现这一经典的数据挖掘算法,也让我更深刻的体会到数据挖掘对于知识发明的重要性,尽管实现了算法,但其中可能还有可以改良的地方,尤其是程序的运行效率方面.Apriori算法实验不但使得我对该算法的理解加倍上升了一个条理,同时也使得我加倍了解了java编程语言,使用加倍得心应手.import java.awt.BorderLayout;import java.awt.Font;import java.awt.GridLayout;import java.awt.Panel;import java.awt.TextArea;import java.awt.TextField;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.util.ArrayList;import java.util.HashMap;import java.util.Iterator;import java.util.Set;import javax.swing.JButton;import javax.swing.JComboBox;import javax.swing.JFrame;import javax.swing.JLabel;import javax.swing.JPanel;import javax.swing.JTextField;import org.omg.CORBA.PUBLIC_MEMBER;public class Apriori extends JFrame implements ActionListener{//////////////////////////////////////////////////////public static int ITEMSIZE=10;public final int FRAMEWIDTH=800;public final int FRAMEHEIGHT=600;///////////////////////////////////////////////////////JPanel up=null;JPanel up_up=null;TextField textFieldName[]=null;JPanel up_down=null;JPanel up_down_left=null;JLabel conflabel=null;JLabel c1=null;JLabel c2=null;JLabel c3=null;JLabel c4=null;JLabel c5=null;JLabel c6=null;JLabel c7=null;JLabel c8=null;JTextField conf=null;JLabel supportlabel=null;JTextField support=null;JPanel up_down_right=null;JComboBox jComboBoxDateSize=null;//下拉框JButton jButtonMine=null;JPanel down=null;TextArea textArea=null;int fpstep=1;int fpindex=0;Dao dao=null;double MinSupport=0.20;double MinConfi=0.70;double DateSize=9.0;ArrayList<Transaction> alTransactions=null;ArrayList<Kfp> alKfps=null;ArrayList<String> notFpList=null;ArrayList<Kfp> SureFpset=null;ArrayList<Kfp> SureFpsetPrio=null;HashMap<String, Integer> KfpSupport=null;ArrayList<String> alsurekfpstr=null;HashMap<String,Double> guanlianguize=null;ArrayList<String> isaddarrStrings=null;int [][]AuxArr=null;public static void main(String[] args){Apriori A=new Apriori();}public Apriori(){JPanel up=new JPanel(new GridLayout(2, 1));JPanel up_up=new JPanel(new GridLayout(1, ITEMSIZE)); //TextField textFieldName[]=new TextField[ITEMSIZE]; //for(int i=0;i<ITEMSIZE;i++)//{//textFieldName[i]=new TextField();//up_up.add(textFieldName[i]);//}c1=new JLabel(" 数");up_up.add(c1);c2=new JLabel(" 据");up_up.add(c2);c3=new JLabel(" 挖");up_up.add(c3);c4=new JLabel(" 掘");up_up.add(c4);c5=new JLabel(" 实");up_up.add(c5);c6=new JLabel(" 验");up_up.add(c6);c7=new JLabel(" --------");up_up.add(c7);c8=new JLabel(" Apriori");up_up.add(c8);up_down=new JPanel(new GridLayout(1, 2));up_down_left=new JPanel(new GridLayout(1, 4));conflabel=new JLabel("可信度:");conf=new JTextField();conf.setText("0.7");supportlabel=new JLabel("支持度:");support=new JTextField();support.setText("0.2");up_down_left.add(conflabel);up_down_left.add(conf);up_down_left.add(supportlabel);up_down_left.add(support);up_down_right=new JPanel(new GridLayout(1, 2)); jComboBoxDateSize=new JComboBox();//下拉框jComboBoxDateSize.addItem("test"); jComboBoxDateSize.addItem("data1"); jComboBoxDateSize.addItem("data2"); jComboBoxDateSize.addItem("data3"); jComboBoxDateSize.addItem("data4"); jComboBoxDateSize.addItem("data5"); jComboBoxDateSize.addActionListener(this);jButtonMine=new JButton("开始挖掘");jButtonMine.addActionListener(this);up_down_right.add(jComboBoxDateSize);up_down_right.add(jButtonMine);up_down.add(up_down_left);up_down.add(up_down_right);up.add(up_up);up.add(up_down);down=new JPanel(new BorderLayout()) ;textArea=new TextArea();//textArea.setFont(new Font(Font.DIALOG,Font.ITALIC , 20)); textArea.setFont(new Font(Font.DIALOG,Font.PLAIN , 20));down.add(textArea);this.setLayout(new BorderLayout());this.setSize(FRAMEWIDTH, FRAMEHEIGHT);this.setLocation(100, 100);this.setSize(this.FRAMEWIDTH, this.FRAMEHEIGHT);this.setDefaultClo搜索引擎优化peration(JFrame.EXIT_ON_CLOSE); this.setTitle("Apriori");//up.setSize(this.FRAMEWIDTH, 100);this.add(up,BorderLayout.NORTH);//down.setLocation(0, 100);//down.setSize(this.FRAMEWIDTH, this.FRAMEHEIGHT-100);this.add(down);this.setVisible(true);}public void InitDate(String table){fpstep=1;AuxArr=new int[ITEMSIZE+1][ITEMSIZE+1];alKfps=new ArrayList<Kfp>();notFpList=new ArrayList<String>();SureFpset=new ArrayList<Kfp>();SureFpsetPrio=new ArrayList<Kfp>();dao=new Dao();KfpSupport=new HashMap<String, Integer>();alsurekfpstr=new ArrayList<String>();guanlianguize=new HashMap<String,Double>();isaddarrStrings=new ArrayList<String>();alTransactions=dao.Query("select * from "+table);this.DateSize=alTransactions.size();}public void ShowkFp(ArrayList<Kfp> SureFpset){int steptemp=fpstep;textArea.append("频繁"+(steptemp)+"项集\r\n");//System.out.println();for(int i=0;i<SureFpset.size();i++){Kfp k=SureFpset.get(i);int tempindex=k.index;String string=String.copyValueOf(k.kfpstr, 0, ++tempindex);int support=KfpSupport.get(string);textArea.append(string+"-----"+support+"-----"+support/DateSize+"\r\n"); //System.out.println(string+"\r\n");}}public void ShowkFp2(HashMap<String,Double> SureFpset){textArea.append("联系关系法则\r\n");Set<String> keys=(Set<String>) SureFpset.keySet();for(String keyString:keys){textArea.append(keyString+"-----------"+SureFpset.get(keyString)+"\r\n");; }}public void DataMine(){int fpsteptemp=0;if(fpstep == 1){for(int i=0;i<Apriori.ITEMSIZE;i++){Kfp kfp=new Kfp();kfp.kfpstr[++kfp.index]=(char) ('a'+i);kfp.support=0;kfp.isfp=false;alKfps.add(kfp);}DealSupport();SaveNotFpBySupport();SaveSureFp();ShowkFp(alKfps);fpstep++;}while(!alKfps.isEmpty()){alKfps.clear();for (int i = 0; i < SureFpset.size(); i++){Kfp k1 = SureFpset.get(i);for (int j = i + 1; j < SureFpset.size(); j++){Kfp k2 = SureFpset.get(j);Kfp resultKfp = Joint(k1, k2);int tempindex=resultKfp.index;String string=String.copyValueOf(resultKfp.kfpstr, 0, ++tempindex);if(string.charAt(0) == 0)continue;SubSet subSet= new SubSet();ArrayList<String> alStrings=subSet.displaySubSet1(string.toCharArray()); int p=0;for(;p<alStrings.size();p++){String string2=alStrings.get(p);if(notFpList.contains(string2))break;}if(p != alStrings.size())continue;if (!isaddarrStrings.contains(string)) {isaddarrStrings.add(string);alKfps.add(resultKfp);}}}SureFpsetPrio.clear();for(int i=0;i<SureFpset.size();i++)SureFpsetPrio.add(SureFpset.get(i));Guanlianguize();SureFpset.clear();DealSupport();SaveNotFpBySupport();// Cut();if (!alKfps.isEmpty()){SaveSureFp();ShowkFp(SureFpset);}fpstep++;}}public void Guanlianguize(){for(int i=0;i<SureFpsetPrio.size();i++){Kfp k=SureFpsetPrio.get(i);int len = k.index;String string=String.copyValueOf(k.kfpstr, 0, len+1);if(!alsurekfpstr.contains(string))alsurekfpstr.add(string);}SubSet s=new SubSet();for(int i=0;i<alsurekfpstr.size();i++){String kfpstr=alsurekfpstr.get(i);char []kfpchararr=kfpstr.toCharArray();ArrayList<String> aList=s.SubSet3(kfpchararr,kfpstr.length());for(int j=0;j<aList.size();j++){String guizetemp="";String kfpstr1=aList.get(j);char []kfpchararr1=kfpstr1.toCharArray();int indexinkfp=0;int indexinchararr1=0;while(indexinkfp < kfpchararr.length && indexinchararr1 < kfpchararr1.length) {if(kfpchararr1[indexinchararr1] != kfpchararr[indexinkfp]){guizetemp=guizetemp+kfpchararr[indexinkfp];indexinkfp++;}{indexinchararr1++;indexinkfp++;}}while(indexinkfp < kfpchararr.length)guizetemp=guizetemp+kfpchararr[indexinkfp++];double support1=(double)KfpSupport.get(kfpstr);double support2=(double)KfpSupport.get(kfpstr1);if(support1/support2 > MinConfi){String temp=kfpstr1+"-------->"+guizetemp;guanlianguize.put(temp,support1/support2);}}}ShowkFp2(guanlianguize);alsurekfpstr.clear();guanlianguize.clear();}public Kfp Joint(Kfp k1,Kfp k2){Kfp resultKfp=new Kfp();int temp_len=k1.index+1;char temp1[]=new char[temp_len];char temp2[]=new char[temp_len];for(int i=0;i<=k1.index;i++){temp1[i]=k1.kfpstr[i];temp2[i]=k2.kfpstr[i];}SubSet s=new SubSet();ArrayList<String> alStrings1=s.SubSet2(temp1,fpstep);ArrayList<String> alStrings2=s.SubSet2(temp2,fpstep);char result[]=new char[temp_len+1];boolean flag=false;for(int i=0;i<alStrings1.size();i++){String tempstr=alStrings1.get(i);if(alStrings2.contains(tempstr)){int p=0;int q=0;int j=0;while(p != temp1.length && q != temp2.length){if( p != temp1.length && q != temp2.length && temp1[p] > temp2[q]) {result[j++]=temp2[q];}if(p != temp1.length && q != temp2.length && temp1[p] == temp2[q]){result[j++]=temp2[q];q++;p++;}if(p != temp1.length && q != temp2.length && temp1[p] < temp2[q]){result[j++]=temp1[p];p++;}}if(p < temp1.length){while(p!=temp1.length)result[j++]=temp1[p++];}if(q < temp2.length){//System.out.println("fpstep="+fpstep+","+"j="+j+","+"q="+q+","+"temp_len="+temp_l en);while(q!=temp2.length)result[j++]=temp2[q++];}flag=true;}if(flag == true)break;}for(int i=0;i<temp_len+1;i++){resultKfp.kfpstr[++resultKfp.index]=result[i];}return resultKfp;}public void DealSupport(){int len=alTransactions.size();for(int i=0;i<len;i++){Transaction t=alTransactions.get(i);String itemset=t.itemset;int num=0;char []tempchar=new char[ITEMSIZE];for(int i1=0;i1<itemset.length();i1++){。

apriori算法的关键步骤

apriori算法的关键步骤

apriori算法的关键步骤Apriori算法是一种常用的关联规则挖掘算法,用于发现数据集中的频繁项集。

它是基于频繁项集的先验性质来减少搜索空间,从而提高算法的效率。

Apriori算法的关键步骤主要包括:数据预处理、生成候选项集、计算支持度、生成频繁项集。

下面将逐一介绍这些步骤。

一、数据预处理在使用Apriori算法之前,需要对数据进行预处理。

这包括去除重复数据、处理缺失值、转换数据格式等操作。

数据预处理的目的是为了提高算法的准确性和效率。

二、生成候选项集Apriori算法通过迭代生成候选项集,然后对候选项集进行支持度计数,从而找出频繁项集。

生成候选项集的过程中,首先生成1-项集,即单个项的集合。

然后根据频繁(k-1)-项集,生成候选k-项集。

生成候选k-项集的方法是将频繁(k-1)-项集两两组合,然后进行剪枝操作,去掉不满足Apriori性质的项集。

三、计算支持度计算候选项集的支持度是为了判断其是否为频繁项集。

支持度是指某个项集在数据集中出现的频率。

通过扫描数据集,统计候选项集在数据集中出现的次数,然后将次数除以数据集的大小,得到支持度。

四、生成频繁项集根据支持度计算的结果,可以得到频繁项集。

频繁项集是指支持度大于等于最小支持度阈值的项集。

在Apriori算法中,通过不断迭代生成候选项集、计算支持度,直到不能再生成新的候选项集为止。

最终得到的频繁项集即为算法的输出结果。

Apriori算法的关键步骤如上所述,下面将通过一个示例来说明算法的具体过程。

假设有一个交易数据集,其中包含多个交易记录,每个交易记录由一组项组成。

现在我们要使用Apriori算法来找出频繁项集。

1. 数据预处理首先对数据进行预处理,去除重复数据、处理缺失值等操作。

假设经过预处理后的数据集如下:```交易1:{牛奶, 面包, 尿布}交易2:{可乐, 面包, 尿布, 啤酒}交易3:{牛奶, 尿布, 啤酒, 鸡蛋}交易4:{牛奶, 面包, 尿布, 啤酒}交易5:{牛奶, 面包, 尿布, 可乐}```2. 生成候选项集首先生成1-项集,即单个项的集合。

weka的apriori算法的实验总结及体会

weka的apriori算法的实验总结及体会

一、前言Weka是一款流行的数据挖掘工具,其内置了多种经典的数据挖掘算法。

其中,Apriori算法是一种用于发现数据集中频繁项集的经典算法。

在本次实验中,我们将对Weka中的Apriori算法进行实验,并总结经验体会。

二、实验准备1. 数据集准备:选择一个符合Apriori算法输入要求的数据集,本次实验选取了一个包含购物篮信息的数据集,用于分析不同商品之间的关联规则。

2. Weka环境准备:确保Weka软件已经安装并能够正常运行。

三、实验步骤1. 数据集加载:我们将选取的数据集导入Weka软件中,确保数据集能够正确显示。

2. 参数设置:在Weka中,Apriori算法有一些参数需要设置,如最小支持度、最小置信度等。

根据实际需求,设置适当的参数。

3. 算法执行:执行Apriori算法,观察结果。

可以得到频繁项集、关联规则等信息。

4. 结果分析:根据算法输出的结果,分析不同项集之间的关联规则,并进行对比和总结。

四、实验结果1. 频繁项集分析:通过Apriori算法的执行,得到了数据集中的频繁项集信息。

可以发现一些商品之间的频繁组合,为进一步的关联规则分析提供了基础。

2. 关联规则分析:根据频繁项集,进一步推导出了一些关联规则。

如果购买了商品A,那么购买商品B的概率较大。

这对于商家进行商品搭配和促销活动有一定的指导作用。

3. 算法性能评估:除了得到具体的关联规则外,还可以对算法的性能进行评估。

包括算法执行时间、内存占用、参数敏感性等方面的评估。

五、实验体会1. 算法优缺点:经过实验,我们发现Apriori算法在处理大规模数据集时存在一定的计算复杂度,需要进行优化才能适应大规模数据挖掘的需求。

但在小规模数据集上,其表现仍然较为理想。

2. 参数选择经验:在实验中,我们也总结出了一些参数选择的经验,如支持度和置信度的合理选择范围,以及对于不同数据集的适应性。

3. 应用前景展望:关联规则挖掘在电商、市场营销等领域有着广泛的应用前景,我们相信在未来的实际工作中,能够将所学到的知识应用到真实的业务场景中。

apriori算法实验报告

apriori算法实验报告

Apriori算法实验报告1实验目的学会用Apriori算法对数据进行频繁项集和关联规则的挖掘,同时适当的改进Apriori算法2 实验环境程序语言:Java 实验数据:数据堂下载的模拟数据8万多条3 算法描述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]}。

数据挖掘Apriori算法报告周

数据挖掘Apriori算法报告周

实训报告书实训名称:系(部):专业班级:学生姓名:学号:指导教师:完成日期:山东科技大学泰山科技学院目录一.关联算法简介 (4)1.1相关概念 (4)1.2Apriori算法思想 (4)1.3Apriori算法的典型改进 (5)二.关联算法的基本原理 (5)三.关联算法的C++简单实现 (6)3.1算法数据: (6)3.2算法步骤: (6)3.3 C++算法的简单实现 (7)3.4程序输出结果: (16)四.学习心得体会 (16)数据挖掘Apriori算法报告一.关联算法简介关规则数据挖掘是重要的一种数据挖掘方法,它的关键环节是寻找频繁项集.近几年许多数据挖掘领域的研究人员投入了大量的时间和精力,深入研究了关联规则的算法,其中Agrawal等人于1993年提出的Apriori算法就是其中最具代表的成果,随后众多学者又在此基础上提出了一些改进,目的在于提高算法的效率,从而改进数据挖掘的效率.这方面的研究是目前数据挖掘领域研究的热点之一.1.1相关概念所谓关联规则挖掘就是从事务数据库、关系数据库或数据仓库等海量数据的项集之间发现有价值的频繁出现的模式关联和相关性.通过预先设定的支持度和可信度,通过特定的数据挖掘算法获得支持度和可信度均较高的关联规则,得到用户感兴趣、有价值的关联规则并应用到实际工作中,真正实现从数据到信息、再到知识的迁移过程.关联规则数据挖掘的过程大体为两步:第一步是从全部项集中寻找出所有频繁项集;第二步是由频繁项集获取关联规则.由于第二步较为容易和直观,所以第一步是关联规则挖掘的核心步骤.目前大多数寻找频繁项集算法因需要大量候选集而效率不高.在关联规则挖掘的方法中,最经典的算法是APriroi算法,除此之外还有基于充分挖掘增量事务的关联规则更新算法、Patition算法、完全频繁项集挖掘、频繁闭项集挖掘、最大频繁项集挖掘算法以及一些新的频繁项集挖掘算法.1.2Apriori算法思想Apriori算法是一种最有影响的挖掘布尔关联规则频繁项集的算法,是Agrawal等人于1993年提出的一种宽度优先算法.算法的核心是使用候选项集找频繁项集。

Apriori算法实验报告

Apriori算法实验报告

河北大学
数学与计算机学院
实验报告
课程名称数据挖掘
实验项目编程实现Apriori算法实验仪器VC++6.0
专业____计算机软件与理论__ 学号 ******** 学生姓名乔红光
实验日期 2011年4月9日
实验地点实验室
成绩
指导教师袁方
m_List_FreqItem.SetItemText(nLargeCount,0,LargeItem[k][nLargeItemCount-1]);
m_List_FreqItem.SetItemText(nLargeCount,1,strIntToString);
UpdateWindow();
}
//复制频繁项目个数
LargeItemCount[k]=nLargeItemCount;
}
运行结果图如下:
六、实验总结:
通过本次实验,加深对Apriori算法的理解,并提高了自己的动手实践能力。

说明:
1.实验名称、实验目的、实验内容、实验要求由教师确定,实验前由教师事先填好,然后作为实验报告模版供学生使用;
2.实验准备由学生在实验或上机之前填写,教师应该在实验前检查;
3.实验过程由学生记录实验的过程,包括操作过程、遇到哪些问题以及如何解决等;
4.实验总结由学生在实验后填写,总结本次实验的收获、未解决的问题以及体会和建议等;
5.源程序、代码、具体语句等,若表格空间不足时可作为附录另外附页。

apriori算法原理及过程

apriori算法原理及过程

apriori算法原理及过程一、前言Apriori算法是数据挖掘中常用的频繁项集挖掘算法之一。

它可以发现数据集中的频繁项集,即经常出现在一起的物品或事件。

本文将详细介绍Apriori算法的原理及过程。

二、Apriori算法原理1.支持度和置信度在介绍Apriori算法之前,先了解两个概念:支持度和置信度。

支持度指的是某个项集在所有事务中出现的概率,即该项集的出现次数与总事务数之比。

置信度指的是如果一个事务包含某个项集A,那么它也包含另一个项集B的概率,即包含A和B的事务数与包含A的事务数之比。

2.频繁项集频繁项集指出现次数大于等于最小支持度阈值(min_support)的项集。

例如,如果min_support=0.5,则出现次数占总事务数50%以上的项集为频繁项集。

3.Apriori原理Apriori原理指:如果一个项集是频繁项集,则它的所有子集也一定是频繁项集。

例如,{A,B,C}是频繁项集,则{A,B}、{A,C}、{B,C}都是频繁项集。

基于Apriori原理,可以通过逐层扫描数据集,从而发现所有的频繁项集。

具体过程如下。

三、Apriori算法过程1.生成候选1项集首先扫描数据集,统计每个物品出现的次数,并根据最小支持度阈值生成所有的候选1项集。

2.生成候选k项集根据上一步得到的频繁1项集,构建候选2项集。

具体方法是将两个不同的频繁1项集合并成一个新的2项集。

然后扫描数据集,统计每个2项集出现的次数,并根据最小支持度阈值筛选出频繁2项集。

接着,利用频繁2项集生成候选3项集。

方法与上述类似:将两个不同的频繁2项集合并成一个新的3项集,并根据最小支持度阈值筛选出频繁3项集。

依此类推,直到无法继续生成新的k+1项候选组合为止。

3.剪枝在每一轮生成候选k+1组合之后,需要进行剪枝操作。

即对于每个k+1组合,判断它是否存在非频繁子组合。

如果存在,则该k+1组合也一定不是频繁项集,需要将其删除。

4.重复步骤2和3,直到无法生成新的候选项集重复执行步骤2和3,直到无法继续生成新的k+1项候选组合为止。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

Apriori算法实验报告学号:姓名:专业:计算机应用技术教师:计算机学院目录1 APRIORI实验 (1)1.1实验背景 (1)1.1.1 国内外研究概况 (1)1.1.2 发展趋势 (1)1.2实验内容与要求 (1)1.2.1 实验内容 (1)1.2.2 实验要求 (1)1.2.3 实验目的 (1)2 APRIORI算法分析与实验环境 (3)2.1A PRIORI算法的描述 (3)2.2A PRIORI算法的步骤 (3)2.3开发环境 (3)2.3.1 软件环境 (3)2.3.2 硬件环境 (4)2.4本章小结 (4)3 算法的设计 (5)3.1A PRIORI算法整体框架 (5)3.2主要的数据结构与函数 (5)3.2.1 数据结构 (5)3.2.2 主要的程序 (6)3.2.3 连接与剪枝操作 (6)3.3本章小结 (6)4 数据库的设计与数据的来源 (7)4.1正确性验证数据 (7)4.2实验数据 (7)4.3本章小结 (8)5 实验结果与性能分析 (9)5.1A PRIORI实验界面 (9)5.2实验的正确性验证 (9)5.3实验性能分析 (10)5.3.1固定最小支持度改变数据量 (10)5.3.2固定数据量改变最小支持度 (11)5.3.3实验结果分析 (11)5.4本章小结 (12)1 Apriori实验1.1 实验背景现在, 数据挖掘作为从数据中获取信息的有效方法, 越来越受到人们的重视。

关联规则挖掘首先是用来发现购物篮数据事务中各项之间的有趣联系。

从那以后, 关联规则就成为数据挖掘的重要研究方向,它是要找出隐藏在数据间的相互关系。

目前关联规则挖掘的研究工作主要包括:Apriori算法的扩展、数量关联规则挖掘、关联规则增量式更新、无须生成候选项目集的关联规则挖掘、最大频繁项目集挖掘、约束性关联规则挖掘以及并行及分布关联规则挖掘算法等。

关联规则的挖掘问题就是在事务数据库D中找出具有用户给定的满足一定条件的最小支持度Minsup和最小置信度Minconf的关联规则。

1.1.1 国内外研究概况1993年,Agrawal等人首先提出关联规则概念,关联规则挖掘便迅速受到数据挖掘领域专家的广泛关注.迄今关联规则挖掘技术得到了较为深入的发展。

Apriori算法是关联规则挖掘经典算法。

针对该算法的缺点,许多学者提出了改进算法,主要有基于哈希优化和基于事务压缩等。

1.1.2 发展趋势关联规则挖掘作为数据挖掘的重要研究内容之一, 主要研究事务数据库、关系数据库和其他信息存储中的大量数据项之间隐藏的、有趣的规律。

关联规则挖掘最初仅限于事务数据库的布尔型关联规则, 近年来广泛应用于关系数据库, 因此, 积极开展在关系数据库中挖掘关联规则的相关研究具有重要的意义。

近年来,已经有很多基于Apriori算法的改进和优化。

研究者还对数据挖掘的理论进行了有益的探索,将概念格和粗糙集应用于关联规则挖掘中,获得了显著的效果。

到目前为止,关联规则的挖掘已经取得了令人瞩目的成绩,包括:单机环境下的关联规则挖掘算法;多值属性关联规则挖掘;关联规则更新算法;基于约束条件的关联规则挖掘;关联规则并行及分布挖掘算法等。

1.2 实验内容与要求1.2.1 实验内容编程实现Apriori算法:要求使用‘a’,‘b’,‘c’,‘d’,‘e’,‘f’,‘g’,‘h’,‘i’,‘j’10个项目随机产生数据记录并存入数据库。

从数据库读取记录进行Apriori实验,获得频繁集以及关联规则,实现可视化。

并用课堂上PPT的实例测试其正确性。

1.2.2 实验要求1、程序结构:包括前台工具和数据库;2、设定项目种类为10个,随机产生事务,生成数据库;3、正确性验证(可用课堂上的例子);4、算法效率的研究:在支持度固定数据量不同的时候测量运行时间;在数据量固定,支持度不同的时候测量运行时间;5、注意界面的设计,输入最小支持度和最小可信度,能够输出并显示频繁项目集以及关联规则。

1.2.3 实验目的1、加强对Apriori算法的理解;2、锻炼分析问题、解决问题并动手实践的能力。

2 Apriori算法分析与实验环境2.1 Apriori算法的描述Apriori算法是一种找频繁项目集的基本算法。

其基本原理是逐层搜索的迭代:频繁K项Lk 集用于搜索频繁(K+1)项集Lk+1,如此下去,直到不能找到维度更高的频繁项集为止。

这种方法依赖连接和剪枝这两步来实现。

算法的第一次遍历仅仅计算每个项目的具体值的数量,以确定大型l项集。

随后的遍历,第k次遍历,包括两个阶段。

首先,使用在第(k-1)次遍历中找到的大项集Lk-1和产生候选项集Ck。

接着扫描数据库,计算Ck中候选的支持度。

用Hash树可以有效地确定Ck中包含在一个给定的事务t中的候选。

如果某项集满足最小支持度, 则称它为频繁项集。

2.2 Apriori算法的步骤步骤如下:1、设定最小支持度s和最小置信度c;2、Apriori算法使用候选项集。

首先产生出候选的项的集合,即候选项集,若候选项集的支持度大于或等于最小支持度,则该候选项集为频繁项集;3、在Apriori算法的过程中,首先从数据库读入所有的事务,每个项都被看作候选1-项集,得出各项的支持度,再使用频繁1-项集集合来产生候选2-项集集合,因为先验原理保证所有非频繁的1-项集的超集都是非频繁的;4、再扫描数据库,得出候选2-项集集合,再找出频繁2-项集,并利用这些频繁2-项集集合来产生候选3-项集;5、重复扫描数据库,与最小支持度比较,产生更高层次的频繁项集,再从该集合里产生下一级候选项集,直到不再产生新的候选项集为止。

2.3 开发环境2.3.1 软件环境(1)编程软件:Jdk开发包+eclipse集成开发环境Eclipse 是一个开放源代码的、基于Java的可扩展开发平台。

就其本身而言,它只是一个框架和一组服务,用于通过插件组件构建开发环境。

幸运的是,Eclipse 附带了一个标准的插件集,包括Java开发工具(Java Development Kit,JDK)。

(2)数据库软件:SQL Server 2008SQL Server 2008 在Microsoft的数据平台上发布,可以组织管理任何数据。

可以将结构化、半结构化和非结构化文档的数据直接存储到数据库中。

可以对数据进行查询、搜索、同步、报告和分析之类的操作。

数据可以存储在各种设备上,从数据中心最大的服务器一直到桌面计算机和移动设备,它都可以控制数据而不用管数据存储在哪里。

(3)办公软件:Excel 2010Excel是一款试算表办公软件。

它是微软办公套装软件office的重要的组成部分,它是集统计分析、数据处理和辅助决策等功能于一身,现在金融、统计财经、管理等众多领域广泛应用。

本实验主要用来为固定数据量改变最小支持数以及固定最小支持数改变数据量两种情况进行时间分析提供可视化图表。

2.3.2 硬件环境装有Windows 7 旗舰版电脑。

2.4 本章小结本章的内容主要是为了引出本实验的主要算法以及对算法的实现环境做了介绍。

3 算法的设计3.1 Apriori算法整体框架图3.1 Apriori实验流程图3.2 主要的数据结构与函数3.2.1 数据结构class Transaction{public int pid;public String itemset;}该类表示表中的一条记录。

class Dao{public ArrayList<Transaction> Query(String sql)}该类用于访问数据库操作。

class Kfp{public char kfpstr[]=new char[Apriori.ITEMSIZE];public int index=-1;public int support=0;public boolean isfp=true;}该类代表一个频繁项目。

3.2.2 主要的程序Java 中最常用的集合类是List 和Map。

List 的具体实现包括ArrayList 和Vector,它们是可变大小的列表,比较适合构建、存储和操作任何类型对象的元素列表。

List 适用于按数值索引访问元素的情形。

HashMap:Map接口的常用实现类,系统<key,value>当成一个整体进行处理,系统总是根据Hash算法来计算<key,value>的存储位置,这样可以保证能快速存、取Map的<key,value>对。

ArrayList<Transaction> alTransactions:保存表中的所有记录ArrayList<Kfp> alKfpsl:临时存储频繁项目的集合,存储连接后的结果ArrayList<Kfp> SureFpset:保存频繁k项集ArrayList<Kfp> SureFpsetPrio:保存频繁k-1项集ArrayList<String> notFpList:保存一定不是频繁项目的集合,用于剪枝HashMap<String, Integer> KfpSuppor:频繁项目集及其对应的支持数HashMap<String,Double> guanlianguize:关联规则及其置信度3.2.3 连接与剪枝操作对于连接操作的两个字符串(长度为k),它们必须有k-1个相同的字符才能做连接操作。

例如:abc和abd可以连接成abcd,abd和bcd可以连接成abcd,而abc和ade就不可以做连接操作。

整个连接过程类似归并排序中的归并操作对于任一频繁项目集的所有非空子集也必须是频繁的,反之,如果某个候选的非空子集不是频繁的,那么该候选集肯定不是频繁的,将其剪枝。

3.3 本章小结本章主要介绍了算法设计的整体流程并且也对主要程序和操作作了简要的说明。

4 数据库的设计与数据的来源本实验的数据均存储于数据库中。

数据库yuzm中共产生6张表。

表test为测试用表,用于程序的正确性验证。

还有5张表存储随机产生的实验数据。

其中数据库的结构如下图所示。

图4.1 数据库结构4.1正确性验证数据表test为PPT上的实例,用于正确性验证。

数据的item个数为5,其中的九行数据均由SQL语句产生,表的每一行都是一个“0”“1”的字符串,字符串长度等于商品种类,其中“0”表示该商品不存在,“1”表示该商品存在。

表的全部数据如图4.2。

图4.2 表test4.2 实验数据5张表是通过算法随机产生的具有不同数据量的数据集,假设商品种类为10种,表的每一行都是一个“0”“1”的字符串,字符串长度等于商品种类,其中“0”表示该商品不存在,“1”表示该商品存在。

相关文档
最新文档