精华内容
下载资源
问答
  • 博客推荐系统--mahout FP关联规则算法应用1

    千次阅读 热门讨论 2014-02-19 08:52:17
    调用算法模块仍旧采用之前系统的步骤:首先在参数界面输入参数,然后提到到一个action中,这个action会启动一个线程启动云平台Fp关联规则算法,然后连接到另外一个action中,另外的这个action会去根据云平台的信息,...

    版本:Spring3+Struts2+Hibernate3+Hadoop1.0.4+Mahout0.7+Mysql5

    系统使用Spring3+Struts2+Hibernate3架构,可以在http://download.csdn.net/detail/fansy1990/6935279下载。运行参考:

    1. 打开mysql,增加blog数据库;修改src下面的jdbc.properties文件的用户名和密码;
    2. 修改blog.xml(和Readme.txt同目录)的docBase为本地目录,放在tomcat的conf\Catalina\localhost目录下面;
    3. 修改applicationContext.xml文件中的自动生成表的配置(hibernate.hbm2ddl.auto),第一次启动为create,后面改为update;
    4. 启动服务器,运行test目录下面的DataGenerator.java、运行src/data目录下面的UserGenerate.java
    即可插入test用户信息以及云平台信息(需要修改UserGenerate.java中云平台相关配置);

    5. 拿修改后的JobTracker.class替换Hadoop云平台中hadoop-core-1.0.4.jar中对应的文件(每个节点都需要),这个修改后的文件把集群的启动时间写入HDFS文件,方便后面的读取;

    博客推荐系统是一个为用户推荐博客的系统,使用Mahout的FP关联规则算法进行博客相关信息挖掘,生成知识库。然后根据知识库以及用户订阅博客来进行其他博客推荐。

    博客推荐系统思路如下:首先把http://fimi.ua.ac.be/data/网站上面的webdocs.dat.gz数据作为基础数据,这些基础数据是一种类似购物篮的数据,我们可以把每行数据看做是一个用户的博客订阅记录(实际上这个数据是用户浏览的网页id),里面的每一项是用户订阅的博客id。这样这份数据就可以使用fp关联规则来挖掘得到频繁项集,即可以得到博客id两两之间的关联度,类似这样的数据 [blogId101 blogId103 500],前面两项是博客id,后面的500是博客blogId101和blogid103的关联度。然后把这样的数据存入数据库中的knowledge表中。登录系统的用户会有一个用户表,这个用户表存储了用户的订阅记录以及推荐记录(默认都为空,当用户订阅博客后,会填充订阅记录一栏数据)。当要对用户进行博客推荐时,首先就会查找这个用户的订阅记录,然后根据这个订阅记录中的博客id在knowledge表中找出与之关联的博客id以及对应的关联度,存入一个map(博客id为key,关联度为value)中。如果博客101和103关联,且关联度为20,博客102和103关联,关联度是30,并且博客101和102都是当前用户订阅的,那么map中存储的博客103对应的关联度就是两者的叠加,即50。map变量的值就是按照这样的方式更新的,最后,map按照关联度(也就是value)从大到小排列,取前10个即为用户推荐的博客。

    下面按照系统功能来分析实现思路:

    1. 首先看系统登录后的界面:

    图1

    用户访问系统发布地址后,首先会打开登录界面,在登录界面用户可以输入用户名和密码进行登录,或者注册。登录会查找数据库用户名和密码是否匹配,如果匹配,那么就会在UserAction中的Session放入username和level(权限),level是为了在图1中的建立知识库模块使用过滤器过滤权限不够的请求。

    注册直接检测用户名是否存在,不存在则正常更新用户表,同时用户表的权限值默认注册是为1,管理员权限级别为0。

    2. 用户信息模块

    用户信息模块包含两个功能:修改密码,订阅查看。

    修改密码主要是修改用户表中的密码字段,不过修改的时候会要求用户提供当前密码,然后和数据库做比对,如果比对正确才给用户更改密码。

    订阅查看则主要是显示用户表的订阅字段数据,由于订阅字段数据是以字符串存储的(类似[blogId101 blogid102 ...]),在前台展示之前需要把字符串分隔为数组,然后在前台展示,所以这里需要解析字符串。在前台展示使用struts2的标签,一个实例如下所示:

    <table border="1">
    		<thead>
    			<tr>
    				<td id="blogId">博客ID</td>
    				<td id="blogInfo">博客简要描述</td>
    			</tr>
    		</thead>
    		
        	<s:iterator value="orderedBlogs" id="array">  
        	<tr>
              <td> <s:property value="array"/>  </td>
              <td>******</td>
             </tr>
            </s:iterator>  
            
        </table>
    3. 建立知识库模块

    建立知识库模块首先会经过LoginFilter进行权限验证,验证不通过的请求将会返回无权限页面,LoginFilter需要要web.xml中配置,配置代码如下:

     <filter>
          <filter-name>LoginFilter</filter-name>
          <filter-class>util.LoginFilter</filter-class>
      </filter>
    
      <filter-mapping>
          <filter-name>LoginFilter</filter-name>
          <url-pattern>/*</url-pattern>
      </filter-mapping> 
    建立知识库模块分为两个部分,导入数据和调用算法进行监控。

    导入数据功能,用户需要提供服务器(一般为运行tomcat的机器)的数据目录文件,然后即可上传。数据可以采用上面给出链接的数据,不过如果仅仅是为了测试,那么可以不用那么多数据的,可以对数据进行处理,随机抽取一部分数据即可。上传部分代码如下所示:

    /**
    	 * 上传数据到云平台
    	 * @param localFile
    	 * @param deltaOrAll
    	 * @return 上传路径;
    	 */
    	public static String upload(String localFile,String deltaOrAll){
    		FileSystem fs=null;
    		String output=UPLOAD_PATH+System.currentTimeMillis();
    		Path in=new Path(localFile);
    		Path out=new Path(output);
    		try {
    			fs = FileSystem.get(URI.create(output),getConf());
    			if("all".equals(deltaOrAll)){
    				HadoopUtil.delete(getConf(), new Path(UPLOAD_PATH));
    			}
    			fs.copyFromLocalFile(in,out);
    		}catch(Exception e){
    			System.err.println(e.getMessage());
    			try {
    				HadoopUtil.delete(getConf(), out);
    			} catch (IOException e1) {
    				e1.printStackTrace();
    			}
    			output=null;
    		}finally{
    			try {
    				if(fs!=null){
    					fs.close();
    				}
    			} catch (IOException e) {
    				System.err.println(e.getMessage());
    			}
    		}
    		return output;
    	}
    调用算法模块仍旧采用之前系统的步骤:首先在参数界面输入参数,然后提到到一个action中,这个action会启动一个线程启动云平台Fp关联规则算法,然后连接到另外一个action中,另外的这个action会去根据云平台的信息,获得任务运行状态。然后返回给用户。

    在获得任务运行状态的时候是参考下面的思路设计的。首先说明,任务运行状态设计了一个实体类(JobInfo),包含5个字段,分别是:jobId、jobName,mapProgerss、redProgress、runStatus,并且如果知道当前任务运行的jobId,那么就可以得到当前任务的jobName、mapProgress、redProgress、runStatus。在云平台任务列表中找出最后一次运行任务的jobId(如果云平台刚启动,那么这个列表是没有的,就需要通过其他方式来获得,后面细说)。然后来推算出下面任务运行的jobId,FP关联规则算法一共三个MR,所以把找出的最后一个jobId分别加3次即可得到一个List<JobInfo>的list,其jobId有值,其他默认为空。获得云平台最后一次任务jobId的代码如下:

    MonitorUtil:

    public static void initialMonitorJobs(int jobNums) throws IOException{
    		
    		JobStatus[] jobStatusAll=HadoopUtils.getJobClient().getAllJobs();
    		JobStatus jobStatus=null;
    		int id =0;
    		String jobIden="";
    		/**
    		 * 防止当前云平台是第一次启动,这个时候没有任务列表,获取的jobStatus是空;
    		 */
    		if(jobStatusAll==null||jobStatusAll.length<=0){
    			//修改TaskTracker代码,把集群启动时间写入hdfs,然后在这里读取出来
    			id=0;
    			jobIden=readJTStartTime();
    			
    		}else{
    			jobStatus=jobStatusAll[jobStatusAll.length-1];
    			id=jobStatus.getJobID().getId();
    			jobIden=jobStatus.getJobID().getJtIdentifier();
    		}
    		
    		log.info("initial monitorJobs with the start jobID :"+id);
    		 
    		monitorJobs=new LinkedHashMap<String,JobInfo>();
    		String jobId="";
    		for(int i=0;i<jobNums;i++){
    			jobId= new JobID(jobIden,id+1+i).toString();
    			
    			monitorJobs.put(jobId, new JobInfo(jobId));
    		}
    		lastJobId=jobId;
    		log.info("initial monitor jobs map done !!!");
    	}
    HadoopUtils:

    public static JobClient getJobClient(){
    		if(jobClient==null){
    			try {
    				InetSocketAddress jobTracker=new InetSocketAddress(getHost(),getJobtrackerPort());
    				jobClient=new JobClient(jobTracker, getConf());
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    		return jobClient;
    	}


    分享,成长,快乐

    转载请注明blog地址:http://blog.csdn.net/fansy1990


    展开全文
  • 数据挖掘-关联规则算法的实现及其应用 Apriori算法

    千次阅读 多人点赞 2019-03-12 08:38:53
    实验一 关联规则算法的实现及其应用 【实验目的】 掌握关联规则挖掘算法Apriori的概念,理解算法的步骤。 加深对Apriori算法的理解,逐步培养解决实际问题的能力。 【实验性质】 设计型实验 【实验内容】 ...

    实验一  关联规则算法的实现及其应用

    【实验目的】

    1. 掌握关联规则挖掘算法Apriori的概念,理解算法的步骤。
    2. 加深对Apriori算法的理解,逐步培养解决实际问题的能力。

    【实验性质】

    设计型实验

    【实验内容】    

     实现使用Apriori算法来挖掘关联规则 

    【实验环境】

    Python 2

    【实验结果】

    • 完整的apriori.py文件

    代码:

    def loadDataSet():

        return[[1,3,4],[2,3,5],[1,2,3,5],[2,5]]

     

    def createC1(dataSet):

        C1=[]

        for transaction in dataSet:

            for item in transaction:

                if not [item] in C1:

                    C1.append([item])

        C1.sort()

        return map(frozenset,C1)

     

    def scanD(D,Ck,minSupport):

        ssCnt={}

        for tid in D:

            for can in Ck:

                if can.issubset(tid):

                    if not ssCnt.has_key(can):ssCnt[can]=1

                    else:ssCnt[can]+=1

        numItems = float(len(D))

        retList =[]

        supportData={}

        for key in ssCnt:

            support =ssCnt[key]/numItems

            if support >=minSupport:

                retList.insert(0,key)

            supportData[key]=support

        return retList,supportData

     

    def aprioriGen(Lk, k): #creates Ck

        retList = []

        lenLk = len(Lk)

        for i in range(lenLk):

            for j in range(i+1, lenLk):

                L1 = list(Lk[i])[:k-2]; L2 = list(Lk[j])[:k-2]

                L1.sort(); L2.sort()

                if L1==L2:

                    retList.append(Lk[i] | Lk[j])

        return retList

     

    def apriori(dataSet, minSupport = 0.5):

        C1 = createC1(dataSet)

        D = map(set, dataSet)

        L1, supportData = scanD(D, C1, minSupport)

        L = [L1]

        k = 2

        while (len(L[k-2]) > 0):

            Ck = aprioriGen(L[k-2], k)

            Lk, supK = scanD(D, Ck, minSupport)

            supportData.update(supK)

            L.append(Lk)

            k += 1

        return L, supportData

     

    def generateRules(L,supportData,minConf=0.7):

        bigRuleList=[]

        for i in range(1,len(L)):

            for freqSet in L[i]:

                H1=(frozenset([item])for item in freqSet)

                if(i>1):

                    rulesFromConseq(freqset,H1,supportData,bigRuleList,\

                                    minConf)

                else:

                    calcConf(freqSet,H1,supportData,bigRuleList,minConf)

            return bigRuleList

     

    def calcConf(freqSet,H,supportData,brl,minConf=0.7):

        prunedH=[]

        for conseq in H:

            conf=supportData[freqSet]/supportData[freqSet-conseq]

            if conf>=minConf:

                print freqSet-conseq,'-->',conseq,'conf:',conf

                brl.append((freqSet-conseq,conseq,conf))

                prunedH.append(conseq)

        return prunedH

     

    def rulesFromConseq(freqSet,H,supportData,brl,minConf=0.7):

        m=len(H[0])

        if(len(freqSet)>(m+1)):

            Hmp1=aprioriGen(H.m+1)

            Hmp1=calcConf(freqSet,Hmp1,supportData,brl,minConf)

            if(len(Hmp1)>1):

                rulesFromConseq(freqSet,Hmp1,supportData,brl,minConf)

    • 编写调用并测试apriori.py的代码

    代码:

    import apriori

    dataSet=apriori.loadDataSet()

    print dataSet

    C1=apriori.createC1(dataSet)

    print C1

    D=map(set,dataSet)

    print D

    L1,suppData0=apriori.scanD(D,C1,0.5)

    print L1

     

    reload (apriori)

    L,suppData=apriori.apriori(dataSet)

    print L

    print L[0]

    print L[1]

    print L[2]

    print L[3]

    print apriori.aprioriGen(L[0],2)

    L,suppData=apriori.apriori(dataSet,minSupport=0.7)

    print L

    reload(apriori)

    L,suppData=apriori.apriori(dataSet,minSupport=0.5)

    rules=apriori.generateRules(L,suppData,minConf=0.7)

    print rules

    rules=apriori.generateRules(L,suppData,minConf=0.5)

    print rules

    • 运行结果:

    【实验步骤】

    第一步:生成后选项集

    程序清单1:Apriori算法中的辅助函数

    代码:

    def loadDataSet():

        return[[1,3,4],[2,3,5],[1,2,3,5],[2,5]]

     

    def createC1(dataSet):

        C1=[]

        for transaction in dataSet:

            for item in transaction:

                if not [item] in C1:

                    C1.append([item])

        C1.sort()

        return map(frozenset,C1)

     

    def scanD(D,Ck,minSupport):

        ssCnt={}

        for tid in D:

            for can in Ck:

                if can.issubset(tid):

                    if not ssCnt.has_key(can):ssCnt[can]=1

                    else:ssCnt[can]+=1

        numItems = float(len(D))

        retList =[]

        supportData={}

        for key in ssCnt:

            support =ssCnt[key]/numItems

            if support >=minSupport:

                retList.insert(0,key)

            supportData[key]=support

        return retList,supportData

    运行结果:

    第二步:组织完整的Apriori算法

    程序清单2:Apriori算法

    代码:

    def aprioriGen(Lk, k): #creates Ck

        retList = []

        lenLk = len(Lk)

        for i in range(lenLk):

            for j in range(i+1, lenLk):

                L1 = list(Lk[i])[:k-2]; L2 = list(Lk[j])[:k-2]

                L1.sort(); L2.sort()

                if L1==L2:

                    retList.append(Lk[i] | Lk[j])

        return retList

     

    def apriori(dataSet, minSupport = 0.5):

        C1 = createC1(dataSet)

        D = map(set, dataSet)

        L1, supportData = scanD(D, C1, minSupport)

        L = [L1]

        k = 2

        while (len(L[k-2]) > 0):

            Ck = aprioriGen(L[k-2], k)

            Lk, supK = scanD(D, Ck, minSupport)

            supportData.update(supK)

            L.append(Lk)

            k += 1

        return L, supportData

    运行结果:

    第三步:从频繁项集中挖掘关联规则

    程序清单3:关联规则生成函数

    代码:

    def generateRules(L,supportData,minConf=0.7):

        bigRuleList=[]

        for i in range(1,len(L)):

            for freqSet in L[i]:

                H1=(frozenset([item])for item in freqSet)

                if(i>1):

                    rulesFromConseq(freqset,H1,supportData,bigRuleList,\

                                    minConf)

                else:

                    calcConf(freqSet,H1,supportData,bigRuleList,minConf)

            return bigRuleList

     

    def calcConf(freqSet,H,supportData,brl,minConf=0.7):

        prunedH=[]

        for conseq in H:

            conf=supportData[freqSet]/supportData[freqSet-conseq]

            if conf>=minConf:

                print freqSet-conseq,'-->',conseq,'conf:',conf

                brl.append((freqSet-conseq,conseq,conf))

                prunedH.append(conseq)

        return prunedH

     

    def rulesFromConseq(freqSet,H,supportData,brl,minConf=0.7):

        m=len(H[0])

        if(len(freqSet)>(m+1)):

            Hmp1=aprioriGen(H.m+1)

            Hmp1=calcConf(freqSet,Hmp1,supportData,brl,minConf)

            if(len(Hmp1)>1):

                rulesFromConseq(freqSet,Hmp1,supportData,brl,minConf)

    运行结果:

     

    我想能看到这里的同学,无外乎两种人:来拷贝代码的人 和 来拷贝代码的人。

    但,在拷贝走的时候,你要想清楚一件事,把代码拷走之后有个蛋用,搞明白对你来说才是最重要的。

    好了,就酱紫。

     

    老铁,这要是都不赞,说不过去吧!!!


    最后对自己说:
    你现在所遭遇的每一个不幸,都来自一个不肯努力的曾经。

    展开全文
  • 关联规则算法

    万次阅读 2014-02-17 11:31:25
    关联规则 编辑 关联规则是形如X→Y的蕴涵式,其中, X和Y分别称为关联规则的先导(antecedent或left-hand-side, LHS)和后继(consequent或right-hand-side, RHS) 。 目录 1简介 ▪ 故事 ▪ 定义 ▪...

    关联规则

    关联规则是形如X→Y的蕴涵式,其中, X和Y分别称为关联规则的先导(antecedent或left-hand-side, LHS)和后继(consequent或right-hand-side, RHS)


    故事 
    在描述有关关联规则的一些细节之前,先来看一个有趣的故事: "尿布与啤酒"的故事。
    在一家超市里,有一个有趣的现象:尿布和啤酒赫然摆在一起出售。但是这个奇怪的举措却使尿布和啤酒的销量双双增加了。这不是一个笑话,而是发生在美国沃尔玛连锁店超市的真实案例,并一直为商家所津津乐道。沃尔玛拥有世界上最大的数据仓库系统,为了能够准确了解顾客在其门店的购买习惯,沃尔玛对其顾客的购物行为进行购物篮分析,想知道顾客经常一起购买的商品有哪些。沃尔玛数据仓库里集中了其各门店的详细原始交易数据。在这些原始交易数据的基础上,沃尔玛利用数据挖掘方法对这些数据进行分析和挖掘。一个意外的发现是:"跟尿布一起购买最多的商品竟是啤酒!经过大量实际调查和分析,揭示了一个隐藏在"尿布与啤酒"背后的美国人的一种行为模式:在美国,一些年轻的父亲下班后经常要到超市去买婴儿尿布,而他们中有30%~40%的人同时也为自己买一些啤酒。产生这一现象的原因是:美国的太太们常叮嘱她们的丈夫下班后为小孩买尿布,而丈夫们在买尿布后又随手带回了他们喜欢的啤酒。
    按常规思维,尿布与啤酒风马牛不相及,若不是借助数据挖掘技术对海量交易数据进行挖掘和分析,沃尔玛是不可能发现数据内在这一有价值的规律的。

    定义

    根据韩家炜等观点,关联规则定义为:
    假设I是项的集合。给定一个交易数据库D,其中每个事务(Transaction)t是I的非空子集,即,每一个交易都与一个唯一的标识符TID(Transaction ID)对应。关联规则在D中的支持度(support)是D中事务同时包含X、Y的百分比,即概率置信度(confidence)是D中事物已经包含X的情况下,包含Y的百分比,即条件概率。如果满足最小支持度阈值和最小置信度阈值。这些阈值是根据挖掘需要人为设定。

    例子

    基本概念表1:关联规则的简单例子
    TID
    网球拍
    网 球
    运动鞋
    羽毛球
    1
    1
    1
    1
    0
    2
    1
    1
    0
    0
    3
    1
    0
    0
    0
    4
    1
    0
    1
    0
    5
    0
    1
    1
    1
    6
    1
    1
    0
    0
    用一个简单的例子说明。表1是顾客购买记录的数据库D,包含6个事务。项集I={网球拍,网球,运动鞋,羽毛球}。考虑关联规则(频繁二项集):网球拍与网球,事务1,2,3,4,6包含网球拍,事务1,2,6同时包含网球拍和网球,X^Y=3, D=6,支持度(X^Y)/D=0.5;X=5, 置信度(X^Y)/X=0.6。若给定最小支持度α = 0.5,最小置信度β = 0.6,认为购买网球拍和购买网球之间存在关联。

    2挖掘过程编辑

    两个阶段

    关联规则挖掘过程主要包含两个阶段:第一阶段必须先从资料集合中找出所有的高频项目组(Frequent Itemsets),第二阶段再由这些高频项目组中产生关联规则(Association Rules)。
    关联规则挖掘的第一阶段必须从原始资料集合中,找出所有高频项目组(Large Itemsets)。高频的意思是指某一项目组出现的频率相对于所有记录而言,必须达到某一水平。一项目组出现的频率称为支持度(Support),以一个包含A与B两个项目的2-itemset为例,我们可以经由公式(1)求得包含{A,B}项目组的支持度,若支持度大于等于所设定的最小支持度(Minimum Support)门槛值时,则{A,B}称为高频项目组。一个满足最小支持度的k-itemset,则称为高频k-项目组(Frequent k-itemset),一般表示为Large k或Frequent k。算法并从Large k的项目组中再产生Large k+1,直到无法再找到更长的高频项目组为止。
    关联规则挖掘的第二阶段是要产生关联规则(Association Rules)。从高频项目组产生关联规则,是利用前一步骤的高频k-项目组来产生规则,在最小信赖度(Minimum Confidence)的条件门槛下,若一规则所求得的信赖度满足最小信赖度,称此规则为关联规则。例如:经由高频k-项目组{A,B}所产生的规则AB,其信赖度可经由公式(2)求得,若信赖度大于等于最小信赖度,则称AB为关联规则。

    案例分析

    就沃尔马案例而言,使用关联规则挖掘技术,对交易资料库中的纪录进行资料挖掘,首先必须要设定最小支持度与最小信赖度两个门槛值,在此假设最小支持度min_support=5% 且最小信赖度min_confidence=70%。因此符合此该超市需求的关联规则将必须同时满足以上两个条件。若经过挖掘过程所找到的关联规则「尿布,啤酒」,满足下列条件,将可接受「尿布,啤酒」的关联规则。用公式可以描述Support(尿布,啤酒)>=5%且Confidence(尿布,啤酒)>=70%。其中,Support(尿布,啤酒)>=5%于此应用范例中的意义为:在所有的交易纪录资料中,至少有5%的交易呈现尿布与啤酒这两项商品被同时购买的交易行为。Confidence(尿布,啤酒)>=70%于此应用范例中的意义为:在所有包含尿布的交易纪录资料中,至少有70%的交易会同时购买啤酒。因此,今后若有某消费者出现购买尿布的行为,超市将可推荐该消费者同时购买啤酒。这个商品推荐的行为则是根据「尿布,啤酒」关联规则,因为就该超市过去的交易纪录而言,支持了“大部份购买尿布的交易,会同时购买啤酒”的消费行为。
    从上面的介绍还可以看出,关联规则挖掘通常比较适用与记录中的指标取离散值的情况。如果原始数据库中的指标值是取连续的数据,则在关联规则挖掘之前应该进行适当的数据离散化(实际上就是将某个区间的值对应于某个值),数据的离散化是数据挖掘前的重要环节,离散化的过程是否合理将直接影响关联规则的挖掘结果。

    分类编辑

    按照不同情况,关联规则可以进行分类如下:
    1.基于规则中处理的变量的类别:
    关联规则处理的变量可以分为布尔型和数值型。布尔型关联规则处理的值都是离散的、种类化的,它显示了这些变量之间的关系;而数值型关联规则可以和多维关联或多层关联规则结合起来,对数值型字段进行处理,将其进行动态的分割,或者直接对原始的数据进行处理,当然数值型关联规则中也可以包含种类变量。例如:性别=“女”=>职业=“秘书” ,是布尔型关联规则;性别=“女”=>avg(收入)=2300,涉及的收入是数值类型,所以是一个数值型关联规则。
    2.基于规则中数据的抽象层次:
    基于规则中数据的抽象层次,可以分为单层关联规则和多层关联规则。在单层的关联规则中,所有的变量都没有考虑到现实的数据是具有多个不同的层次的;而在多层的关联规则中,对数据的多层性已经进行了充分的考虑。例如:IBM台式机=>Sony打印机,是一个细节数据上的单层关联规则;台式机=>Sony打印机,是一个较高层次和细节层次之间的多层关联规则。
    3.基于规则中涉及到的数据的维数:
    关联规则中的数据,可以分为单维的和多维的。在单维的关联规则中,我们只涉及到数据的一个维,如用户购买的物品;而在多维的关联规则中,要处理的数据将会涉及多个维。换成另一句话,单维关联规则是处理单个属性中的一些关系;多维关联规则是处理各个属性之间的某些关系。例如:啤酒=>尿布,这条规则只涉及到用户的购买的物品;性别=“女”=>职业=“秘书”,这条规则就涉及到两个字段的信息,是两个维上的一条关联规则。

    4相关算法编辑

    Apriori算法

    Apriori算法:使用候选项集找频繁项集
    Apriori算法是一种最有影响的挖掘布尔关联规则频繁项集的算法。其核心是基于两阶段频集思想的递推算法。该关联规则在分类上属于单维、单层、布尔关联规则。在这里,所有支持度大于最小支持度的项集称为频繁项集,简称频集。
    算法的基本思想是:首先找出所有的频集,这些项集出现的频繁性至少和预定义的最小支持度一样。然后由频集产生强关联规则,这些规则必须满足最小支持度和最小可信度。然后使用第1步找到的频集产生期望的规则,产生只包含集合的项的所有规则,其中每一条规则的右部只有一项,这里采用的是中规则的定义。一旦这些规则被生成,那么只有那些大于用户给定的最小可信度的规则才被留下来。为了生成所有频集,使用了递推的方法。
    可能产生大量的候选集,以及可能需要重复扫描数据库,是Apriori算法的两大缺点。

    基于划分的算法

    基于划分的算法
    Savasere等设计了一个基于划分的算法。这个算法先把数据库从逻辑上分成几个互不相交的块,每次单独考虑一个分块并对它生成所有的频集,然后把产生的频集合并,用来生成所有可能的频集,最后计算这些项集的支持度。这里分块的大小选择要使得每个分块可以被放入主存,每个阶段只需被扫描一次。而算法的正确性是由每一个可能的频集至少在某一个分块中是频集保证的。该算法是可以高度并行的,可以把每一分块分别分配给某一个处理器生成频集。产生频集的每一个循环结束后,处理器之间进行通信来产生全局的候选k-项集。通常这里的通信过程是算法执行时间的主要瓶颈;而另一方面,每个独立的处理器生成频集的时间也是一个瓶颈。

    FP-树频集算法

    FP-树频集算法
    针对Apriori算法的固有缺陷,J. Han等提出了不产生候选挖掘频繁项集的方法:FP-树频集算法。采用分而治之的策略,在经过第一遍扫描之后,把数据库中的频集压缩进一棵频繁模式树(FP-tree),同时依然保留其中的关联信息,随后再将FP-tree分化成一些条件库,每个库和一个长度为1的频集相关,然后再对这些条件库分别进行挖掘。当原始数据量很大的时候,也可以结合划分的方法,使得一个FP-tree可以放入主存中。实验表明,FP-growth对不同长度的规则都有很好的适应性,同时在效率上较之Apriori算法有巨大的提高。

    5应用编辑

    应用

    关联规则挖掘技术已经被广泛应用在西方金融行业企业中,它可以成功预测银行客户需求。一旦获得了这些信息,银行就可以改善自身营销。银行天天都在开发新的沟通客户的方法。各银行在自己的ATM机上就捆绑了顾客可能感兴趣的本行产品信息,供使用本行ATM机的用户了解。如果数据库中显示,某个高信用限额的客户更换了地址,这个客户很有可能新近购买了一栋更大的住宅,因此会有可能需要更高信用限额,更高端的新信用卡,或者需要一个住房改善贷款,这些产品都可以通过信用卡账单邮寄给客户。当客户打电话咨询的时候,数据库可以有力地帮助电话销售代表。销售代表的电脑屏幕上可以显示出客户的特点,同时也可以显示出顾客会对什么产品感兴趣。
    同时,一些知名的电子商务站点也从强大的关联规则挖掘中的受益。这些电子购物网站使用关联规则中规则进行挖掘,然后设置用户有意要一起购买的捆绑包。也有一些购物网站使用它们设置相应的交叉销售,也就是购买某种商品的顾客会看到相关的另外一种商品的广告。
    但是在我国,“数据海量,信息缺乏”是商业银行在数据大集中之后普遍所面对的尴尬。金融业实施的大多数数据库只能实现数据的录入、查询、统计等较低层次的功能,却无法发现数据中存在的各种有用的信息,譬如对这些数据进行分析,发现其数据模式及特征,然后可能发现某个客户、消费群体或组织的金融和商业兴趣,并可观察金融市场的变化趋势。可以说,关联规则挖掘的技术在我国的研究与应用并不是很广泛深入。

    研究

    由于许多应用问题往往比超市购买问题更复杂,大量研究从不同的角度对关联规则做了扩展,将更多的因素集成到关联规则挖掘方法之中,以此丰富关联规则的应用领域,拓宽支持管理决策的范围。如考虑属性之间的类别层次关系,时态关系,多表挖掘等。围绕关联规则的研究主要集中于两个方面,即扩展经典关联规则能够解决问题的范围,改善经典关联规则挖掘算法效率和规则兴趣性。[1]

    展开全文
  • Apriori 关联规则算法

    千次阅读 2018-01-27 18:12:55
    它的模式属于描述型模式,发现关联规则算法属于无监督学习的方法。其实是一种事物相关性的探究。 百度百科: 通过对比支持度,进行剪枝,将支持度高的分支留下,继续探寻关联,直到再没有高于最小支持度为止。...

    关联规则通过量化的数字描述物品甲的出现对物品乙的出现有多大的影响。它的模式属于描述型模式,发现关联规则的算法属于无监督学习的方法。其实是一种事物相关性的探究。

    百度百科:

    这里写图片描述

    通过对比支持度,进行剪枝,将支持度高的分支留下,继续探寻关联,直到再没有高于最小支持度为止。
    应用场景比较广泛,购物篮数据,医疗诊断,科学数据分析。
    首先数据方面,要把数据转换为0,1 的形式,1代表有,0代表无,每一项集的中元素相乘结果为1,则证明有该项集有结果,在通过求和后求占比,即是该项集支持度。

    再通过置信度检验是否为强规则。

    实现代码:

    def find_rule(data, support, confidence):
        result = pd.DataFrame(index=['support', 'confidence'])  # 定义输出结果
    
        support_series = round(1.0 * data.sum() / len(data), 6)  # 支持度序列
        column = list(support_series[support_series > support].index)  # 初步根据支持度筛选
        k = 0
        while len(column) > 1:
            k += 1
            print("正在搜索{}元项集".format(k))
            column = connect_string(column)
            # 通过相乘得1 确认项集结果
            sf = lambda i: data[i].prod(axis=1, numeric_only=True)  # 新一批支持度的计算函数
            # 用map函数分布式求解,加快运算速度
            data_new = pd.DataFrame(list(map(sf, column)), index=['-'.join(i) for i in column]).T
            # 计算占比(支持度)
            support_series_new = round(data_new[['-'.join(i) for i in column]].sum() / len(data),6)
            # 通过支持度剪枝
            column = list(support_series_new[support_series_new > support].index)
            support_series = support_series.append(support_series_new)
            column_new = []
    
            for i in column:
                i = i.split('-')
                for j in range(len(i)):
                    column_new.append(i[:j] + i[j + 1:] + i[j:j+1])
            # 先行定义置信度序列,节约计算时间
            cofidence_series = pd.Series(index=['-'.join(i) for i in column_new])
    
            for i in column_new:  # 计算置信度序列
                cofidence_series['-'.join(i)] = support_series['-'.join(sorted(i))] / support_series['-'.join(i[:len(i) - 1])]
    
            for i in cofidence_series[cofidence_series > confidence].index:  # 置信度筛选
                result[i] = 0.0
                result[i]['confidence'] = cofidence_series[i]
                result[i]['support'] = support_series['-'.join(sorted(i.split('-')))]
        return result.T
    
    def trans_index(x):
        rename = []
        for item in x.split('-'):
            rename.append(origin_columns[int(item)])
        return "-".join(rename)
    
    if __name__ == '__main__':
        inputfile = 'data/Income.csv'
        outputfile = 'tmp/income.csv'
        data = pd.read_csv(inputfile)
        del data['Unnamed: 0']
        # 保存原列标
        origin_columns = list(data.columns)
        # 替换列标
        data.columns = np.arange(0, len(origin_columns)).astype(str)
        # 设置最小支持度
        support = 0.3
        # 设置最小置信度
        confidence = 0.5 
        result = find_rule(data, support, confidence).reset_index()
        # 将关系名称换回原来的
        result['index'] = result['index'].apply(trans_index)
        result = result.set_index('index')
        print("*"*20, "结果", "*"*20)
        print(result)
        result.to_csv(outputfile)

    结果也可以写成键值对的形式存入redis 数据库,方便搜索调用。

    展开全文
  • apriori和关联规则算法

    千次阅读 2016-02-21 10:32:48
    从大规模数据集中寻找物品间的隐含关系被称为关联规则分析(association analysis)或关联规则学习(association rule learning)。举个例子说就是发现用户购买了一件商品(如帽子)后,会购买另一件商品(如围巾)...
  • 机器学习中常用关联规则算法 关联规则算法是一种基于规则的机器学习算法,该算法可以在大数据中发现彼此之间的关系。 它的目的是:利用一些度量指标来分辨数据库中存在的强规则。也即是说关联规则挖掘是用于知识...
  • 关联规则常用算法

    千次阅读 2020-07-03 15:53:41
    关联规则常用算法   关联规则(Association Rules)是海量数据挖掘(Mining Massive Datasets,MMDs)非常经典的任务,其主要目标是试图从一系列事务集中挖掘出频繁项以及对应的关联规则关联规则来自于一个...
  • 实验目的:在掌握关联规则算法的原理的基础上,能够应用关联规则算法解决实际问题。 实验内容:根据实验数据,采用Apriori等关联规则发现算法,给出相关关联规则。 实验要求:给出数据预处理过程、关联规则发现算法...
  • 关联规则算法(扫盲篇)

    千次阅读 2012-07-31 13:14:59
    关联规则算法课件,对关联规则中的几个概念讲述的非常清楚 http://wenku.baidu.com/view/6be795d9ad51f01dc281f187.html#10002-qzone-1-83904-35... 数据挖掘整体介绍及关联规则应用案例 ...
  • FPGrowth(频繁模式增长)是一种关联规则分析算法,本文通过代码演示用spark运行FPGrowth算法的一个小例子。
  • 使用Apriori关联规则算法实现购物篮分析

    千次阅读 多人点赞 2020-11-19 15:19:26
    本章使用Apriori关联规则算法实现购物篮分析,发现超市不同商品之间的关联关系,并根据商品之间的关联规则制定销售策略。 1背景与挖掘目标 现代商品种类繁多,顾客往往会由于需要购买的商品众多而变得疲于选择,且...
  • 关联规则挖掘算法

    千次阅读 2018-08-31 20:06:08
    关联规则挖掘是一种基于规则的机器学习算法,该算法可以在大数据库中发现感兴趣的关系。它的目的是利用一些度量指标来分辨数据库中存在的强规则。也即是说关联规则挖掘是用于知识发现,而非预测,所以是属于无监督的...
  • 提到关联规则算法,一般会想到Apriori或者FP,一般很少有想到HotSpot的,这个算法不知道是应用少还是我查资料的手段太low了,在网上只找到很少的内容,这篇...比较好用的算法类软件,如weka,其里面已经包
  • Aprion算法的优缺点 优点: ...5)适合稀疏数据集:根据以往的研究,该算法只能适合稀疏数据集的关联规则挖掘,也就是频繁项目集的长度稍小的数据集。 缺陷: 1)对数据库的扫描次数过多。 2)Apion...
  • 关联规则—Apriori算法—FPTree

    万次阅读 多人点赞 2018-07-19 13:58:56
    1 关联规则 2 频繁项集(Frequent Itemset) ...6 关联规则 Apriori 算法关联规则新指标: [Math Processing Error]liftlift 值 ▶ 关联规则应用方向: ▶ 基于support,confidence和lift 筛选规则 ...
  • 关联规则(Association Rules,AR),这种原理最初应用于购物篮发现,实际上就是从大量的已知购物信息中提取出具有关联性而人们平时又不会注意到的规则,像经典的啤酒与尿布、蛋挞与飓风的案例都是对...
  • 关联规则1:关联规则应用场景

    千次阅读 2020-08-03 11:33:30
    关联规则,作为十大机器学习算法之一,应用非常广泛。最经典的例子当然是“啤酒”和“尿布” 的故事。 这个故事的背景是什么呢?
  • 本文简单介绍传统数据挖掘关联规则算法中的Apriori算法,以及在挖掘中医医案辨证规律中的应用。并简单分析传统算法缺点,提出简要的改进思路。 文章目录一、关联规则简介二、Apriori算法简介三、Apriori步骤Step1 找...
  • 关联规则Apriori算法实例

    千次阅读 2019-10-18 11:02:55
    Apriori算法关联规则计算结果Apriori算法 关联规则 以下数据使用关联规则计算 import pandas as pd #import Apriori from apriori import * inputfile ='../menu_orders.xls' outputfile = 'tmp/apriori_rules.xls...
  • 关联规则DHP算法详解

    千次阅读 2016-09-29 17:05:38
    参考文献: [1]Park, J. S., Chen, M. S., & Yu, P. S. (1995). An effective hash-based algorithm for mining association rules.... Sigmod Record, 24(2), 175-... 关联规则dhp算法的研究与分析. 佛山科学技术学院学
  • 摘 要 本文介绍了关联规则的基本概念和分类方法,列举了一些关联规则挖掘算法并简要分析了典型算法,展望了关联规则挖掘的未来研究方向。   关键词 数据挖掘,关联规则,频集,Apriori算法,FP-树     1...
  • 基于关联规则的推荐算法

    万次阅读 2019-01-09 17:15:45
    基于关联规则的推荐是根据历史数据统计不同规则出现的关系,形如:X-&amp;amp;gt;Y,表示X事件发生后,Y事件会有一定概率发生,这个概率是通过历史数据统计而来。 对于一个规则X-&amp;amp;gt;Y,有两个指标...
  • 基于关联规则的分类算法

    千次阅读 2017-04-11 10:09:38
    自1993年Agrawal提出数据库中的关联规则挖掘后,关联规则挖掘算法应用得到迅速发展。关联规则的功能不再局限于概念描述。1997年,Ali等人提出了使用分类关联规则进行部分分类的思想,但他们当时认为关联规则在分类...
  • 关联规则算法是在大量数据事例中挖掘项集之间的关联或相关联系,它典型的应用就是购物篮分析,通过关联规则分析帮助我们发现交易数据库中不同的商品(项)之间的联系,找到顾客购买行为模式,如购买某一个商品对其它...
  • 关联规则挖掘算法:Apriori

    千次阅读 2014-09-21 16:33:32
    所谓的关联规则(Association Rule)主要是指数据中的并发关系,最典型的的应用就是对购物篮的分析,发现所有的老爸买尿布的时候都会买啤酒。  关联规则挖掘中有一些容易混淆的术语,详见...
  • R语言实现关联规则 笔者前言:以前在网上遇到很多很好的关联规则的案例,最近看到一个更好的,于是便学习一下,写个学习笔记。 ...推荐算法中 ...物品-物品用关联规则;...关联规则和协同过滤算法 关联规则,...
  • 这一节主要涉及到的数据挖掘算法关联规则及Apriori算法。 由此展开电商网站数据分析模型的构建和电商网站商品自动推荐的实现,并扩展到协同过滤算法关联规则最有名的故事就是啤酒与尿布的故事,非常有效...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 104,181
精华内容 41,672
关键字:

关联规则算法的应用