利用Apriori算法进行关联分析

1. Apriori算法

Apriori算法是一种挖掘关联规则的频繁项集算法，这些关系有两种形式 : 频繁项集和关联规则。
举个例子就知道了：著名的”尿布与啤酒”。
这就是通过关联分析来获取到的结果。

2. 名词解释

前后文中存在的名词都放在这里了
1. 频繁项集 ： 在事件集合中出现频繁的项目
2. 关联规则 ： 尿布-啤酒 关联等等 说明有很大的几率同时出现
3. 支持度：该项出现的次数/数据集的大小
4. 置信度：对于尿布-啤酒这一关联 置信度的定义 支持度(尿布与啤酒)/支持度(尿布)
一般的,A-B置信度 : conf(A-B) = support(AB)/support(A)，这也是关联规则中很重要的依靠的一个数据

3. 主要算法伪代码以及思想

主要思想

• 先计算各项的支持度，然后计算其置信度，如果直接运算如此多的数据，会有很大的计算开销，那么这时候你就要给算法一个阈值或者说是支持度置信度最小值，如果比这个值小就在后续中“剪”掉，这样一来就会节省很多时间………
• 所谓的Apriori原理，是说如果一个项是频繁的，那么他的子集也是频繁的，看他的逆否命题：一个项非频繁，那么他的超集也是非频繁的……是不是很有道理……例如：{{0},{1}}频繁 , 那么{0},{1}也频繁；如果{0}非频繁，那么{{0},{1}}就是非频繁……..或者把01换成实际生活中盒装奶与吸管…..理解一下…..

优缺点

优点 : 算法简单
缺点：数据过大运算量大

伪代码

# 1. scanData 生成频繁项集
for 数据集中的每条交易记录item：
    for 每个候选项集elem：
        检查elem是否是item的子集
        如果是，则增加elem的计数
for 每个候选项集：
    如果其支持度不低于最小值,则保留该项集以及支持度
返回所有频繁项集列表以及对应支持度列表

# 2. AprioriGen 生成候选项集
for i-len(频繁项集)
    for i+1-len(频繁项集)
        合并操作
返回候选集

# 3. Apriori 算法
当频繁项集中的项的个数大于0时：
    生成候选集(AprioriGen 函数)
    计算候选项集的支持度,删除非频繁项集
    生成频繁项集(scanData 函数)
返回频繁项集以及对应支持度

# 4. 关联规则挖掘见代码注释...

4. 代码

# coding:utf-8

from numpy import *


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


def creatC1(data):  # 创建一个候选集合 其中包含几个size为1的小集合
    c1 = []  # python不允许一个集合只包含一个数字 所以用list代替 [[],[],[],[]]
    for item in data:  # for "账单"条目
        for elem in item:  # for 条目的每个元素
            if [elem] not in c1:
                c1.append([elem])
    c1.sort()  # sort to 123...
    return map(frozenset, c1)  # frozen意为冻住的,返回一个不可更改的list


def scanData(data, Ck, minSupport):  # creat Lk from Ck (L代表频繁集 C代表候选集)
    appearNum = {}  # 记录候选集在数据中出现的次数
    for item in data:  # for 数据条目
        for elem in Ck:  # for 候选集元素
            if elem.issubset(item):  # 如果候选集出现在条目中
                if not appearNum.has_key(elem):  # 计数操作
                    appearNum[elem] = 1
                else:
                    appearNum[elem] += 1
    sum = float(len(data))  # 数据总条目数 float
    Lk = []  # LK记录
    supportData = {}  # 支持度的list
    for elem in appearNum:
        support = appearNum[elem] / sum  # 计算支持度
        if support >= minSupport:  # 是否大于最小支持度
            Lk.append(elem)
            supportData[elem] = support
    return Lk, supportData  # 返回频繁项集 以及 支持度


def AprioriGen(Lk, k):  # creat Ck+1 form Lk
    Ck = []
    lenLk = len(Lk)
    for i in range(lenLk):
        for j in range(i + 1, lenLk):  # 合并的过程很巧妙
            l1 = list(Lk[i])[:k - 2]  # 例如过程 [0] [1] [2] -> [01] [02] [12] -> [012]
            l2 = list(Lk[j])[:k - 2]  # [01][02][12]直接合并会出现3组[012]需要去重
            l1.sort()  # 而利用k-2这个筛选条件就只会出现 01|02 -> 012 这一种情况,以此类推
            l2.sort()
            if l1 == l2:
                Ck.append(Lk[i] | Lk[j])  # 集合并集
    return Ck  # 返回候选集


