【商业挖掘】关联规则——Apriori算法(最全~)

一、关联规则挖掘

** 1. 定义：参考百度百科即可：**

** “假设是项的集合。给定一个交易数据库D，其中每个事务**(Transaction)t是I的非空子集，即，每一个交易都与一个唯一的标识符TID(Transaction ID)对应。关联规则在D中的支持度(support)是D中事务同时包含X、Y的百分比，即概率；置信度(confidence)是D中事务已经包含X的情况下，包含Y的百分比，即条件概率。如果满足最小支持度****阈值和最小置信度阈值，则认为关联规则是有趣的。这些阈值是根据挖掘需要人为设定。” ——引用百度百科词条解释

百度百科或者一些教材说的太专业了反而很难理解，不妨看下面的个人观点大白话解释：

---

** 关联规则提出的背景是购物篮分析，A顾客会买零食、面包、牛奶，不同客户会有不同的消费，那每一个顾客的消费集合就构成了一个事务（消费-支付事务），那这个事务集就上上面说的“唯一标识符TID”；那问题是，每种商品被不同顾客购买了多少次呢？那么这个次数就是“支持频数”，那被所有顾客购买的概率就是“支持度Sup”；那问题又来了，X商品和Y商品之间的被购买关系是怎样的呢？比如消费者买了面包，还可能会买面包伴侣（牛奶等），那面包和牛奶就构成了关联，那这个关联的置信度又是多少呢？就是消费者买了面包，再去买牛奶的概率是多少呢？反之亦言。那这个条件概率，就是上面提到的置信度。**

   ** 2. 作用：**可以揭示数据集的内在的、重要的特性。是很多重要数据挖掘任务的**基础关联、相关和因果分析**的基本方式。在序列、结构（e.g.子图）模式分析；时空、多媒体、时序和流数据中的模式分析；分类：关联分类；聚类分析：基于频繁模式的聚类；数据仓库：冰山方体计算等各类数据挖掘工作中发挥着基础性作用。

    说的又很**奇奇怪怪**的，关联规则的挖掘到底有什么用？还是可以回到上面的**购物篮分析**，比如啊，我们分析了面包和牛奶的关联规则之后，如果满足支持度、置信度要求，那么我们就可以把这两个商品放在一块儿（可能会增加购买），或者在做*Promotion*打造时可以辅助策略制定等等。事实上，从**商业视角**来说，他就是对*People、Place、Promotion、Price*策略制定的综合考量因子（4ps战略）。
    在和复旦大佬学长交流之后，他提到了异常检测，虽然我也不太明白什么道理。但是结合**财会视角**来看，这个关联规则或许还能够对企业行为进行监测。

    那对于**网页开发**来说，点击哪些模块儿？链接？先后顺序？等都是可以考量的点。

———“个人角度，如果有错误请予以斧正！！！”

  **  3. 挖掘的步骤：①找出频繁项集；②由频繁项集，找出满足minsup和minconfi的关联规则。**

如果一个Goodlist由100个商品，如果想要遍历循环，那得到的频繁项集有2^100-1个

↓
引出Apriori算法

二、Apriori-关联规则算法

    Apriori算法利用频繁项集性质的**先验知识**（prior knowledge），通过逐层搜索的迭代方法，即将k-项集用于探察(k+1)-项集，来穷尽数据集中的所有频繁项集。

    **步骤：**先找到频繁1-项集集合*L**1*,然后用*L**1*找到频繁2-项集集合*L**2*，接着用*L**2*找*L**3*，直到找不到频繁k-项集，找每个*L**k*需要一次数据库扫描。最后得到所有满足最小支持的频繁项集合，再进行关联规则输出。

    关于Apriori的解释，CSDN中有非常多的前辈给出了自己非常完备的解释，对其优缺点也进行了深入剖析，我在这里就不做过多解释，向大家推我认为非常非常好的三篇文章链接：

这一篇生动有趣，适合年轻人来看！（点击本文字即可）

这一篇有博主手写的解释！适合小白理解Apriori的步骤！

这一篇也不错噢！

三、Apriori算法分解—Python大白话式实现

    我看了CSDN中很多博主分享的代码，发现很多博主代码趋同（可能复制粘贴），或者直接调用的外部开源的库来实现的，还有的博主自己撰写的，但是用了很多可能不懂的函数来做的，甚至还有的就直接在一个函数里面嵌套多个函数来传递参数实现，读起来感觉，对小白非常不友好。

    那在这里，我就分享一些很简单的代码来实现。包括数据导入、数据处理、调用、关联规则挖掘等完整的分析流程。**我看了一下这个应该是全站流程最全面的代码了**。

                                                    **——当然简单就意味着代码很长，有些地方处理的比较粗糙**

