演算法中核心性質：頻繁項集的所有非空子集也必須是頻繁的。逆反命題 也成立：如果一個項集是非頻繁的，那麼所有它的超集也是非頻繁。

一、Apriori演算法簡介：  Apriori演算法是一種挖掘關聯規則的頻繁項集演算法，其核心思想是通過候選集生成和情節的向下封閉檢測兩個階段來挖掘頻繁項集。 Apriori（先驗的，推測的）演算法應用廣泛，可用於消費市場價格分析，猜測顧客的消費習慣；網路安全領域中的入侵檢測技術；可用在用於高校管理中，根據挖掘規則可以有效地輔助學校管理部門有針對性的開展貧困助學工作；也可用在行動通訊領域中，指導運營商的業務運營和輔助業務提供商的決策制定。

二、挖掘步驟：

1.依據支援度找出所有頻繁項集（頻度）

2.依據置信度產生關聯規則（強度）

三、基本概念

對於A->B

①支援度：P(A ∩ B)，既有A又有B的概率

②置信度：

P(B|A)，在A發生的事件中同時發生B的概率 p(AB)/P(A)     例如購物籃分析：牛奶 ⇒麵包

例子：[支援度：3%，置信度：40%]

支援度3%：意味著3%顧客同時購買牛奶和麵包

置信度40%：意味著購買牛奶的顧客40%也購買麵包

③如果事件A中包含k個元素，那麼稱這個事件A為k項集事件A滿足最小支援度閾值的事件稱為頻繁k項集。

④同時滿足最小支援度閾值和最小置信度閾值的規則稱為強規則

四、實現步驟

    Apriori演算法是一種最有影響的挖掘布林關聯規則頻繁項集的演算法

Apriori使用一種稱作逐層搜尋的迭代方法，“K-1項集”用於搜尋“K項集”。

首先，找出頻繁“1項集”的集合，該集合記作L1。L1用於找頻繁“2項集”的集合L2，而L2用於找L3。如此下去，直到不能找到“K項集”。找每個Lk都需要一次資料庫掃描。

核心思想是：連線步和剪枝步。連線步是自連線，原則是保證前k-2項相同，並按照字典順序連線。剪枝步，是使任一頻繁項集的所有非空子集也必須是頻繁的。反之，如果某

個候選的非空子集不是頻繁的，那麼該候選肯定不是頻繁的，從而可以將其從CK中刪除。

簡單的講，1、發現頻繁項集，過程為（1）掃描（2）計數（3）比較（4）產生頻繁項集（5）連線、剪枝，產生候選項集

   重複步驟（1）~（5）直到不能發現更大的頻集

2、產生關聯規則，過程為:根據前面提到的置信度的定義，關聯規則的產生如下：

（1）對於每個頻繁項集L，產生L的所有非空子集；

（2）對於L的每個非空子集S，如果

                P（L）/P（S）≧min_conf

注：L-S表示在項集L中除去S子集的項集

下面程式碼實現了一個簡單資料集下的Apriori 演算法實現：

def loadDataSet():
    return [[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]]
 
def createC1(dataSet):# return C1 frequent item set
    C1 = []
    for transaction in dataSet:
        for item in transaction:
            if not [item] in C1:
                C1.append([item])
    C1.sort()
    return map(frozenset,C1) # frozenset can't changed !

def scanD(D,CK,minSupport):
    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 = []
    supportData = {}
    for key in ssCnt:
        support = ssCnt[key]/numItems
        if support >= minSupport:
            retList.insert(0, key)
        supportData[key]= support
        
    return retList,supportData # return result list and support data is a map

def aprioriGen(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

def apriori(dataSet,minSupport = 0.5):
    C1 = createC1(dataSet)
    D = map(set, dataSet)
    L1,supportData = scanD(D, C1, minSupport)
    L = [L1]
    k = 2
    while(len(L[k-2])>0):
        Ck = aprioriGen(L[k-2], k)
        Lk,supK = scanD(D, Ck, minSupport)
        supportData.update(supK)
        L.append(Lk)
        k+=1
    return L,supportData
    
if __name__ == "__main__":
    '''
    dataSet = loadDataSet()
    print(dataSet)
    C1 = createC1(dataSet)
    print(C1)
    D = map(set, dataSet)
    print(D)
    L1,supportData = scanD(D, C1, 0.5)
    print(L1)
    print(supportData)
    '''
    dataSet = loadDataSet()
    L,supportData = apriori(dataSet)
    print(L[1])

結果輸出：[[frozenset([1]), frozenset([3]), frozenset([2]), frozenset([5])], [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])], [frozenset([2, 3, 5])], []] 

從頻繁項集中發現關聯規則生成：

這裡用到很重要的一個剪枝條件： 如 0,1,2 --> 3 是一條低可信度的規則，那麼所有其他以3做為後件的規則可信度也會較低，這就是簡單快速的剪枝規則。

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,br1,minConf = 0.7):
    prunedH = []
    for conseq in H:
        conf = supportData[freqSet]/supportData[freqSet-conseq]
        if conf>= minConf:
            print freqSet-conseq,' --> ',conseq, 'confidence:',conf
            br1.append((freqSet-conseq,conseq,conf))
            prunedH.append(conseq)
    return prunedH

def rulesFromConseq(freqSet,H,supportData,br1,minConf = 0.7):
    m = len(H[0])
    if (len(freqSet)>(m+1)):
        Hmp1 = aprioriGen(H, m+1)
        Hmp1 = calcConf(freqSet, Hmp1, supportData, br1, minConf)
        if (len(Hmp1)>1):
            rulesFromConseq(freqSet, Hmp1, supportData, br1, minConf)

輸出support 0.5 confidence 0.5 的關聯規則：

frozenset([3])  -->  frozenset([1]) confidence: 0.666666666667
frozenset([1])  -->  frozenset([3]) confidence: 1.0
frozenset([5])  -->  frozenset([2]) confidence: 1.0
frozenset([2])  -->  frozenset([5]) confidence: 1.0
frozenset([3])  -->  frozenset([2]) confidence: 0.666666666667
frozenset([2])  -->  frozenset([3]) confidence: 0.666666666667
frozenset([5])  -->  frozenset([3]) confidence: 0.666666666667
frozenset([3])  -->  frozenset([5]) confidence: 0.666666666667
frozenset([5])  -->  frozenset([2, 3]) confidence: 0.666666666667
frozenset([3])  -->  frozenset([2, 5]) confidence: 0.666666666667
frozenset([2])  -->  frozenset([3, 5]) confidence: 0.666666666667