第十一章 使用Apriori演算法進行關聯分析

• Apriori演算法
• 頻繁項集生成
• 關聯規則生成

從大規模資料集中尋找物品間的隱含關係被稱作為關聯分析（association analysis）和關聯規則學習（association rule learning）。

11.1 關聯分析

關聯分析有兩種形式：頻繁項集、關聯規則。頻繁項集（frequent item sets）是經常出現在一塊的物品的集合，關聯規則（association rules）暗示兩種物品之間可能存在很強的關係。使用頻繁項集和關聯規則，商家可以更好地理解他們的顧客。

當尋找頻繁項集時，有兩個概念比較重要：支援度和可信度。

一個項集的支援度（support）被定義為資料集中包含該項集的記錄所佔的比例。由上圖可以看出項集{豆奶}的支援度為4/5,項集{豆奶，尿布}的支援度為3/5。支援度是針對項集來說，因此可以定義一個最小支援度過濾較小支援度的項集。

可信度或置信度（confidence）是針對關聯規則來定義的。可被定義為conf(B) = support({A,B})/support({A})。

支援度和置信度是用來量化關聯分析是否成功的方法。

11.2 Apriori原理

上圖顯示了4種商品所有可能的組合。對給定的集合項集{0,3}，需要遍歷每條記錄並檢查是否同時包含0和3,掃描完後除以記錄總數即可得支援度。對於包含N種物品的資料集共有2的N次方-1種項集組合，即使100種，也會有1.26×10的30次方種可能的項集組成。

為降低計算時間，可用Apriori原理：如果某個項集是頻繁的，那麼它的所有子集也是頻繁的。逆反：如果一個項集是非頻繁集，那麼它的所有超集也是非頻繁的。

11.3 使用Apriori演算法來發現頻繁集

Apriori演算法的兩個輸入引數分別是最小支援度和資料集。首先生成所有單個物品的項集列表，得到滿足最小支援度的項集，將其進行組合生成包含兩個元素的項集，繼續剔除不滿足最小支援度的項集，重複直到所有項集都被去掉。

資料集掃描的虛擬碼：

對資料集中的每條交易記錄tran

每個候選集can

檢查can是否是tran的子集

如果是，則增加can的計數值

對每個候選項集

如果其支援度不低於最小值，則保留該項集

返回所有頻繁項集列表

整個Apriori演算法的虛擬碼：

當集合中項集的個數大於0時

構建一個k個項集組成的候選項集列表

檢查資料以確認每個項集都是頻繁的

保留頻繁項集並構建k+1項組成的候選項集的列表

coding:

<span style="font-size:18px;">#!/usr/bin/env python
# coding=utf-8
def  loadDataSet():
    return [[1,3,4],[2,3,5],[1,2,3,5],[2,5]]

def createC1(dataSet):                  #構建所有候選項集的集合
    C1 = []
    for transaction in dataSet:
        for item in transaction:
            if not [item] in C1:
                C1.append([item])       #C1新增的是列表，對於每一項進行新增，{1},{3},{4},{2},{5}
    C1.sort()
    return map(frozenset, C1)           #使用frozenset，被“冰凍”的集合，為後續建立字典key-value使用。

def scanD(D,Ck,minSupport):             #由候選項集生成符合最小支援度的項集L。引數分別為資料集、候選項集列表，最小支援度
    ssCnt = {}
    for tid in D:                       #對於資料集裡的每一條記錄
        for can in Ck:                  #每個候選項集can
            if can.issubset(tid):       #若是候選集can是作為記錄的子集，那麼其值+1,對其計數
                if not ssCnt.has_key(can):#ssCnt[can] = ssCnt.get(can,0)+1一句可破，沒有的時候為0,加上1,有的時候用get取出，加1
                    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):                  #建立符合置信度的項集Ck,
    retList = []
    lenLk   = len(Lk)
    for i in range(lenLk):
        for j in range(i+1, lenLk):     #k=3時，[:k-2]即取[0],對{0,1},{0,2},{1,2}這三個項集來說，L1=0，L2=0，將其合併得{0,1,2}，當L1=0,L2=1不新增，
            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]                           #L將包含滿足最小支援度，即經過篩選的所有頻繁n項集，這裡新增頻繁1項集
    k  = 2
    while (len(L[k-2])>0):              #k=2開始，由頻繁1項集生成頻繁2項集，直到下一個打的項集為空
        Ck = aprioriGen(L[k-2], k)
        Lk, supK = scanD(D, Ck, minSupport)
        supportData.update(supK)        #supportData為字典，存放每個項集的支援度，並以更新的方式加入新的supK
        L.append(Lk)
        k +=1
    return L,supportData

