使用Apriori进行关联分析

大型超市有海量交易数据，我们可以通过聚类算法寻找购买相似物品的人群，从而为特定人群提供更具个性化的服务。但是对于超市来讲，更有价值的是如何找出商品的隐藏关联，从而打包促销，以增加营业收入。其中最经典的案例就是关于尿不湿和啤酒的故事。怎样在繁杂的数据中寻找到数据之间的隐藏关系？当然可以使用穷举法，但代价高昂，所以需要使用更加智能的方法在合理时间内找到答案。Apriori就是其中的一种关联分析算法。

基本概念

　　关联分析是一种在大规模数据集中寻找有趣关系的非监督学习算法。这些关系可以有两种形式：频繁项集或者关联规则。频繁项集（frequent item sets)是经常出现在一块的物品的集合，关联规则(association rules)暗示两种物品之间可能存在很强的关系。

　　下图是一个乒乓球店的交易记录，〇表示顾客购买了商品。其中{底板,胶皮,浇水}就是一个频繁项集；从中可以找到底板->胶皮这样的关联规则：

支持度

　　怎样有效定义频繁和关联？其中最重要的两个概念是支持度和置信度。

　　支持度(support)从字面上理解就是支持的程度，一个项集的支持度(support)被定义为数据集中包含该项集的记录所占的比例。上图中{底板}的支持度=(5/6) * 100%。

　　这个概念其实经常在现实生活中出现，翻译成支持率似乎更好理解，典型的例子就是投票，比如英国脱欧的支持率为51.89%。

　　用数学去解释就是，设W 中有s％的事务同时支持物品集A和B，s％称为{A，B}的支持度，即:

　　support({A,B}) = num(A∪B) / W = P(A∩B)

　　num(A∪B)表示含有物品集{A,B}的事务集的个数，不是数学中的并集。

置信度

　　置信度(confidence)揭示了A出现时B是否一定出现，如果出现，则出现的概率是多大。如果A->B的置信度是100%，则说明A出现时B一定会出现（返回来不一定）。上图中底板共出现5次，其中4次同时购买了胶皮，底板->胶皮的置信度是80%。

　　用公式表示是，物品A->B的置信度=物品{A,B}的支持度 / 物品{A}的支持度：

　　Confidence(A->B) = support({A,B}) / support({A}) = P(B|A)

Apriori原理

　　本节摘自《机器学习实战》

　　假设我们在经营一家商品种类并不多的杂货店，我们对那些经常在一起被购买的商品非常感兴趣。我们只有4种商品：商品0，商品1，商品2和商品3。那么所有可能被一起购买的商品组合都有哪些？这些商品组合可能只有一种商品，比如商品0，也可能包括两种、三种或者所有四种商品。我们并不关心某人买了两件商品0以及四件商品2的情况，我们只关心他购买了一种或多种商品。

　　下图显示了物品之间所有可能的组合。为了让该图更容易懂，图中使用物品的编号0来取代物品0本身。另外，图中从上往下的第一个集合是Ф，表示空集或不包含任何物品的集合。物品集合之间的连线表明两个或者更多集合可以组合形成一个更大的集合。

　　前面说过，我们的目标是找到经常在一起购买的物品集合。我们使用集合的支持度来度量其出现的频率。一个集合的支持度是指有多少比例的交易记录包含该集合。如何对一个给定的集合，比如{0，3}，来计算其支持度？我们遍历毎条记录并检查该记录包含0和3，如果记录确实同时包含这两项，那么就增加总计数值。在扫描完所有数据之后，使用统计得到的总数除以总的交易记录数，就可以得到支持度。上述过程和结果只是针对单个集合{0,3}。要获得每种可能集合的支持度就需要多次重复上述过程。我们可以数一下上图中的集合数目，会发现即使对于仅有4种物品的集合，也需要遍历数据15次。而随着物品数目的增加遍历次数会急剧增长。对于包含— 物品的数据集共有2^N-1种项集组合。事实上，出售10000或更多种物品的商店并不少见。即使只出售100种商品的商店也会有1.26×10³⁰种可能的项集组合。对于现代的计算机而言，需要很长的时间才能完成运算。

