之前費心費力寫了一篇，結果沒有儲存。這一篇主要放上書本上的程式分析及執行結果。

    關聯分析主要分為：頻繁項集生成和關聯規則生成

1.頻繁項集生成——Apriori演算法

程式碼：

def createC1(dataSet):
    '''
    構建大小為1的所有候選項的集合，儲存不重複的項值
    map(function,data)對映函式,在python3中返回一個迭代器，智慧迴圈一次，故改為list
    frozenset() 返回一個凍結的集合，凍結後集合不能再新增或刪除任何元素，不可改變
                可用做字典鍵值使用
    '''
    C1=[]
    for transcation in dataSet:
        for item in transcation:
            if not [item] in C1:
                C1.append([item])
    C1.sort()
    return list(map(frozenset,C1))    
    
def scanD(D,Ck,minSupport):
    '''
    D：資料集  Ck：候選項集列表 minSupport：最小支援度
    '''
    ssCnt={}                      #建立空字典
    for tid in D:        
        for can in Ck:            
            if can.issubset(tid):
                if not ssCnt. __contains__(can): #與課本不同，python3沒有has_key()
                    ssCnt[can]=1
                else:
                    ssCnt[can]+=1
                                
    numItems=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):
    '''
    建立候選項集   Lk:頻繁項集列表   k：項集元素個數，期望得到的是含有k個元素的集合
    '''
    retList=[]
    lenLk=len(Lk)
    for i in range(lenLk):
        for j in range(i+1,lenLk):
            L1=list(Lk[i])[:k-2]    #取兩個集合前k-2個數
            L2=list(Lk[j])[:k-2]
            L1.sort()
            L2.sort()
            if L1==L2:           
                retList.append(Lk[i]|Lk[j])   #如果兩個集合前k-2個元素都相等，那這兩個集合合成一個集合，並操作
    return retList


def apriori(dataSet,minSupport=0.5):
    '''
    apriori演算法主函式
    '''
    #前3條語句是對計算查詢單個元素中的頻繁項集
    C1=createC1(dataSet)
    D=list(map(set,dataSet))
    L1,supportData=scanD(D,C1,minSupport)
    L=[L1]
    k=2    
    #L[k-1]中集合有k個元素，迴圈更新頻繁項集
    while(len(L[k-2])>0):    #是否還有候選集        
        Ck=aprioriGen(L[k-2],k)
        Lk,supK=scanD(D,Ck,minSupport)
        supportData.update(supK)  #把supk的鍵值對新增到supportData裡
        L.append(Lk)
        k+=1
    return L,supportData
 

對給定的簡單資料集：

#建立資料集
def loadDataSet():
    return [[1,3,4],[2,3,5],[1,2,3,5],[2,5]]

if __name__=='__main__':    
    dataSet=loadDataSet()
    L,support=apriori(dataSet,0.5)
    
    for k in support:
        print(k,support[k])
    print()
    print(L)

得到結果：

2.關聯規則生成

    我認為書本上的generateRules()函式有錯誤。當頻繁項元素大於2（程式裡 i>1）時，應該先計算規則右部元素個數為1時的可信度，而不是直接跳過。程式碼修改為：

def generateRules(L,supportData,minConf=0.7):
    '''
    關聯規則生成主函式
    L:頻繁集項列表   supportData：包含頻繁項集支援資料的字典  minConf：最小可信度閾值
    構建關聯規則需有大於等於兩個的元素
    '''
    bigRuleList=[]
    for i in range(1,len(L)):
        for freqSet in L[i]:
            H1=[frozenset([item]) for item in freqSet] #記錄freqSet裡的單個元素
            H1=calcConf(freqSet,H1,supportData,bigRuleList,minConf)
            if (i>1):
                #考慮進行進一步合併,這裡與課本不同
                #如果只有兩個元素,即只包含關於A->B形式的集合，無需對supportData進行更新                
                rulesFromConseq(freqSet,H1,supportData,bigRuleList,minConf)
            
    return bigRuleList

def calcConf(freqSet,H,supportData,br1,minConf=0.7):
    '''
    計算規則可信度以及找到滿足最小可信度要求的規則    
    freqSet是H的超集
    具體是計算freqSet-conseq'-->'conseq的可信度
    '''
    prunedH=[]
    for conseq in H:
        conf=supportData[freqSet]/support[freqSet-conseq]
        if conf>=minConf:
            print( freqSet-conseq,'-->',conseq,'conf:',conf)
            br1.append((freqSet-conseq,conseq,conf))
            prunedH.append(conseq)
    return prunedH

def rulesFromConseq(freqSet,H,supportData,br1,minConf=0.7):
    '''
    這裡H相當於freqSet子集
    在這個函式裡面，迴圈是從子集元素個數由2一直增大到freqSet的元素個數減1
    '''
    m=len(H[0])
    if(len(freqSet)>(m+1)):
        Hmp1=aprioriGen(H,m+1)    #將H中各集合（元素個數為m)合併成有m+1個元素的集合
        Hmp1=calcConf(freqSet,Hmp1,supportData,br1,minConf)        
        if(len(Hmp1)>1):        #表示至少還有兩個子集，可以合併，相當於迴圈操作
            rulesFromConseq(freqSet,Hmp1,supportData,br1,minConf)
 

對給定簡單資料集：

if __name__=='__main__':
       
    dataSet=loadDataSet()
    L,support=apriori(dataSet,0.5)    
    rules=generateRules(L,support,0.5)

得到結果：

圖中用紅筆標識的部分在書本所寫程式碼中是無法得到的。