Apriori算法 进行关联分析

 

Apriori算法主要用于在大规模数据中寻找数据之间的关系，包括频繁项集和关联规则

频繁项集：经常一起出现的物品的集合

关联规则：两个物品之间的相关性

例如：以下有四条购物记录

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

商品1和商品2之间的关系就是关联规则

项集的支持度：数据集中包含该项集的记录的比例，针对项集，我们一般会定义一个

例：[1,2]的支持度为3/4   [2]的支持度为1

置信度：置信度是针对关联规则产生的  计算方式：A->B的置信度：[A,B]支持度/[A]支持度

例：[2]->[1]的置信度为3/4 计算方式为[1,2]支持度/[2]支持度

频繁项集：大于最小支持度的项集就是频繁项集

频繁项集的性质: 

    1.频繁项集的所有子集都是频繁项集      例：[1,2,4]是频繁项集 [1,2] [1] [4]等都是频繁项集

    2.非频繁项集的所有超集都是非频繁项集    例：[1]是非频繁项集 [1,2] [1,4]都是非频繁项集

选出频繁项集

loadDataSet()：加载数据集

createC1(数据集)：生成只有一个元素的候选项集 即[1] [2] [3] [4] [5]

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 list(map(frozenset,C1))

 

计算所有项集的支持度，返回所有支持度大于最小支持度的项集（即频繁项集） 

scanD(数据集，候选项集，最小支持度） retList 频繁项集 supportData频繁项集的支持度

def scanD(D,Ck,minSupport):
    ssCnt = {}
    for tid in D:
        for can in Ck:
            if can.issubset(tid):
                if not ssCnt.__contains__(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

 

将大小为k-1的候选项集合并为大小为K的候选项集 （当前k-2个元素相同时则合并）

aprioriGen(候选项集，K)

def aprioriGen(Lk,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:
                retList.append(Lk[i]|Lk[j])
    return retList

 

从只有一个元素的候选项集开始，选择大于最小支持度的候选项集，然后合并项集，重复上述操作，直到当前候选项集的数量为0时结束。

apriori(数据集，最小支持度)

def apriori(dataSet,minSupport = 0.5):
    C1 = createC1(dataSet)
    D = list(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

选出关联规则

项集C(a,b,c,d...) A包含C中部分元素 B=C-A 
计算A->B的置信度(C，包含一堆A的数组，项集的支持度，关联规则集合，最小置信度)

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

计算C所有组合的置信度(C，包含一堆A的数组，项集的支持度，关联规则集合，最小置信度)

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)

generateRules(符合最小支持度的频繁项集，该项集的支持度，最小置信度）返回大于最小置信度的关联规则

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