关联挖掘和Aprioir算法

Apriori算法

• 优点：易编码实现
• 缺点：在大数据集上可能较慢
• 适用数据类型：数值型或者标称型

算法过程:

关联分析是一种在大规模数据集中寻找有意思的关系的任务，这里的有意思的关系有两种：频繁项集（frequent item sets）或关联规则（association rules）。
支持度（support）：一个项集的支持度被定义为数据集中该项集的记录所占的比例。
置信度（confidence）：关联规则A->B的置信度表示为support(A,B)/support(A)

单纯暴力做的话有2^n-1个组合
Apriori原理：如果某个项集是频繁的那么它的子项集也是频繁的。
反过来看就是说一个项如果不是频繁项的话，那么包含他的项也不是频繁项

这里主要是两个过程：
1.生成频繁项集：

这是一个挺简单的过程就是两个集合C、L来回倒，C就是通过初选的集合（像是最原始的啊，组合出来的啊）；L是通过支持度筛选的集合。过程大体如下：
1.根据原始数据集构建单个项组成的集合C1
2.根据C1计算L1
3.找出L1中可以的合并的得到C2
4.重复上述C2 -> L2 -> C3 ->.....->Ck -> Lk

2.推导出关联规则：

通过上一步得到的频繁项集，我们就只需要吧每个频繁项集里能够列出的规则都列出来，然后计算置信度，选出置信度符合要求的就可以了。

函数：

loadDataSet()
导入数据集，数据集包含多条list，每个list是一个项集
createC1(dataSet)
创建C1，提取出所有单个的项，这里用frozenset的原因是后面要用这个作为字典的key
scanD(D, Ck, minSupport)
过滤掉Ck中不符合最小支持度的，返回满足的Lk和最小支持度
apprioriGen(Lk, k)
将Lk合并得到Ck+1，这里通过只对前k-1个元素进行比较，可以减少遍历次数。比如合并{0,1}，{0,2}，{1,2}合并，只需要判断一次就行
apriori(dataSet, minsupport=0.5)
将上面的几个函数综合起来，完成整个过程。结束条件是不再能够产生新的项集
generateRules(L, supportData, minConf=0.7)
生成关联规则的主函数，这里要从包含两个项的频繁项集开始判断
calcConf(freqSet, H, supportData, brl, minConf=0.7)
对于给定的频繁项集freqSet和可以推断出来的H计算置信度，得到关联规则
rulesFromConseq(freqSet, H, supportData, brl, minConf=0.7)
这里的不同是H可以变得更复杂，比如说现在有{1,2,3}-->{1}{2}，这里我们希望将H进一步合并得到{1,2}从而更加充分的发掘关联规则。这是一个递归的过程知道无法再合并结束。

1.  #coding=utf-8
    def loadDataSet():
        return [[1,3,4],[2,3,5],[1,2,3,5],[2,5]]
    def creteC1(dataSet):
        C1 = []
        for transaction in dataSet:
            for item in transaction:
                if [item] not 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 ssCnt.has_key(can):
                        ssCnt[can] += 1
                    else:
                        ssCnt[can] = 1
        numItems = float(len(D))
        retList = []
        supportData = {}
        for key in ssCnt:
            supprt = ssCnt[key] / numItems
            if supprt >= minSupport:
                retList.append(key)
            supportData[key] = supprt
        return retList,supportData
    def appriGen(Lk,k):
        retList = []
        lenLk = len(Lk)
        for i in range(lenLk):
            for j in range(i+1, lenLk):
                L1 = list(Lk[i])[:k-2]#前k-1个
                L2 = list(Lk[i])[:k-2]
                L1.sort()
                L2.sort()
                if L1 == L2:
                    retList.append(Lk[i] | Lk[j])
        return retList
    def apriori(dataSet, minSupport=0.5):
        C1 = creteC1(dataSet)
        D = map(set, dataSet)
        L1, supportData = scanD(D,C1,minSupport=0.7)
        L = [L1]
        k=2
        while len(L[k-2]) > 0:
            Ck = appriGen(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):
        bigRules = []
        for i in range(1,len(L)):#从包含两个的开始
            for freqSet in L[i]:
                H1 = [frozenset([item]) for item in freqSet]
                if (i>1):#频繁项集元素数目大于2
                    rulesFormConseq(freqSet,H1,supportData,bigRules,minConf)
                else:
                    calcConf(freqSet,H1,supportData,bigRules,minConf)
        return bigRules
    def calcConf(freqSet, H, supportData,brl,minConf=0.7):
        prunedH = []
        for conseq in H:
            conf = supportData[freqSet] / supportData[freqSet - conseq]
            print 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 = appriGen(H,m+1)
            Hmp1 = calcConf(freqSet,Hmp1,supportData,brl,minConf)
            if len(Hmp1)>1:
                rulesFromConseq(freqSet,Hmp1,supportData,brl,minConf)
    def main():
        dataSet = loadDataSet()
        L,supportData = apriori(dataSet, minSupport=0.7)
        print L
        rules = generateRules(L,supportData,minConf=0.7)
        print rules
   
    if __name__ == '__main__':
        main()

2. 机器学习笔记索引

来自为知笔记(Wiz)