基于Python的机器学习实战：Apriori算法及关联规则

首先由Apriori算法生成频繁项集及对应的支持度，后根据频繁项集产生规则。

其中频繁项集的产生较为简单，只要运用python的set(集合)，可以很方便的解决集合取并集、交集，子集的情况。要比使用list方便很多，减少代码量。

后面产生规则时要使用递归，代码较短，但较为难以理解，现已加较多注释解释，可以跳过Apriori产生频繁项集实现的代码片段，直接看产生规则的代码片段，也就是后三个函数。

def loadDataSet():
    return [[1,2,3],[1,2,4],[1,3,4],[1,2,3,5],[1,3,5],[2,4,5],[1,2,3,4]]

def screen(freList, dataSet, minSup):
    length, resList, resSup, length2 = len(freList), [], [], len(dataSet)
    for i in range(length-1):
        for j in range(i+1,length):
            t = sorted(list(set(freList[i])|set(freList[j])))
            if len(t) > len(freList[i])+1:
                continue
            if t not in resList:
                resList.append(t)
    resLen, t = len(resList), 0
    while t= minSup:
            resSup.append(support)
            t += 1
        else:
            resList.pop(t)
            resLen = resLen-1
    return resList, resSup

#生成频繁项集
def apriori(dataSet, minSup):
    freList, supList, resList = [], [], []
    allData = set()
    for data in dataSet:
        for i in data:
            allData.add(i)
    for i in allData:
        resList.append([i])
    resList, resSup = screen(resList, dataSet, minSup)
    while resList:
        freList.append(resList)
        supList.append(resSup)
        # print("resList = ",resList)
        # print("resSup = ",resSup)
        resList, resSup = screen(resList, dataSet, minSup)
    return freList, supList

#对某一个规则计算置信度
def conf(tList, dataSet, support):          # tList为一个规则的前缀， dataSet为原始数据集， support为该频繁项集的支持度
    sum = 0
    for data in dataSet:                    #循环计算前缀的支持度
        if set(tList).issubset(set(data)):
            sum += 1
    return support/(sum/1.0/len(dataSet))   #置信度为 频繁项集的支持度 除以 前缀的支持度

#递归确定规则前缀
def calCon(frefix, fList, support, dataSet, minCon): #frefix为规则前缀， fList为频繁项集， support为频繁项集的支持度
    if len(frefix) > 1: #当规则前缀长度大于1时，才能将该前缀继续拆分
        for data in frefix:
            m = set(frefix)     #将前缀转换为集合
            m.remove(data)      #for循环遍历情况下，每次移除规则前缀中的一个值，其余的重新做为规则前缀
            t = sorted(list(m)) #t为当前的规则前缀
            latter = sorted(list(set(fList) - set(t)))  #latter为规则后缀
            confidence = conf(t, dataSet, support)      #计算该规则前缀对应的置信度
            if confidence >= minCon:
                print(t, "-->", latter, ":", confidence)
                calCon(t, fList, support, dataSet, minCon)    #将新的规则前缀递归调用该函数，直到前缀长度不能再拆分
    return 0

#规则产生函数
def generateRules(freList, supList, dataSet, minCon):   #freList为所有的频繁项集， supList为频繁项集对应的支持度，
                                                          # dataSet为数据集， minCon为最小置信度
    for i, List in enumerate(freList):
        for j, fList in enumerate(freList[i]):      #两层for循环遍历每一个频繁项集
            calCon(fList, fList, supList[i][j], dataSet, minCon)    #fList为某个频繁项集， minCon为最小置信度，
                                                                    # 第一个参数是规则前缀，其初始化值为频繁项集，第二个参数是频繁项集
                                                                    # supList[i][j]为频繁项集对应的支持度， dataSet为整个数据集

if __name__ == '__main__':
    dataSet = loadDataSet()
    minSup, minCon = 0.25, 0.7      #minSup最小支持度, minCon最小置信度
    for data in dataSet:
        data.sort()
    freList, supList = apriori(dataSet,minSup)
    print("频繁项集：",freList)
    print("支持度集合：",supList)
    generateRules(freList, supList, dataSet, minCon)

设定了最小支持度和最小置信度，结果如下：