Apriori算法基本概念以及原理解析

Apriori算法中几个重要的概念

A—>B:
支持度： P(A^B) 表示A和B同时发生时的概率，没有先后顺序。
可信度或置信度： P(B|A) 表示A发生时，B发生的概率，有先后顺序。
P(B|A) = P(A^B)/P(A)
频繁项集：满足最小支持度阀值的事件集，如果事件里面有k个元素，就是频繁k项集。频繁项集通俗点来说，就是经常同时出现的一些元素的集合。

Apriori算法原理

AprioriApriori 的原理：如果某个项集是频繁项集，那么它所有的子集也是频繁的。
即如果 {0,1} 是频繁的，那么 {0}, {1} 也一定是频繁的。

Apriori算法步骤

1. 发现频繁项集(循环，从a到g产生候选集后，会回到扫描元素，由产生频繁k项集到循环后产生频繁k+1项集)
   a.扫描元素
   b.计算支持度
   c.统计筛选
   d.产生频繁项集
   e.自链接
   f.减枝
   g.产生候选集
2. 产生关联规则

Apriori算法原理(python版)

class Apriori:

    @classmethod
    def caculate(cls, dataSet, minSupport=0.5):
        C1 = cls.createC1(dataSet)
        # 将dataSet集合化，以满足scanD的格式要求
        # D = map(set, dataSet)
        L1, supportData = cls.scanD(dataSet, C1, minSupport)
        L = [L1]
         # 最初的L1中的每个项集含有一个元素，新生成的
         # 项集应该含有2个元素，所以 k=2
        k = 2
        while (len(L[k - 2]) > 0):
            Ck = cls.aprioriGen(L[k - 2], k)
            Lk, supK = cls.scanD(dataSet, Ck, minSupport)
            # 将新的项集的支持度数据加入原来的总支持度字典中
            supportData.update(supK)
            # 将符合最小支持度要求的项集加入L
            L.append(Lk)
            # 新生成的项集中的元素个数应不断增加
            k += 1
        # 返回所有满足条件的频繁项集的列表，和所有候选项集的支持度信息
        return L, supportData

    @classmethod
    def createC1(self, 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)

    @classmethod
    def aprioriGen(cls, Lk, k):
     '''
    由初始候选项集的集合Lk生成新的生成候选项集，
    k表示生成的新项集中所含有的元素个数
    '''
        retList = []
        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])
        return retList

    @classmethod
    def scanD(self, D, Ck, minSupport):
     '''
    计算Ck中的项集在数据集合D(记录或者transactions)中的支持度,
    返回满足最小支持度的项集的集合，和所有项集支持度信息的字典。
    '''
        ssCnt = {}
        l_Ck = list(Ck)
        for tid in D:
        # 对于每一条transaction
            for can in l_Ck:
            # 对于每一个候选项集can，检查是否是transaction的一部分
            # 即该候选can是否得到transaction的支持
                if can.issubset(tid):
                    if ssCnt.get(can) == None: ssCnt[can] = 1
                    else: ssCnt[can] += 1
        numItems = float(len(D))
        retList = []
        supportData = {}
        for key in ssCnt:
        # 每个项集的支持度
            support = ssCnt[key]/numItems
            # 将满足最小支持度的项集，加入retList
            if support >= minSupport:
                retList.insert(0, key)
            else:
                #print(str(key) + "支持度：" + str(support)+ "，小于最小支持度：" + str(minSupport))
                pass
            # 汇总支持度数据
            supportData[key] = support
        return retList, supportData