問題的背景：     超市的會員卡記錄了大量的使用者購買資料，通過分析這些資料可以幫助商店分析使用者的購買行為。從大規模資料集中尋找物品間的隱含關係被稱為關聯規則分析（association analysis）或關聯規則學習（association rule learning）。舉個例子說就是發現使用者購買了一件商品（如帽子）後，會購買另一件商品（如圍巾）的概率。關聯規則分析需要從大規模的商品資料中，發現和統計各種商品的組合（頻繁項集發現）是一個非常費時費力的事情，這個也是關聯規則分析的主要問題。為了解決這個問題提出了apriori演算法，也叫先驗演算法。
    1993年,R.Agrawal等人首次提出了挖掘顧客交易資料中專案集間的關聯規則問題，其核心是基於兩階段頻繁集思想的遞推演算法。該關聯規則在分類上屬於單維、單層及布林關聯規則，典型的演算法是Aprior演算法。
  Aprior演算法將發現關聯規則的過程分為兩個步驟：第一步通過迭代，檢索出事務資料庫中的所有頻繁項集，即支援度不低於使用者設定的閾值的項集；第二步利用頻繁項集構造出滿足使用者最小信任度的規則。其中，挖掘或識別出所有頻繁項集是該演算法的核心，佔整個計算量的大部分。
問題定義：     關聯規則分析是為了在大規模資料集中尋找有趣關係的任務。這些關係分為兩種，頻繁項集和關聯規則。     頻繁項集（frequent item sets）是經常出現在一塊的物品的集合，關聯規則（association rules）暗示兩種物品之間可能存在很強的關係。
    apriori演算法就是為了發現頻繁項集。頻繁項集發現後再進行關聯規則分析，需要用到條件概型。
    需要思考的問題：
        1、頻繁項集，頻繁如何定義，也就是說怎樣才算頻繁？
        2、應該如何去定義商品間的購買關係，也就是憑什麼說他們存在某個關係？
        3、如何去過濾掉一些不需要的商品關係，篩選出想要的商品關係？
        第一個問題會在講apriori演算法原理的時候解決。
        第二個問題需要用到條件概型

        ，其中P(AB)是A商品和B商品同時出現的概率，P(B)是B商品出現的概率，P(A|B)是在B商品出現的情況下出現A商品的概率。在關聯規則分析中，我們將P(AB)稱為A和B同時出現的的支援度，P(B)稱為B出現的支援度。P(A|B)指定是購買B再購買A的可信度。     apriori原理：
        如下圖對於{0,1,2,3}的組合如下共有15種，即2的N次方減1種，其中N為商品種數。因此計算所有組合的次數時間複雜度是很大的。
        如何降低複雜度呢？         研究人員發現了一種所謂的Apriori原理，如果某個項集是頻繁的，那麼它的所有子集也是頻繁的。逆否命題是，如果某個項集不是頻繁的，那麼包含這個項集的項集也不是頻繁的。這個原理可作為減枝的依據，例如{0}不是頻繁的，那麼包含0的所有項集都不是頻繁的，包含0的項集出現次數就不用統計了。         第一個問題的解決方法：
        頻繁項集的頻繁是自定義的，根據實驗場景定義一個次數，低於這個次數的項集就可以減枝減掉。

演算法圖例說明

     

          為了便於計算，下面的支援度用項集出現次數來代替。

假設有一個數據庫D，其中有4個事務記錄，分別表示為：

TID	Items
T1	I1,I3,I4
T2	I2,I3,I5
T3	I1,I2,I3,I5
T4	I2,I5

這裡預定最小支援度minSupport=2,下面用圖例說明演算法執行的過程：

TID	Items
T1	I1,I3,I4
T2	I2,I3,I5
T3	I1,I2,I3,I5
T4	I2,I5

掃描D，對每個候選項進行支援度計數得到表C1:

項集	支援度計數
{I1}	2
{I2}	3
{I3}	3
{I4}	1
{I5}	3

比較候選項支援度計數與最小支援度minSupport，產生1維最大專案集L1：

項集	支援度計數
{I1}	2
{I2}	3
{I3}	3
{I5}	3

由L1產生候選項集C2：

項集
{I1,I2}
{I1,I3}
{I1,I5}
{I2,I3}
{I2,I5}
{I3,I5}

掃描D，對每個候選項集進行支援度計數:

項集	支援度計數
{I1,I2}	1
{I1,I3}	2
{I1,I5}	1
{I2,I3}	2
{I2,I5}	3
{I3,I5}	2

比較候選項支援度計數與最小支援度minSupport，產生2維最大專案集L2：

項集	支援度計數
{I1,I3}	2
{I2,I3}	2
{I2,I5}	3
{I3,I5}	2

由L2產生候選項集C3：

項集
{I2,I3,I5}

掃描D，對每個候選項集進行支援度計數:

項集	支援度計數
{I2,I3,I5}	2

比較候選項支援度計數與最小支援度minSupport，產生3維最大專案集L3：

項集	支援度計數
{I2,I3,I5}	2

演算法終止。

從頻繁項中挖掘關聯規則：

關聯規則挖掘也可以進行減枝，例如012->3，可信度可用如下公式計算為，

對於以012->3為根節點的所有節點，例如03->12，可信度可用如下公式計算為

觀察發現分子是一樣的，分母由於子節點是父節點的子集，所以對應的概率更大，上面的例子P(12) >= P(012)。