步骤1： 外部库调用❀

    只用到了 pandas itertools 和 自带的time

import pandas as pd #数据导入用
import itertools as it #子集生成用
import time #输出程序员运行时间用

步骤2： 数据导入❀

    因为是全函数编写，最终的数据导入在代码最后，所以直接拿出来看

if __name__ == '__main__':
    # 数据导入
    data = pd.read_excel("D:\OneDrive\桌面\测试数据.xlsx", index_col=0, header=0)
    data = data.applymap(lambda x: str(x).strip())  # 删除导入时可能存在的空格值，比如：“面包”成了“ 面包”
    # 数据格式转换
    data = data.values  # 改为元组型数据，便于list输出
    data = data.tolist()  # 输出为客户*商品集合
    # 设定支持度和置信度
    minsup,minconfi=map(eval,input("请输入支持度和置信度：").split(" "))
    start = time.time()
    Find_rule_apriori(data,minsup,minconfi)
    end=time.time()
    print('Running time: {0} Seconds'.format(end - start))

**步骤3： 数据处理❀ **

    很多博主在数据导入阶段说明不清，不知道最终的导入格式，这里我把**测试数据截图**放出来仅供大家参考，助于后续程序的理解：

    那在Panda导入中会出现一个问题就是，**空白格会被默认为None值**，输出出来就是“non”：

   那么为了处理“nan”值，而常规的pandas的其他功能应该是不能直接删去的，多数还是填充。因此我编写了以下“白话for循环”的Non_deal()函数:

def Non_deal(df):
    list_data = []
    rows = len(df)
    for i in range(0,rows):
        list = df[i]
        list_con = []
        cols = len(list)
        for j in range(0,cols):
            if list[j]!="nan":
                list_con.append(list[j])  
#如果用remove法需要倒序去除，否则无法去除干净（因为每一次去除会导致len-1）
        list_data.append(list_con)
    return list_data

  输出结果为: 可以看到non值都被删去了。**注意remove的使用**，我这里处理比较粗糙，为了用Append多加了一个中间列表List_con，虽然用remove会更快。

**步骤4：输出所有Goodlist❀ **

    事实上也就是备选频繁1项集，这个函数不太重要，后续调用也完全可以替代别的方式，编写的目的是我思考时的便利逻辑过程的一种方式而已。

#目的是得到备选1-项集
def Good_list(df):  #将单个商品集合出来
    list_all=[]
    list_in=Non_deal(df)
    for i in range(0,len(list_in)):
        for j in range(0,len(list_in[i])):
            list_m=[]
            list_m.append(str(list_in[i][j]))
            list_all.append(str(list_m))
        list_all=list(set(list_all))
    for i in range(0,len(list_all)):
        list_all[i]=eval(list_all[i])
    return list_all

**步骤5：项集重组❀ **

    因为Apriori是通过**满足支持度阈值**的***频繁k项集*得到*备选频繁k+1项集合***，因此这一个函数的目的便是进行项集重组，***升阶化***的过程。注意，这个不是放在最前面的逻辑，而是预先编写。为了后面直接调用的准备工作。**可以发现也都是for循环**，连while等等都不带的。由于我们导入数据就选择的是列表格式，因此我们后续工作也就**都利用list**来完成，那么list就需要一直for循环调用，不像dict中直接for item in dict等等方便清晰，前面也说了，细节处理还是较粗糙。

#目的是进行k-1-频繁项集合的重组为k项目集合
def creat_connect(list_c,n): ##实现集合内的重组，例如2-项集合重组为3-项集
    new_list=[]
    for i in range(0,len(list_c)):
        list_a = []
        for j in range(i+1,len(list_c)):
            list_b = list_c[i]
            list_d = []
            for k in range(0,n):
                list_d.append(list_c[j][k])
            list_a = list_b+list_d
            list_a=list(set(list_a))
            list_a.sort()
            new_list.append(str(list_a))
        new_list=list(set(new_list))
    New_list=[]
    for i in range(0,len(new_list)):
        new_list[i]=eval(new_list[i])
        new_list[i].sort()
        if len(new_list[i])==n+1:
            New_list.append(new_list[i])
    return New_list