dataSet = loadDataSet()
C1 = createC1(dataSet)
print "所有候選1項集C1:\n",C1

D = map(set, dataSet)
print "資料集D:\n",D

L1, supportData0 = scanD(D,C1, 0.5)
print "符合最小支援度的頻繁1項集L1:\n",L1

L, suppData = apriori(dataSet)
print "所有符合最小支援度的項集L：\n",L
print "頻繁2項集：\n",aprioriGen(L[0],2)
L, suppData = apriori(dataSet, minSupport=0.7)
print "所有符合最小支援度為0.7的項集L：\n",L
</span>

效果：

11.4 從頻繁項集中挖掘關聯規則

要找關聯規則，從頻繁項集開始，根據置信度算出頻繁項集中出現的哪些商品必然可以推到出當中的另外一些商品，即找出頻繁項集中各商品之間的關聯規則。

每個頻繁項集可以產生多個關聯規則。如果某條規則並不滿足最小可信度要求，那麼該規則的所有子集也不會滿足最小可信度要求。apriori演算法，可以首先從一個頻繁項集開始，接著建立一個規則列表，其中規則右部只包含一個元素，然後對這些規則進行測試，合併所有剩餘規則來建立一個新的規則列表。

coding:

<span style="font-size:18px;">#===============關聯規則生成函式==================
def generateRules(L, supportData, minConf = 0.7):
    bigRuleList = []                                                            #規則存放在bigRuleList列表中
    for i in range(1, len(L)):
        for freqSet in L[i]:                                                    #L0是頻繁1項集，沒關聯規則
            H1 = [frozenset([item]) for item in freqSet]                        #H1存放頻繁i項集的某個頻繁項集的單個元素集合，頻繁3項集的{0,1,2}的{{0},{1},{2}
            if i>1:
                rulesFromConseq(freqSet, H1, supportData, bigRuleList, minConf) #從頻繁3項集開始，從置信度算出關聯規則
            else:
                calcConf(freqSet, H1, supportData, bigRuleList, minConf)        #對頻繁2項集，計算置信度
    return bigRuleList

def calcConf(freqSet, H, supportData, br1, minConf = 0.7):                      #計算置信度函式，
    prunedH = []
    for conseq in H:
        conf = supportData[freqSet]/supportData[freqSet - conseq]               #conf({2}) = s({{0},{1},{2}})/s({{0},{1},{2}}-{2})
        if conf >= minConf:
            print freqSet-conseq,"——>",conseq, "conf:",conf                     #那麼有{{0},{1}}——>{{2}}
            br1.append((freqSet-conseq, conseq, conf))
            prunedH.append(conseq)
    return prunedH

def rulesFromConseq(freqSet, H, supportData, br1, minConf=0.7):
    m = len(H[0])                                                               #m,頻繁m項集
    if (len(freqSet)) > (m+1):
        Hmp1 = aprioriGen(H, m+1)                                               #由H，建立m+1項集 
        Hmp1 = calcConf(freqSet, Hmp1, supportData, br1, minConf)               #保留符合置信度的m+1項集，Hmp1 = prunedH
        if (len(Hmp1)>1):
            rulesFromConseq(freqSet, Hmp1, supportData, br1, minConf)

L,suppData = apriori(dataSet, minSupport=0.5)
rules      = generateRules(L,suppData, minConf=0.7)
print rules

rules      = generateRules(L,suppData, minConf=0.5)
print rules</span>

效果：

顯然的，降低可信度閾值，獲得更多的規則。

11.5 示例：發現毒蘑菇的相似特徵

資料：

第一個特徵表示有毒或者可食用，1為可食用，2為有毒。第二列為整數3-8的6種可能的蘑菇傘的形狀。對所有頻繁項集並不是那麼感興趣，而是對特定是否有毒這個元素項的項集感興趣。可通過apriori找出所有跟是否有毒這個特徵相關的項集。 coding:

mushDatSet  = [line.split() for line in open("mushroom.dat").readlines()]
L, suppData = apriori(mushDatSet, minSupport=0.3)
for item in L[1]:
    if item.intersection("2"):
        print item

for item in L[3]:
    if item.intersection("2"):
        print item

效果：

11.6 小結

關聯分析是用於發現大資料集中元素間有趣關係的agiel工具集，可用頻繁項集和關聯規則這兩種方式度量。發現元素間的不同組合比較耗時，apriori演算法顯得比較高效。如果一個元素項是不頻繁的，那麼包含該元素的超集也是不頻繁的。

每次增加頻繁項集的大小，apriori演算法都會重新掃描整個資料集，當資料集很大時，會降低頻繁項集發現的速度。

python有資料探勘的工具包pymining，裡面實現了分詞，聚類，關聯分析等功能，可以參考