机器学习（十）：Apriori算法

引言：
Apriori算法是第一个关联规则挖掘算法。它基于Apriori原理，用支持度做度量，迭代产生频繁项集；对频繁项集，使用置信度做度量，最后发现关联规则。
本文用到的部分术语已在简介中介绍（具体看‘基本概念-关联分析’），这里不再重述。

一、Apriori原理

如果一个项集是频繁的，则它的所有子集一定也是频繁的；相反，如果项集是非频繁的，则它的所有超集也一定是非频繁的。

二、发现频繁项集

假定事务总数为N，支持度阈值是minsup，发现频繁项集的过程如下（理论上，存在许多产生候选项集的方法，本例使用支持度阈值来产生）：
①初始时每个项都被看作候选1-项集。计数对它们的支持度之后，将支持度少于阈值的候选项集丢弃，生成频繁1-项集。
②在第二次迭代，依据Apriori原理（即所有非频繁的1-项集的超集都是非频繁的），仅使用频繁1-项集来产生候选2-项集。此时生成的候选2-项集有多个，将支持度少于阈值的候选项集丢弃，生成频繁2-项集。
③经过多次迭代，每次用上一次生成的频繁n-项集产生新的候选(n+1)-项集，直至没有发现频繁(n+1)-项集，则得到的频繁n-项集就是最终结果。
例1
下图是一个购物篮事务的例子。

TID	项集
1	{面包，牛奶}
2	{面包，尿布，啤酒，鸡蛋}
3	{牛奶，尿布，啤酒，可乐}
4	{面包，牛奶，尿布，啤酒}
5	{面包，牛奶，尿布，可乐}

假定支持度阈值是60%，相当于支持度计数为5*60%=3。
①初始时每个项都被看作候选1-项集，即候选1-项集={面包，牛奶，尿布，啤酒，鸡蛋，可乐}，其中{可乐}和{鸡蛋}出现的事务少于3，即支持度少于支持度阈值，丢弃得频繁1-项集={面包，牛奶，尿布，啤酒}。
②由于只有4个频繁1项集，因此算法产生的候选2-项集的数目为 $C_4^2=6$ 。计算它们的支持度后，发现这6个候选项集中的2个{啤酒，面包}和{啤酒，牛奶}是非频繁的，丢弃得频繁2-项集={面包，牛奶}，{面包，尿布}，{牛奶，尿布}，{啤酒，尿布}。
③用频繁2-项集生成候选3-项集（将含有1个相同项的集合合并），得到候选3-项集＝{面包，牛奶，尿布}，{面包，啤酒，尿布}，{牛奶，啤酒，尿布}；丢弃支持度少于支持度阈值的项，最后得频繁3-项集为空集，则可得频繁2-项集={面包，牛奶}，{面包，尿布}，{牛奶，尿布}，{啤酒，尿布}为最终结果。

三、发现关联规则

发现关联规则是指找出支持度大于等于minsup并且置信度大于等于minconf的所有规则，其中minsup和minconf是对应的支持度阈值和置信度阈值。
设Y是频繁项集，关联规则可以这样提取：将项集Y划分成两个非空的子集X和Y-X，使得X->Y-X满足置信度阈值（注意：这里的规则必然已经满足支持度阈值，因为它们是由频繁项集产生的）。
例2
设Y={1,2,3}是频繁项集，可以由Y产生6个候选关联规则：{1,2}->{3}，{1,3}->{2}，{2,3}->{1}，{1}->{1,2}，{2}->{1,3}，{3}->{1,2}。6个候选关联规则中满足置信度阈值的关联规则，就是我们最终需要的结果。

四、代码实现（python）

以下代码来自Peter Harrington《Machine Learing in Action》。
代码如下（保存为apriori.py）

# -- coding: utf-8 --
from numpy import *

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

def createC1(dataSet):
    # 该函数构建集合C1：候选1-项集
    C1 = []
    for transaction in dataSet:
        for item in transaction:
            if not [item] in C1:
                C1.append([item])

    C1.sort()
    return map(frozenset, C1)

def scanD(D, Ck, minSupport):
    # 该函数接收3个参数，分别是数据集、候选k-项集、支持度阈值；该函数用于生成频繁项集
    ssCnt = {}
    for tid in D:
        for can in Ck:
            if can.issubset(tid):
                if not ssCnt.has_key(can): ssCnt[can]=1
                else: ssCnt[can] += 1
    numItems = float(len(D))
    retList = []                                # retList存储大于支持度阈值的候选1-项集，即频繁1-项集
    supportData = {}                            # supportDatacunc存储各候选1－项集的支持度
    for key in ssCnt:
        support = ssCnt[key]/numItems
        if support >= minSupport:
            retList.insert(0,key)
        supportData[key] = support
    return retList, supportData

def aprioriGen(Lk, k):
    # 该函数接收2个参数，分别是频繁(k－1)-项集、k；该函数用于生成候选项集
    retList = []                                 # 存储候选k-项集
    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])    # 前k-2个项相同，合并Lk[i]与Lk[j]
    return retList

def apriori(dataSet, minSupport = 0.5):
    # 该函数接收2个参数，分别是数据集、支持度阈值（默认0.5）
    C1 = createC1(dataSet)                       # 创建候选1-项集
    D = map(set, dataSet)
    L1, supportData = scanD(D, C1, minSupport)   # L1为频繁1-项集，supportData存储各候选1－项集的支持度
    L = [L1]
    k = 2
    while (len(L[k-2]) > 0):
        # 循环各频繁(k-1)－项集，直至为空
        Ck = aprioriGen(L[k-2], k)               # Ck为候选k-项集
        Lk, supK = scanD(D, Ck, minSupport)      # Lk为频繁k-项集，supportData存储各候选k－项集的支持度
        supportData.update(supK)                 # 存储各候选项集的支持度
        L.append(Lk)                             # 将新生成的频繁k-项集添加进频繁项集数组
        k += 1
    return L, supportData

def generateRules(L, supportData, minConf=0.7):
    # 该函数接收3个参数，分别是频繁项集、包含项集的支持度字典、置信度阈值；
    bigRuleList = []
    for i in range(1, len(L)):
        for freqSet in L[i]:
            H1 = [frozenset([item]) for item in freqSet]
            if (i > 1):
                # 项集数目大于3执行次函数
                rulesFromConseq(freqSet, H1, supportData, bigRuleList, minConf)
            else:
                # 频繁2-项集执行此函数
                calcConf(freqSet, H1, supportData, bigRuleList, minConf)
    return bigRuleList

def calcConf(freqSet, H, supportData, brl, minConf=0.7):
    # 该函数接收5个参数，分别是用于计算的频繁项集、此项集各个元素、包含项集的支持度字典、关联规则数组、置信度阈值；
    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

def rulesFromConseq(freqSet, H, supportData, brl, minConf=0.7):
    # 该函数接收5个参数，分别是用于计算的频繁项集、此项集各个元素、包含项集的支持度字典、关联规则数组、置信度阈值；
    m = len(H[0])
    if (len(freqSet) > (m + 1)):
        Hmp1 = aprioriGen(H, m+1)                                  # 将H中的元素两两合并
        Hmp1 = calcConf(freqSet, Hmp1, supportData, brl, minConf)  # 计算置信度
        if (len(Hmp1) > 1):
            rulesFromConseq(freqSet, Hmp1, supportData, brl, minConf)

运行命令如下：
这里写图片描述

以上全部内容参考书籍如下：
《数据挖掘导论（完整版）》人民邮电出版社
Peter Harrington《Machine Learing in Action》