机器学习实战---使用Apriori算法进行关联分析

一：参考资料

（一）机器学习实战或者见https://blog.csdn.net/qq_36523839/article/details/82191677

（二）Apriori算法是什么？适用于什么情境？（更好的理解关联规则）

（三）python中set和frozenset方法和区别

二：实现Apriori算法中的辅助函数

（一）加载数据

#1.加载数据
def loadDataSet():
    return [[1,3,4],[2,3,5],[1,2,3,5],[2,5]]    #模拟了多个（4）订单，每个订单中购买了不同的商品

（二）创建C1集合，是对各个订单数据统一统计，返回唯一的不重复的商品号

#2.创建C1集合，是对各个订单数据统一统计，返回唯一的不重复的商品号
def createC1(dataSet):
    C1 = []     #先设置为列表，表示可以改变  #注意：我们在C1列表中存放的还是列表，不是直接的数据
    for dts in dataSet:
        for dt in dts:
            if not [dt] in C1:  #注意：我们在C1列表中存放的还是列表，不是直接的数据
                C1.append([dt])

    C1.sort()   #进行排序操作
    return list(map(frozenset,C1))    #返回不可变集合（以为不可变集合可以作为字典键值使用）,使用list将map转list

（三）根据数据集、和我们在createC1函数中获取的候选项集列表Ck,以及我们设置的支持度。返回满足最小支持度要求的集合

#3.根据数据集、和我们在createC1函数中获取的候选项集列表Ck,以及我们设置的支持度。返回满足最小支持度要求的集合
def scanD(D,Ck,minSupport): #D是数据集，由loadDataSet获取
    ssCnt = {}

    #实现统计出现各个商品在多少个订单中出现
    for tid in D:   #遍历所有订单
        for can in Ck:  #遍历所有的商品号，是不可变集合类型
            if can.issubset(tid):   #如果是订单的子集，表示出现在一个订单中，可以+1计数
                if not can in ssCnt:    #py3没有has_key方法
                # if not ssCnt.has_key(can):  #注意：这就是我们要的不可变集合使用位置，是要作为字典的键
                    ssCnt[can] = 1
                else:
                    ssCnt[can] += 1

    #计算各个商品的支持度，返回满足最小支持度的商品号
    numItems = len(D)   #计算所有订单数
    retList = [] #返回所有满足最小支持度的商品号
    supportData = {}    #返回所有商品的支持度

    for key in ssCnt.keys():
        support = ssCnt[key] / numItems
        if support >= minSupport:
            retList.append(key)
        supportData[key] = support

    return retList,supportData

三：Apriori算法实现，获取候选频繁项集

（一）实现将多个列表合并（辅助Apriori算法）：具体就是将多个n维列表合并维多个n+1维的列表

#二：Apriori算法实现
#1.实现将多个列表合并：具体就是将多个n维列表合并维多个n+1维的列表
#重点：我们要将多个n维列表合并维多个n+1维的列表，那么我们必须保证要合并的两个列表前n-1个数据是相同的，合并后才会变为n+1维
def aprioriGen(Lk,K):   #实现合并，创造新的CK。注意：这里的K是只我们合并后列表的长度,Lk的实际长度是K-1
    retList = []
    lenLK = len(Lk)
    for i in range(lenLK): #进行遍历合并
        for j in range(i+1,lenLK):
            L1 = list(Lk[i])[:K-2] #Lk的实际长度是K-1,所以我们只需要设置Lk的K-1-1即可
            L2 = list(Lk[j])[:K-2]
            L1.sort()   #之所以我们在这里进行排序，因为在createC1初始数据中，已经排序完成，后面新加入的数据也是自动排序的
            L2.sort()   #注释之后无影响
            if L1==L2:
                retList.append(Lk[i] | Lk[j])   #注意对于frozenset类型，我们可以使用|进行并集操作，并且并集后的数据是排序后的

    return retList  #返回合并后维n+1维的列表数据