所以可以得出如果某條規則不滿足最小可信度，那麼該規則的所有子集也不會滿足最小可信度要求。

在ipython和python3.4環境下進行的實驗，程式碼如下：

例子資料

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

"""
建立集合大小為1的項集
"""
def createC1(dataSet):
    C1 = []
    for transaction in dataSet:
        for item in transaction:
            if not [item] in C1:
                C1.append([item])
                
    C1.sort()
    return map(frozenset, C1)#use frozen set so we
                            #can use it as a key in a dict  
"""
計算指定項集的支援度
D是資料集合，Ck是要求支援度的項集，minSupport是最小支援度
"""
def scanD(D, Ck, minSupport):
    ssCnt = {}
    for tid in D:
        for can in Ck:
            if can.issubset(tid):
                if not ssCnt.get(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
"""
生成集合大小比原來的大一的項集
"""
def aprioriGen(Lk, k): #creates Ck
    retList = []
    lenLk = len(Lk)
    # 如果Lk只有一項，則retList為[]
    for i in range(lenLk):
        for j in range(i+1, lenLk):
            # 為了每次新增的都是單個項構成的集合，所以Lk中項的大小是k-1，那麼前k-2項相同，才能使合併後只比原來多一項。
            L1 = list(Lk[i])[:k-2]; L2 = list(Lk[j])[:k-2]
            L1.sort(); L2.sort()
            if L1==L2: #if first k-2 elements are equal
                retList.append(Lk[i] | Lk[j]) #set union
    return retList
"""
求出資料集合中，支援度大於最小支援度的所有項集
"""
def apriori(dataSet, minSupport = 0.5):
    C1 = createC1(dataSet)
    # 轉化為list型別重要
    C1 = list(C1)
    D = map(set, dataSet)
    # 轉化為list型別重要
    D = list(D)
#     print(D)
#     print(C1)
    L1, supportData = scanD(D, C1, minSupport)
#     print(L1)
    L = [L1]
    k = 2
    while (len(L[k-2]) > 0):
        Ck = aprioriGen(L[k-2], k)
        Lk, supK = scanD(D, Ck, minSupport)#scan DB to get Lk
        supportData.update(supK)
        L.append(Lk)
        k += 1
    return L, supportData
"""
計算 freqSet-conseq -> conseq 的可信度， conseq是H中的元素
"""
def calcConf(freqSet, H, supportData, brl, minConf=0.7):
    prunedH = [] #create new list to return
    for conseq in H:
        conf = supportData[freqSet]/supportData[freqSet-conseq] #calc confidence
        if conf >= minConf: 
            print(freqSet-conseq,'-->',conseq,'conf:',conf)
            brl.append((freqSet-conseq, conseq, conf))
            prunedH.append(conseq)
    return prunedH
"""
# 1個元素的集合 -> (len(freqSet) - 1) 元素的集合
# 2個元素的集合 -> (len(freqSet) - 2) 元素的集合
# ...
"""
def rulesFromConseq(freqSet, H, supportData, brl, minConf=0.7):
    print("H:", H)
    m = len(H[0])
    if (len(freqSet) > (m + 1)): #try further merging
        Hmp1 = aprioriGen(H, m+1)#create Hm+1 new candidates
#         print("Hmp1:",Hmp1)
        Hmp1 = calcConf(freqSet, Hmp1, supportData, brl, minConf)
#         print("Hmp1:",Hmp1)
        if (len(Hmp1) > 1):    #need at least two sets to merge
            rulesFromConseq(freqSet, Hmp1, supportData, brl, minConf)
"""
兩個元素的集合求關聯規則
三個元素的集合求關聯規則
...
"""
def generateRules(L, supportData, minConf=0.7):  #supportData is a dict coming from scanD
    bigRuleList = []
    for i in range(1, len(L)):#only get the sets with two or more items
        print(L[i])
        for freqSet in L[i]:
            H1 = [frozenset([item]) for item in freqSet]
            print(H1)
            if (i > 1):
                rulesFromConseq(freqSet, H1, supportData, bigRuleList, minConf)
            else:
                calcConf(freqSet, H1, supportData, bigRuleList, minConf)
    return bigRuleList  

進行apriori演算法項集為1的測試，如果可行再應用到遞推中

# 載入資料
dataSet=loadDataSet()
dataSet

# 獲取集合大小為1的所有項集
C1=createC1(dataSet)
# print(len(C1))
# TypeError: object of type 'map' has no len()
C1 = list(C1)
C1

# 將資料型別轉換為集合
D=map(set, dataSet)
# print(len(D))
D = list(D)
D

# 求集合大小為1的項集的支援度，返回留下支援度大於最小支援度的項集和它們的支援度
L1, suppData0 = scanD(D, C1, 0.5)
print(L1)
print(suppData0)

測試priori演算法

L1, suppData0 = apriori(dataSet)
print(L1)
print()
print(suppData0)

L1, suppData0 = apriori(dataSet, minSupport=0.7)
print(L1)
print()
print(suppData0)

測試關聯規則

L, suppData = apriori(dataSet, minSupport=0.5)
print(L)
print()
print(suppData)

rules = generateRules(L, suppData, minConf=0.7)

rules = generateRules(L, suppData, minConf=0.5)
rules

缺點： 每次增加頻繁項集的大小，Apriori演算法都會重新掃描整個資料集合。

當資料集很大時，這會顯著降低頻繁項集的發現速度。 參考自： 《機器學習實戰》