步骤6：支持度扫描与输出 ❀

    这里就回归了逻辑线条，这里**提供两种方法**，一种是输出counts一种是输出rates，即支持频数和支持度的两种衡量办法，这里仅供大家挑选，两个函数没什么区别。 本find_rule函数用的是counts函数，如果要换记得调整为rates。

#输出每个k-项频繁集的候选集的比率
def sup_rate(df,data):
    m = len(data)  # 事务总数
    item_set_list = []
    for i in range(0,len(df)):
        n=0
        list_n=[]
        for j in range(0,len(data)):
            if (set(df[i]) <= set(data[j]))==True:
                n+=1
        list_n.append(df[i])
        list_n.append(round(n/m,2))
        item_set_list.append(list_n)
    return  item_set_list
#输出每个k-项频繁集的候选集的个数，上有比率写法，两者无本质区别，都可以使用
def sup_counts(df,data): #输出每个1-项频繁集的候选集的次数
    item_set_list = []
    for i in range(0,len(df)):
        n=0
        list_n=[]
        for j in range(0,len(data)):
            if (set(df[i]) <= set(data[j]))==True:
                n+=1
        list_n.append(df[i])
        list_n.append(n)
        item_set_list.append(list_n)
    return  item_set_list

步骤7：根据最小支持度阈值进行减枝叶❀

    其他博主文章也说过，Apriori算法的**核心就是通过剪枝来减少扫描难度**。因为非频繁项集的超级也一定不频繁。

#得到满足最小支持度阈值的关联规则（find——rule of min-sup-rate item）
def sup_satisfy_item(data,min_suprate):
    n = len(data)  # 事务总数
    Good_list1=Good_list(data)
    m = len(Good_list1)  # 商品总数
    dt = sup_counts(Good_list1, data)
    All_freitem_list=[]
    for k in range(1,m):
        dt.sort()
        k_apriori=[]
        for j in range(0,len(dt)):
            if dt[j][-1] >= min_suprate*n: ##减枝过程
                k_apriori.append(dt[j][0])
                k_apriori.sort()
        dt=sup_counts(creat_connect(k_apriori,k),data)
        if len(k_apriori)!=0:
            All_freitem_list.append(k_apriori)
        else:
            break
    return All_freitem_list

**步骤8：对每一个频繁项集进行子集拆分计算confi和rule挖掘❀ **

    这个函数也是一个中间函数，预备工作而已。注意条件（前提是频繁项集，如果不是的话，数量可能非常多，很难挖掘 ）这也是身边其他人或者大家可能会犯的错误，**为啥不通过Good_list清单来生成所有的1/2/3/.../k项备选频繁集，再来扫描其每一个的支持度呢？**那如果是这么想的，就忽略了Apriori算法的**核心**了。具体是什么可以返回自行理解。

——好吧我承认 /(ㄒoㄒ)/~~：事实上Good_list()函数的编写，就是我按照上述逻辑来编写的

def Ksubset_get(df): #获得非空子集（前提条件是频繁项集，否则数量太多，很难挖掘）
    n =len(df)
    k =len(df[0])
    All_nzsubset=[]
    for num in range(n):
        for i in it.combinations(df,num+1):  #调用it.combination 函数
            All_nzsubset.append(list(i))
    return All_nzsubset

**步骤9：Find_rule❀ **

    最后一步了！！**直接进行规则输出就好了**，这一步非常非常非常的复杂，因为**用的是list**不是dict，可能在某些处理上不得不加入很多**中间list来进行暂存以便后续调用**。但其实我后面想了一下，用dict也很复杂，简单不到哪里去的感觉。（主要是没写）