（二）实现Apriori算法

#2.实现Apriori算法
def apriori(dataSet,minSupport=0.5):
    #先获取初始数据
    C1 = createC1(dataSet)
    #获取数据
    D = list(map(set,dataSet))  #注意：我们需要使用list将数据从map转换为list
    #进行一次裁剪
    L1,supportData = scanD(D,C1,minSupport)

    #开始进行循环处理
    L = [L1]    #将每一个维度的列表都放入列表中
    K = 2
    while len(L[K-2]) > 0: #从LK[0]即列表长度为1开始
        Ck = aprioriGen(L[K-2],K)   #进行合并操作
        Lk,supportNewData = scanD(D,Ck,minSupport)  #进行新的裁剪
        #更新新的维度数据Lk的支持度
        supportData.update(supportNewData)  #对于没有的n+1维长度的列表，进行添加
        L.append(Lk)    #添加操作
        K += 1
    #注意：对于上面循环中，我们扩展到最后可能会出现，由于scanD方法中对于支持度较低的数据进行过滤，导致后面出现返回的Lk为空集，但是却更新了一次支持度（对最后面的n维列表更新）
    #所以必然L最后为[],导致len(LK[K-2])==0,退出循环
    return L,supportData

（三）测试上述代码

#测试
dataset = loadDataSet()
L,supportData = apriori(dataset,0.7)

L,supportData = apriori(dataset,0.5)

[[frozenset({1}), frozenset({3}), frozenset({2}), frozenset({5})], [frozenset({1, 3}), frozenset({2, 3}), frozenset({3, 5}), frozenset({2, 5})], [frozenset({2, 3, 5})], []]

四：基于上面的候选频繁项集，实现关联规则获取

（一）关联规则主函数实现

#三：从上面获取的频繁项集中挖掘出关联规则https://www.zhihu.com/question/19912364/answer/963934469?utm_source=wechat_session
#注意：frozenset不可变集合是可以作为dict重点的key处理 a =frozenset({2, 5}) b = {a:1}
#注意：frozenset可以进行多种运算，比如|，-...

#1.关联规则生成函数
def generateRules(L,supportData,minConf=0.7):   #L是我们上面apriori(dataset,0.7)求解的频繁项集，supportData是所有数据集的支持度信息，minConf是置信度
    bigRuleList = []    #存放关联规则 注意：对于列表，字典等类型，通过函数可以进行修改

    for i in range(1,len(L)):   #我们只对列表有两个及以上的元素的集合进行关联处理（单个没有关联）比如i=1时：[frozenset({2, 5}),frozenset({3, 4})]
        for freqset in L[i]:    #遍历集合中元素所有都是含有i+1个元素的列表的数据信息    frozenset({2, 5})
            H1 = [frozenset([item]) for item in freqset]    #注意：对应frozenset初始化，必须使用[]或者{}   [frozenset({2}),frozenset({5})]
            if i > 1:   #对于i>1,即集合中每个元素列表长度大于2，我们的规则可以有多种方法[a,b,c]  a=>bc ac=>b ...，所以我们将其封装为一个函数
                rulesFromConseq(freqset,H1,supportData,bigRuleList,minConf)
            else:   #对于i=1时，表示有2两个元素在集合列表中，我们只包含一个映射[a,b]   a=>b b=>a   单个元素之间的映射（通过calConf可以实现这一种映射）
                calConf(freqset,H1,supportData,bigRuleList,minConf) #计算置信度
            #注意：calConf可以看做rulesFromConseq的辅助函数
    return bigRuleList

（二）实现置信度求解函数