　　为了降低所需的计算时间，研究人员发现一种所谓的Apriori原理。Apriori原理可以帮我们减少可能感兴趣的项集。Apriori原理是说如果某个项集是频繁的，那么它的所有子集也是频繁的。上图给出的例子，这意味着如果{0,1}是频繁的，那么{0}、{1}也一定是频繁的。这个原理直观上并没有什么帮助，但是如果反过来看就有用了，也就是说如果一个项集是非频繁集，那么它的所有超集也是非频繁的，如下所示：

　　上图中，已知阴影项集{2，3}是非频繁的。利用这个知识，我们就知道项集{0,2,3} ，{1,2,3}以及{0,1,2,3}也是非频繁的。这也就是说，一旦计算出了{2,3}的支持度，知道它是非频繁的之后，就不需要再计算{0,2,3}、{1,2,3}和{0,1,2,3}的支持度，因为我们知道这些集合不会满足我们的要求。使用该原理就可以避免项集数目的指数增长，从而在合理时间内计算出频繁项集。

Apriori算法过程

　　关联分析的目标包括两项：发现频繁项集和发现关联规则。首先需要找到频繁项集，然后才能获得关联规则。

Apriori算法过程

　　发现频繁项集的过程如上图所示：

1. 由数据集生成候选项集C1（1表示每个候选项仅有一个数据项）；再由C1通过支持度过滤，生成频繁项集L1（1表示每个频繁项仅有一个数据项）。
2. 将L1的数据项两两拼接成C2。
3. 从候选项集C2开始，通过支持度过滤生成L2。L2根据Apriori原理拼接成候选项集C3；C3通过支持度过滤生成L3……直到Lk中仅有一个或没有数据项为止。

　　下面是一个超市的交易记录：

　　Apriori算法发现频繁项集的过程如下：

　　具体代码：

def loadDataSet():
    return [[1,2,5],[2,4],[2,3],[1,2,4],[1,3],[2,3],[1,3],[1,2,3,5],[1,2,3]]
#1.构建候选1项集C1
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))

#将候选集Ck转换为频繁项集Lk
#D：原始数据集
#Cn: 候选集项Ck
#minSupport:支持度的最小值
def scanD(D, Ck, minSupport):
    #候选集计数
    ssCnt = {}
    for tid in D:
        for can in Ck:
            if can.issubset(tid):
                if can not in ssCnt.keys(): ssCnt[can] = 1
                else: ssCnt[can] += 1

    numItems = float(len(D))
    Lk= []     # 候选集项Cn生成的频繁项集Lk
    supportData = {}    #候选集项Cn的支持度字典
    #计算候选项集的支持度, supportData key:候选项， value:支持度
    for key in ssCnt:
        support = ssCnt[key] / numItems
        if support >= minSupport:
            Lk.append(key)
        supportData[key] = support
    return Lk, supportData

#连接操作，将频繁Lk-1项集通过拼接转换为候选k项集
def aprioriGen(Lk_1, k):
    Ck = []
    lenLk = len(Lk_1)
    for i in range(lenLk):
        L1 = list(Lk_1[i])[:k - 2]
        L1.sort()
        for j in range(i + 1, lenLk):
            #前k-2个项相同时，将两个集合合并
            L2 = list(Lk_1[j])[:k - 2]
            L2.sort()
            if L1 == L2:
                Ck.append(Lk_1[i] | Lk_1[j])

    return Ck

def apriori(dataSet, minSupport = 0.5):
    C1 = createC1(dataSet)
    L1, supportData = scanD(dataSet, C1, minSupport)
    L = [L1]
    k = 2
    while (len(L[k-2]) > 0):
        Lk_1 = L[k-2]
        Ck = aprioriGen(Lk_1, k)
        print("ck:",Ck)
        Lk, supK = scanD(dataSet, Ck, minSupport)
        supportData.update(supK)
        print("lk:", Lk)
        L.append(Lk)
        k += 1

    return L, supportData

dataset = loadDataSet()
L, supportData = apriori(dataset, minSupport=0.2)

控制台信息：

　　代码中的scanD方法可作一下修改：

