数据关联分析 association analysis (Aprior算法，python代码）

1基本概念

购物篮事务（market basket transaction),如下表，表中每一行对应一个事务，包含唯一标识TID,和购买的商品集合。本文介绍一种成为关联分析(association analysis)的方法，这种方法，可以从下表可以提取出，{尿布}—>牛奶.

两个关键问题：1大型数据计算量很大。2发现的某种模式可能是虚假，偶然发生的。

2问题定义

把数据可以转换为如下表的二元表示，非二元不在本文讨论范围

项集

项集的支持度计数：

关联规则：

我们要发现，满足最小支持度与最小置信度的规则。

l 频繁项集(frequent itemset):发现满足最小支持度阈值的所有项集，这些项集成为频繁项集。

l 规则的产生：从上一步发现的频繁项集中提取所有高置信度的规则，这些规则成为强规则(strong rule)

频繁项集的产生

穷举法：

利用格结构（lattice structure）产生所有候选项集（candidate itemset）.

利用穷举法，计算每个候选项集的支持度计数。但是该方法计算量太大。

先验(apriori)原理：

如果一个项集是频繁的，则的所有子集一定是频繁的。若某项集是非频繁的，则其所有的超级也一定是非频繁的。

如下图，若{c,d,e}是频繁项集，则它的子集一定是频繁项集。

项集{a,b}是非频繁的，则其所有的超级也一定是非频繁的,如下图。

Aprior算法的频繁项集产生

1. 确定每个1-项集的支持度计数，删除不满足最小支持度的1-项集。（步骤1,2）

2. 迭代：使用频繁(k-1)项集，产生新的候选k项集（步骤5）

3. 为了对候选k项集计算支持度计数，再次扫描数据(6-10)

4. 删去支持度小于最小支持度（minsup）的候选集

5. 当Fk=NULL,结束。

6. 候选集是所有频繁i项集的交际。i=1,2…

方法：产生(频繁k-项集)。(step5)

函数aprior-gen的候选产生过程，合并一对频繁k-1项集，仅当他们前k-2个项都相同时，即

图例：

Python代码：

def aprioriGen(Lk,k):#create ck(k项集)    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:#比较i,j前k-1个项若相同，和合并它俩                retList.append(Lk[i] | Lk[j])#加入新的k项集 | stanf for union    return retList

支持度计数：算法(6-12)代码

Python代码：

def scanD(D,ck,minSupport):#dataset,a list of candidate set,最小支持率    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        numItem=float(len(D))    retList=[]    supportData={}    for key in ssCnt:        support=ssCnt[key]/numItem        if support>=minSupport:            retList.insert(0,key)            supportData[key]=support                return retList,supportData#返回频繁k项集，相应支持度

频繁项集的产生：

def apriori(dataSet,minSupport=0.5):    C1=createC1(dataSet)    D=map(set,dataSet)    L1,supportData=scanD(D,C1,minSupport)#利用k项集生成频繁k项集（即满足最小支持率的k项集）    L=[L1]#L保存所有频繁项集        k=2    while(len(L[k-2])>0):#直到频繁k-1项集为空        Ck=aprioriGen(L[k-2],k)#利用频繁k-1项集 生成k项集        Lk,supK= scanD(D,Ck,minSupport)        supportData.update(supK)#保存新的频繁项集与其支持度        L.append(Lk)#保存频繁k项集        k+=1    return L,supportData#返回所有频繁项集，与其相应的支持率

规则产生(mining rules)

定理：

例如下：若bcd ->a是低置信度的，则它的子代都是低置信度的。利用此定理可以避免不必要的计算，减少运算复杂度。

算法流程如下：

 

python代码：

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)#添加入被修剪过的H中            return prunedHdef rulesFromConseq(freqSet,H,supportData,brl,minConf=0.7):         m=len(H[0])#H是一系列后件长度相同的规则，所以取H0的长度即可    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)            def generateRules(L,supportData,minConf=0.7):    import pdb    pdb.set_trace()    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

 

 

 

整个prior算法的python代码

算法函数：

# -*- coding: utf-8 -*-"""Created on Wed Dec 04 22:25:57 2013@author: Administrator"""def loadDataSet():    return [[1,3,4],[2,3,5],[1,2,3,5],[2,5]]def createC1(dataSet):#产生单个item的集合    C1=[]    for transaction in dataSet:        for item in transaction:             if not [item] in C1:                C1.append([item])        C1.sort()        return map(frozenset,C1)#给C1.list每个元素执行函数        def scanD(D,ck,minSupport):#dataset,a list of candidate set,最小支持率    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        numItem=float(len(D))    retList=[]    supportData={}    for key in ssCnt:        support=ssCnt[key]/numItem        if support>=minSupport:            retList.insert(0,key)            supportData[key]=support                return retList,supportData#返回频繁k项集，相应支持度        def aprioriGen(Lk,k):#create ck(k项集)    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:#比较i,j前k-1个项若相同，和合并它俩                retList.append(Lk[i] | Lk[j])#加入新的k项集 | stanf for union    return retList        def apriori(dataSet,minSupport=0.5):    C1=createC1(dataSet)    D=map(set,dataSet)    L1,supportData=scanD(D,C1,minSupport)#利用k项集生成频繁k项集（即满足最小支持率的k项集）    L=[L1]#L保存所有频繁项集        k=2    while(len(L[k-2])>0):#直到频繁k-1项集为空        Ck=aprioriGen(L[k-2],k)#利用频繁k-1项集 生成k项集        Lk,supK= scanD(D,Ck,minSupport)        supportData.update(supK)#保存新的频繁项集与其支持度        L.append(Lk)#保存频繁k项集        k+=1    return L,supportData#返回所有频繁项集，与其相应的支持率            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)#添加入被修剪过的H中            return prunedHdef rulesFromConseq(freqSet,H,supportData,brl,minConf=0.7):         m=len(H[0])#H是一系列后件长度相同的规则，所以取H0的长度即可    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)            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

 

测试代码：

import aprioridataSet=apriori.loadDataSet()C1=apriori.createC1(dataSet)D=map(set,dataSet)L1,suppData0=apriori.scanD(D,C1,0.5)L,suppData=apriori.apriori(dataSet)print Lrules=apriori.generateRules(L,suppData,minConf=0.5)

 

 

参数文献：

1数据挖掘导论

2machine learning in action