#2.辅助函数，计算置信度
def calConf(freqset,H1,supportData,bigRuleList,minConf):
    prunedH = []    #保存置信度
    for conseq in H1:
        #置信度confidence=P(B|A)=P(AB)/P(A)),指的是发生事件A的基础上发生事件B的概率（相当与条件概率）。
        conf = supportData[freqset] / supportData[freqset-conseq]   #计算置信度看机器学习实战
        if conf >= minConf: #大于最小置信度，打印并保存
            print(freqset-conseq,"---->",conseq,conf)   #打印前提条件，对于结果，置信度
            bigRuleList.append((freqset-conseq,conseq,conf))    #保存规则
            prunedH.append(conseq)  #保存本次置信度检查中，满足最小置信度要求的规则，但是保存不全，后面也没有使用，应该不需要

    return prunedH

（三）从初始的候选项集中，生成更多的数据集，进行关联规则查看,借助上面的函数计算置信度，也可以将两个函数合二为一

#3.从初始的候选项集中，生成更多的数据集，进行关联规则查看,借助上面的函数计算置信度，也可以将两个函数合二为一
def rulesFromConseq(freqset,H1,supportData,bigRuleList,minConf=0.7):    #注意：在递归过程中，freqset不会变化，H1会随着合并增加
    m = len(H1[0])  #查看当前输入的列表中，每个不可变集合元素个数
    #查看频繁项是否可以大到可以移除大小为m的子集
    if len(freqset) >= (m+1):    #如果我们传入的原始freqset长度>m+1则可以正常递归，假设同上假设fregset为frozenset({2, 5})，H1为[frozenset({2}), frozenset({5})]
        #重点注意：len(freqset) > (m+1)中，如果len(freqset)=3，m=2呢？？？
        #因此对比书本代码进行修改，使得可以出现a,b=>c的情况
        Hmp1 = calConf(freqset,H1,supportData,bigRuleList,minConf)    #根据我们合并的新的集合，进行置信度检测
        Hmp1 = aprioriGen(Hmp1,m+1)   #进行合并操作
        if len(Hmp1) > 1:   #继续递归，直到我们的函数不满足len(freqset) > (m+1)时退出
            rulesFromConseq(freqset,Hmp1,supportData,bigRuleList,minConf)

（四）进行测试

L,supportData = apriori(dataset)
rules = generateRules(L,supportData,0.5)

（五）全部代码

import numpy as np

#一：实现Apriori算法中的辅助函数
#1.加载数据
def loadDataSet():
    return [[1,3,4],[2,3,5],[1,2,3,5],[2,5]]    #模拟了多个（4）订单，每个订单中购买了不同的商品

#2.创建C1集合，是对各个订单数据统一统计，返回唯一的不重复的商品号
def createC1(dataSet):
    C1 = []     #先设置为列表，表示可以改变  #注意：我们在C1列表中存放的还是列表，不是直接的数据
    for dts in dataSet:
        for dt in dts:
            if not [dt] in C1:  #注意：我们在C1列表中存放的还是列表，不是直接的数据
                C1.append([dt])

    C1.sort()   #进行排序操作
    return list(map(frozenset,C1))    #返回不可变集合（以为不可变集合可以作为字典键值使用）,使用list将map转list

#3.根据数据集、和我们在createC1函数中获取的候选项集列表Ck,以及我们设置的支持度。返回满足最小支持度要求的集合
def scanD(D,Ck,minSupport): #D是数据集，由loadDataSet获取
    ssCnt = {}

    #实现统计出现各个商品在多少个订单中出现
    for tid in D:   #遍历所有订单
        for can in Ck:  #遍历所有的商品号，是不可变集合类型
            if can.issubset(tid):   #如果是订单的子集，表示出现在一个订单中，可以+1计数
                if not can in ssCnt:    #py3没有has_key方法
                # if not ssCnt.has_key(can):  #注意：这就是我们要的不可变集合使用位置，是要作为字典的键
                    ssCnt[can] = 1
                else:
                    ssCnt[can] += 1

    #计算各个商品的支持度，返回满足最小支持度的商品号
    numItems = len(D)   #计算所有订单数
    retList = [] #返回所有满足最小支持度的商品号
    supportData = {}    #返回所有商品的支持度

    for key in ssCnt.keys():
        support = ssCnt[key] / numItems
        if support >= minSupport:
            retList.append(key)
        supportData[key] = support

    return retList,supportData