def Apriori(data, minSupport=0.5):  # minSupport is default 0.5
    c1 = creatC1(data)
    D = map(set, data)  # 内部去重 例如[1,1,2]->[1,2] ?
    L1, supportData = scanData(data, c1, minSupport)
    L = [L1]  # L集合存放了长度为i的频繁项集
    k = 2  # k=2 设计很巧妙
    while len(L[k - 2]) > 0:
        Ck = AprioriGen(L[k - 2], k)  # 从LK 生成 CK
        Lk, supportLK = scanData(D, Ck, minSupport)
        supportData.update(supportLK)
        L.append(Lk)  # 频繁项添加
        k += 1
    return L, supportData


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]  # 拆分每个频繁项
            ''' 理解注释 '''
            # print "index is :", i
            # print "freqSet :", freqSet
            # print "H1 :", H1
            ''' 理解注释 '''
            if i > 1:  # 如果大于两个元素 需要进一步关联规则生成以及判断置信度
                rulesFromConseq(freqSet, H1, supportData, bigRuleList, minConf)
            else:  # 如果只是两个元素 直接判断其置信度
                # print "+ + + + + generateRules else begin + + + + +"
                calcConf(freqSet, H1, supportData, bigRuleList, minConf)
                # print "+ + + + + generateRules else end + + + + +"
                # print 'bigRuleList is :', bigRuleList, '\n-------------------------- generateRules for end ---------------------------------------------------'
    return bigRuleList


def calcConf(freqSet, H, supportData, bigRuleList, minConf=0.7):  # 计算其 freq->H的置信度
    Hmp1 = []  # 返回置信度符合条件的H
    for elem in H:
        conf = supportData[freqSet] / supportData[freqSet - elem]  # 计算置信度 利用了集合减法
        if conf >= minConf:
            # print freqSet - elem, '-->', elem, 'conf:', conf
            bigRuleList.append((freqSet - elem, elem, conf))
            Hmp1.append(elem)  # 此时不满足条件不会加入list 因为其超集也不会频繁
    return Hmp1


def rulesFromConseq(freqSet, H, supportData, bigRuleList, minConf=0.7):  # 生成关联规则
    m = len(H[0])
    ''' 理解注释 '''
    # print "---------  +  + +  rulesFromConseq  + +   +  -----------"
    # print "H0 is :", H[0]
    # print "m is :", m
    # print "freqSet is :", len(freqSet)

    # 为什么len > m+1呢 简单来说 既要生成CK+1 又不能和freqSet长度相等(以防无法进行关联计算freqSet->H)
    # 4个元素的关联规则 len:2->2,1->3 (本文 递归执行)
    # 消除注释可见过程
    ''' 理解注释 '''
    if len(freqSet) > (m + 1):
        Hmp1 = AprioriGen(H, m + 1)  # 生成C(Hmp1 : Hm plus 1) 来进行关联分析
        Hmp1 = calcConf(freqSet, Hmp1, supportData, bigRuleList, minConf)
        if len(Hmp1) > 1:  # 满足条件 递归
            rulesFromConseq(freqSet, Hmp1, supportData, bigRuleList, minConf)


if __name__ == '__main__':
    data = loadSimpleData()
    c1 = creatC1(data)
    L, support = Apriori(data, 0.6)
    print L
    rules = generateRules(L, support, 0.6)
    print '----'*12
    for x in rules:
        print x

5. 结果分析

'''
[[frozenset([5]), frozenset([2]), frozenset([3]), frozenset([1])], [frozenset([3, 5]), frozenset([2, 3]), frozenset([2, 5]), frozenset([1, 3])], [frozenset([2, 3, 5])], []] 
------------------------------------------------
(frozenset([5]), frozenset([3]), 0.7999999999999999)
(frozenset([3]), frozenset([5]), 0.7999999999999999)
(frozenset([3]), frozenset([2]), 0.7999999999999999)
(frozenset([2]), frozenset([3]), 0.7999999999999999)
(frozenset([5]), frozenset([2]), 1.0)
(frozenset([2]), frozenset([5]), 1.0)
(frozenset([3]), frozenset([1]), 0.7999999999999999)
(frozenset([1]), frozenset([3]), 1.0)
(frozenset([5]), frozenset([2, 3]), 0.7999999999999999)
(frozenset([3]), frozenset([2, 5]), 0.7999999999999999)
(frozenset([2]), frozenset([3, 5]), 0.7999999999999999)
'''
# frozenset 是 '冻起来' 的意思，就是不可变的
# 结果是 a,b,置信度
# 即买a产品顺便买b产品的几率是多少...可以排序看...