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