#二：Apriori算法实现
#1.实现将多个列表合并：具体就是将多个n维列表合并维多个n+1维的列表
#重点：我们要将多个n维列表合并维多个n+1维的列表，那么我们必须保证要合并的两个列表前n-1个数据是相同的，合并后才会变为n+1维
def aprioriGen(Lk,K):   #实现合并，创造新的CK。注意：这里的K是只我们合并后列表的长度,Lk的实际长度是K-1
    retList = []
    lenLK = len(Lk)
    for i in range(lenLK): #进行遍历合并
        for j in range(i+1,lenLK):
            L1 = list(Lk[i])[:K-2] #Lk的实际长度是K-1,所以我们只需要设置Lk的K-1-1即可
            L2 = list(Lk[j])[:K-2]
            L1.sort()   #之所以我们在这里进行排序，因为在createC1初始数据中，已经排序完成，后面新加入的数据也是自动排序的
            L2.sort()   #注释之后无影响
            if L1==L2:
                retList.append(Lk[i] | Lk[j])   #注意对于frozenset类型，我们可以使用|进行并集操作，并且并集后的数据是排序后的

    return retList  #返回合并后维n+1维的列表数据

#2.实现Apriori算法
def apriori(dataSet,minSupport=0.5):
    #先获取初始数据
    C1 = createC1(dataSet)
    #获取数据
    D = list(map(set,dataSet))  #注意：我们需要使用list将数据从map转换为list
    #进行一次裁剪
    L1,supportData = scanD(D,C1,minSupport)

    #开始进行循环处理
    L = [L1]    #将每一个维度的列表都放入列表中
    K = 2
    while len(L[K-2]) > 0: #从LK[0]即列表长度为1开始
        Ck = aprioriGen(L[K-2],K)   #进行合并操作
        Lk,supportNewData = scanD(D,Ck,minSupport)  #进行新的裁剪
        #更新新的维度数据Lk的支持度
        supportData.update(supportNewData)  #对于没有的n+1维长度的列表，进行添加
        L.append(Lk)    #添加操作
        K += 1
    #注意：对于上面循环中，我们扩展到最后可能会出现，由于scanD方法中对于支持度较低的数据进行过滤，导致后面出现返回的Lk为空集，但是却更新了一次支持度（对最后面的n维列表更新）
    #所以必然L最后为[],导致len(LK[K-2])==0,退出循环
    return L,supportData

#测试
dataset = loadDataSet()
# L,supportData = apriori(dataset,0.5)
# print(L)    #[[frozenset({1}), frozenset({3}), frozenset({2}), frozenset({5})], [frozenset({1, 3}), frozenset({2, 3}), frozenset({3, 5}), frozenset({2, 5})], [frozenset({2, 3, 5})], []]

#三：从上面获取的频繁项集中挖掘出关联规则https://www.zhihu.com/question/19912364/answer/963934469?utm_source=wechat_session
#注意：frozenset不可变集合是可以作为dict重点的key处理 a =frozenset({2, 5}) b = {a:1}
#注意：frozenset可以进行多种运算，比如|，-...