def Find_rule_apriori(data,min_suprate,min_confi):
    a=len(data) #事务总数
    Sup_satisfy_item=sup_satisfy_item(data,min_suprate) #获得满足支持度的频繁项集，第一项为频繁1项集合的集合，以此类推。
    l=len(Sup_satisfy_item) #获得频繁项集集合的集合长度
    for i in range(1,l): #无需对频繁1项集合找寻关联规则，直接从频繁二项集的集合进行扫寻循环
        Sup_satisfy_itemi=Sup_satisfy_item[i]    #得到一个频繁i+1项集合的列表的列表
        m=len(Sup_satisfy_itemi)
        for j in range(0,m):  #为对每一个频繁项集进行扫寻，因此需要再做一次for循环
            Prule = Sup_satisfy_itemi[j]
            list1=[]
            list1.append(Prule)
            item_counts1 = sup_counts(list1,data)[0][-1]  #首先需要得到这一个频繁项集的支持度，或者计算频数也可以
            list1.clear()
            prerule_find = Ksubset_get(Prule)  #得到这一个频繁项集集合的所有非空集合，方便进行关联规则的重组
            prerule_find.remove(prerule_find[-1])  #删除全集
            q = len(prerule_find)   #得到排除全集后的关联重组列表的长度，以便进行for循环
            for z in range(0,q):
                list2=[]
                list2.append(prerule_find[z])
                item_counts2 = sup_counts(list2,data)[0][-1]  #得到每一个关联重组后项集的支持度（或频数）
                list2.clear()
                if item_counts2 > 0:
                    Confi_item = item_counts1/item_counts2 #得到置信度
                    if Confi_item >= min_confi: #置信度减除
                        n=len(prerule_find[z])
                        list3 = Prule[:]
                        for o in range(0, n):
                            list3.remove(str(prerule_find[z][o]))
                        print("{0} ==> {1},sup={2},confi={3}".format(prerule_find[z],list3,round(item_counts1/a,2),round(Confi_item,2)))

    **输出结果：**可以看到，整个程序的运行速度还是比较快的，加入更多的good和tid之后个人认为还是可以保持较快的输出速度。

四、Apriori代码——全部呈上~

import pandas as pd
import numpy as np
import itertools as it
import time
# 去除集合矩阵（i，j）None值，便于计数以及算法，常规的pandas是用来数据清洗和数据填充的，没办法解决这种问题
def Non_deal(df):
    list_data = []
    rows = len(df)
    for i in range(0,rows):
        list = df[i]
        list_con = []
        cols = len(list)
        for j in range(0,cols):
            if list[j]!="nan":
                list_con.append(list[j])  #如果用remove法需要倒序去除，否则无法去除干净（因为每一次去除会导致len-1）
        list_data.append(list_con)
    return list_data
#目的是得到备选1-项集
def Good_list(df):  #将单个商品集合出来
    list_all=[]
    list_in=Non_deal(df)
    for i in range(0,len(list_in)):
        for j in range(0,len(list_in[i])):
            list_m=[]
            list_m.append(str(list_in[i][j]))
            list_all.append(str(list_m))
        list_all=list(set(list_all))
    for i in range(0,len(list_all)):
        list_all[i]=eval(list_all[i])
    return list_all
#目的是进行k-1-频繁项集合的重组为k项目集合
def creat_connect(list_c,n): ##实现集合内的重组，例如2-项集合重组为3-项集
    new_list=[]
    for i in range(0,len(list_c)):
        list_a = []
        for j in range(i+1,len(list_c)):
            list_b = list_c[i]
            list_d = []
            for k in range(0,n):
                list_d.append(list_c[j][k])
            list_a = list_b+list_d
            list_a=list(set(list_a))
            list_a.sort()
            new_list.append(str(list_a))
        new_list=list(set(new_list))
    New_list=[]
    for i in range(0,len(new_list)):
        new_list[i]=eval(new_list[i])
        new_list[i].sort()
        if len(new_list[i])==n+1:
            New_list.append(new_list[i])
    return New_list
#输出每个k-项频繁集的候选集的比率
def sup_rate(df,data):
    m = len(data)  # 事务总数
    item_set_list = []
    for i in range(0,len(df)):
        n=0
        list_n=[]
        for j in range(0,len(data)):
            if (set(df[i]) <= set(data[j]))==True:
                n+=1
        list_n.append(df[i])
        list_n.append(round(n/m,2))
        item_set_list.append(list_n)
    return  item_set_list
#输出每个k-项频繁集的候选集的个数，上有比率写法，两者无本质区别，都可以使用
def sup_counts(df,data): #输出每个1-项频繁集的候选集的次数
    item_set_list = []
    for i in range(0,len(df)):
        n=0
        list_n=[]
        for j in range(0,len(data)):
            if (set(df[i]) <= set(data[j]))==True:
                n+=1
        list_n.append(df[i])
        list_n.append(n)
        item_set_list.append(list_n)
    return  item_set_list
#得到满足最小支持度阈值的关联规则（find——rule of min-sup-rate item）
def sup_satisfy_item(data,min_suprate):
    n = len(data)  # 事务总数
    Good_list1=Good_list(data)
    m = len(Good_list1)  # 商品总数
    dt = sup_counts(Good_list1, data)
    All_freitem_list=[]
    for k in range(1,m):
        dt.sort()
        k_apriori=[]
        for j in range(0,len(dt)):
            if dt[j][-1] >= min_suprate*n: ##减枝过程
                k_apriori.append(dt[j][0])
                k_apriori.sort()
        dt=sup_counts(creat_connect(k_apriori,k),data)
        if len(k_apriori)!=0:
            All_freitem_list.append(k_apriori)
        else:
            break
    return All_freitem_list