def scanD(D, Ck, minSupport):
    #候选集计数
    ssCnt = {}
    #数据集过滤
    D2 = [item for item in D if len(item) >= len(Ck[0])]
    for tid in D2:
        for can in Ck:
            if can.issubset(tid):
                if can not in ssCnt.keys(): ssCnt[can] = 1
                else: ssCnt[can] += 1
    ……

    return Lk, supportData

需要注意的是，在上述代码的aprioriGen方法中，假定购买商品是有顺序的，可以通过频繁2项集{P1,P2},{P1,P3}推导出频繁项{P1,P2,P3}，但是不能通过频繁2项集{P3,P4},{P1,P3}推导出频繁项{P1,P3,P4}。如果去掉假设，则需要修改aprioriGen的代码：

#将频繁Lk-1项集转换为候选k项集
def aprioriGen(Lk_1, k):
    Ck = []
    lenLk = len(Lk_1)
    for i in range(lenLk):
        L1 = Lk_1[i]
        for j in range(i + 1, lenLk):
            L2 = Lk_1[j]
            if len(L1 & L2) == k - 2:
                L1_2 = L1 | L2
                if L1_2 not in Ck:
                    Ck.append(L1 | L2)
    return Ck

发现关联规则

　　我们的目标是通过频繁项集挖掘到隐藏的关联规则。

　　所谓关联规则，指通过某个元素集推导出另一个元素集。比如有一个频繁项集{底板,胶皮,胶水}，那么一个可能的关联规则是{底板,胶皮}→{胶水}，即如果客户购买了底板和胶皮，则该客户有较大概率购买胶水。这个频繁项集可以推导出6个关联规则：

　　{底板,胶水}→{胶皮},

　　{底板,胶皮}→{胶水},

　　{胶皮,胶水}→{底板},

　　{底板}→{胶水, 胶皮},

　　{胶水}→{底板, 胶皮},

　　{胶皮}→{底板, 胶水}

　　箭头左边的集合称为“前件”，右边集合称为“后件”，根据前件会有较大概率推导出后件，这个概率就是之前提到的置信度。需要注意的是，如果A→B成立，B→A不一定成立。

　　一个具有N个元素的频繁项集，共有M个可能的关联规则：

　　下图是一个频繁4项集的所有关联规则网格示意图， 

　　上图中深色区域表示低可信度规则，如果012→3是一条低可信度规则，则所有其它3为后件的规则都是低可信度。这需要从可信度的概念去理解，Confidence(012→3) = P(3|0,1,2)，Confidence(01→23)=P(2,3|0,1)，P(3|0,1,2) >= P(2,3|0,1)。由此可以对关联规则做剪枝处理。

　　还是以上篇的超市交易数据为例，我们发现了如下的频繁项集：

　　对于寻找关联规则来说，频繁1项集L1没有用处，因为L1中的每个集合仅有一个数据项，至少有两个数据项才能生成A→B这样的关联规则。

　　当最小置信度取0.5时，L2最终能够挖掘出9条关联规则：

　　从频繁3项集开始，挖掘的过程就较为复杂。

　　假设有一个频繁4项集（这是杜撰的，文中的数据不能生成L4），其挖掘过程如下：

　　因为书中的代码假设购买商品是有顺序的，所以在生成3后件时，{P2,P4}和{P3,P4}并不能生成{P2,P23,P4}，如果想去掉假设，需要使用上篇中改进后的代码。

　　发掘关联规则的代码如下：

#生成关联规则
#L: 频繁项集列表
#supportData: 包含频繁项集支持数据的字典
#minConf 最小置信度
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


# 计算是否满足最小可信度
def calcConf(freqSet, H, supportData, brl, minConf=0.7):
    prunedH = []
    #用每个conseq作为后件
    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


# 对规则进行评估
def rulesFromConseq(freqSet, H, supportData, brl, minConf=0.7):
    m = len(H[0])
    if (len(freqSet) > (m + 1)):
        Hmp1 = aprioriGen(H, m + 1)
       # print(1,H, Hmp1)
        Hmp1 = calcConf(freqSet, Hmp1, supportData, brl, minConf)
        if (len(Hmp1) > 0):
            rulesFromConseq(freqSet, Hmp1, supportData, brl, minConf)

由此可以看到，apriori算法需要经常扫描全表，效率并不算高。

作者：我是8位的

出处：http://www.cnblogs.com/bigmonkey