#1.关联规则生成函数
def generateRules(L,supportData,minConf=0.7):   #L是我们上面apriori(dataset,0.7)求解的频繁项集，supportData是所有数据集的支持度信息，minConf是置信度
    bigRuleList = []    #存放关联规则 注意：对于列表，字典等类型，通过函数可以进行修改

    for i in range(1,len(L)):   #我们只对列表有两个及以上的元素的集合进行关联处理（单个没有关联）比如i=1时：[frozenset({2, 5}),frozenset({3, 4})]
        for freqset in L[i]:    #遍历集合中元素所有都是含有i+1个元素的列表的数据信息    frozenset({2, 5})
            H1 = [frozenset([item]) for item in freqset]    #注意：对应frozenset初始化，必须使用[]或者{}   [frozenset({2}),frozenset({5})]
            if i > 1:   #对于i>1,即集合中每个元素列表长度大于2，我们的规则可以有多种方法[a,b,c]  a=>bc ac=>b ...，所以我们将其封装为一个函数
                rulesFromConseq(freqset,H1,supportData,bigRuleList,minConf)
            else:   #对于i=1时，表示有2两个元素在集合列表中，我们只包含一个映射[a,b]   a=>b b=>a   单个元素之间的映射（通过calConf可以实现这一种映射）
                calConf(freqset,H1,supportData,bigRuleList,minConf) #计算置信度
            #注意：calConf可以看做rulesFromConseq的辅助函数
    return bigRuleList

#2.辅助函数，计算置信度
def calConf(freqset,H1,supportData,bigRuleList,minConf):
    prunedH = []    #保存置信度
    for conseq in H1:
        #置信度confidence=P(B|A)=P(AB)/P(A)),指的是发生事件A的基础上发生事件B的概率（相当与条件概率）。
        conf = supportData[freqset] / supportData[freqset-conseq]   #计算置信度看机器学习实战
        if conf >= minConf: #大于最小置信度，打印并保存
            print(freqset-conseq,"---->",conseq,conf)   #打印前提条件，对于结果，置信度
            bigRuleList.append((freqset-conseq,conseq,conf))    #保存规则
            prunedH.append(conseq)  #保存本次置信度检查中，满足最小置信度要求的规则，但是保存不全，后面也没有使用，应该不需要

    return prunedH

#3.从初始的候选项集中，生成更多的数据集，进行关联规则查看,借助上面的函数计算置信度，也可以将两个函数合二为一
def rulesFromConseq(freqset,H1,supportData,bigRuleList,minConf=0.7):    #注意：在递归过程中，freqset不会变化，H1会随着合并增加
    m = len(H1[0])  #查看当前输入的列表中，每个不可变集合元素个数
    #查看频繁项是否可以大到可以移除大小为m的子集
    if len(freqset) >= (m+1):    #如果我们传入的原始freqset长度>m+1则可以正常递归，假设同上假设fregset为frozenset({2, 5})，H1为[frozenset({2}), frozenset({5})]
        #重点注意：len(freqset) > (m+1)中，如果len(freqset)=3，m=2呢？？？
        #因此对比书本代码进行修改，使得可以出现a,b=>c的情况
        Hmp1 = calConf(freqset,H1,supportData,bigRuleList,minConf)    #根据我们合并的新的集合，进行置信度检测
        Hmp1 = aprioriGen(Hmp1,m+1)   #进行合并操作
        if len(Hmp1) > 1:   #继续递归，直到我们的函数不满足len(freqset) > (m+1)时退出
            rulesFromConseq(freqset,Hmp1,supportData,bigRuleList,minConf)

L,supportData = apriori(dataset)
rules = generateRules(L,supportData,0.5)

五：总结

Apriori算法简单，易于实现。但是它也有自己的缺点，数据集很大的时会出现下面两个问题。

1. 需要多次扫描数据集

例如在Apriori算法循环中：即每次增加新的频繁项集的时候，Apriori算法都会重新扫描整个数据集

Lk,supportNewData = scanD(D,Ck,minSupport)  #进行新的裁剪

或者后面求解的支持度（针对每个数据都存在支持度），也存在多次扫描

2. 可能会产生庞大的候选集

当数据极大，支持度设置太小时

3.FP-growth算法引出

针对Apriori算法的性能瓶颈问题，2000年Jiawei Han等人提出了基于FP树生成频繁项集的FP-growth算法。该算法只进行2次数据库扫描且它不使用侯选集，直接压缩数据库成一个频繁模式树，最后通过这棵树生成关联规则。

研究表明它比Apriori算法大约快一个数量级。