def Ksubset_get(df): #获得非空子集（前提条件是频繁项集，否则数量太多，很难挖掘）
    n =len(df)
    k =len(df[0])
    All_nzsubset=[]
    for num in range(n):
        for i in it.combinations(df,num+1):  #调用it.combination 函数
            All_nzsubset.append(list(i))
    return All_nzsubset
def Find_rule_apriori(data,min_suprate,min_confi):
    a=len(data) #事务总数
    Sup_satisfy_item=sup_satisfy_item(data,min_suprate) #获得满足支持度的频繁项集，第一项为频繁1项集合的集合，以此类推。
    l=len(Sup_satisfy_item) #获得频繁项集集合的集合长度
    for i in range(1,l): #无需对频繁1项集合找寻关联规则，直接从频繁二项集的集合进行扫寻循环
        Sup_satisfy_itemi=Sup_satisfy_item[i]    #得到一个频繁i+1项集合的列表的列表
        m=len(Sup_satisfy_itemi)
        for j in range(0,m):  #为对每一个频繁项集进行扫寻，因此需要再做一次for循环
            Prule = Sup_satisfy_itemi[j]
            list1=[]
            list1.append(Prule)
            item_counts1 = sup_counts(list1,data)[0][-1]  #首先需要得到这一个频繁项集的支持度，或者计算频数也可以
            list1.clear()
            prerule_find = Ksubset_get(Prule)  #得到这一个频繁项集集合的所有非空集合，方便进行关联规则的重组
            prerule_find.remove(prerule_find[-1])  #删除全集
            q = len(prerule_find)   #得到排除全集后的关联重组列表的长度，以便进行for循环
            for z in range(0,q):
                list2=[]
                list2.append(prerule_find[z])
                item_counts2 = sup_counts(list2,data)[0][-1]  #得到每一个关联重组后项集的支持度（或频数）
                list2.clear()
                if item_counts2 > 0:
                    Confi_item = item_counts1/item_counts2 #得到置信度
                    if Confi_item >= min_confi: #置信度减除
                        n=len(prerule_find[z])
                        list3 = Prule[:]
                        for o in range(0, n):
                            list3.remove(str(prerule_find[z][o]))
                        print("{0} ==> {1},sup={2},confi={3}".format(prerule_find[z],list3,round(item_counts1/a,2),round(Confi_item,2)))

if __name__ == '__main__':
    # 数据导入
    data = pd.read_excel("D:\OneDrive\桌面\测试数据.xlsx", index_col=0, header=0)
    print(data)
    data = data.applymap(lambda x: str(x).strip())  # 删除导入时可能存在的空格值，比如：“面包”成了“ 面包”
    # 数据格式转换
    data = data.values  # 改为元组型数据，便于list输出
    data = data.tolist()  # 输出为客户*商品集合
    print(Non_deal(data))
    # 设定支持度和置信度
    minsup,minconfi=map(eval,input("请输入支持度和置信度：").split(" "))
    start = time.time()
    Find_rule_apriori(data,minsup,minconfi)
    end=time.time()
    print('Running time: {0} Seconds'.format(end - start))

五、总结

** ① 非常感谢我们老师的指导和激励呜呜呜，上课一直被点名。**

** ② Apriori算法真的很难写出来，写的很痛苦的家人们一定不要放弃！心态要好，希望这篇文章能够帮到你们一些，给到你们一些“我踩过的坑不要踩”的建议。**

** ③ 个人一直以来就喜欢分享，看以前的文章也可以发现，什么聚类分析、模糊聚类（传递闭包矩阵算法等等）都是个人编写的大白话函数，所以撰写本文的初衷就是个人的分享~**

** ④ K-means算法本人由于之前学习数学建模的时候太懒了，就没有撰写。**

** ⑤ 如果大家复制了我的函数，希望能够在代码段中标明了引用。**

** ⑥ 本文在细节的处理非常粗糙，希望大家在编写过程中能够予以改进，期待和各位交流（改进了一定要记得和我分享分享呜呜呜）**

** ⑦ 这是一个学习锻炼的过程，非计科、信管等专业，但也要强化这种语言能力~特别是商科！**