数据挖掘-关联分析 Apriori算法和FP-growth 算法

#coding=gbk
# apriori算法的实现
def load_dataset(): #定义数据集
    return [[1,3,4],[2,3,5],[1,2,3,5],[2,5]]

def create_C1(dataSet): #得到数据集中的每个数据，且进行排序
    C1 =[]
    for transantion in dataSet:
        for item in transantion:
            if not [item] in C1:
                C1.append([item])   #储存 I1, I2,。。需要使其不重复
    C1.sort()
    #use frozen set so we can use it as a key in a dict
    #应该输出 1,2,3,4,5
    return list(map(frozenset, C1))  #  将C1中的每个集合映射为frozenset,之后可以作为字典的键,

dataSet = load_dataset()
ck = create_C1(dataSet)
print(ck)        # 输出：[frozenset({1}), frozenset({2}), frozenset({3}), frozenset({4}), frozenset({5})]

#测试代码
# # map(function, sequence)
# c2 = [[2,4],[5,8],[3]]
# c2.sort()
# a = list(map(frozenset, c2))
# print(a)    #[frozenset({2, 4}), frozenset({3}), frozenset({8, 5})]
# print(a[0]) # frozenset({2, 4})

# Apriori算法首先构建集合 C1 ,然后扫描数据集判断这些只有一个元素的项集是否满足最小支持度的要求。那些满足最低要求的项集构成集合 L1 。
# 而 L1 中的元素相互组合构成 C2 , C2 再进一步过滤变为 L2 。

#该函数使 C1 生成L1,ck为全部的数据项
def scanD(D, Ck, minSupport):   #参数D 为数据集， Ck为候选项列表， 最小支持度
    ssCnt= {}       #存储数据项1,2，。。及其出现的次数
    
    for tid in D:       #遍历数据集
        for can in Ck:  #遍历候选项 1,2,3,4,5,
            if can.issubset(tid):   #判断候选项是否含数据集中的各项
                if not can in ssCnt:
                    ssCnt[can] =1
                else:
                    ssCnt[can]+=1   #有则进行加一操作，   1,2,3,4,5 的数据项的个数， 为了计算支持度
    numItems = float(len(D))    #计算数据集大小
    retList = []        #使L1 初始化， 保存大于最小支持度的数据项
    supportData = {}    #使用字典记录支持度
    for key in ssCnt:
        support = ssCnt[key]/ numItems  #求得支持度
        if support >= minSupport:       #如果支持度大于用户给的最小支持度， 对小于的数据项进行去除。
            retList.insert(0,  key) #保存到列表中
        else:
            supportData[key]= support   #输出去除项的支持度
    return retList, supportData

#测试：
r, s = scanD(dataSet, ck, 0.5)
print(r)    #[frozenset({1}), frozenset({3}), frozenset({2}), frozenset({5})]
print(s)    #{frozenset({4}): 0.25}

#Apriori 算法实现
# 输入参数为 频繁项集列表 Lk 与  项集元素个数 k , 输出为 Ck 
def aprioriGen(Lk, k):  
    retList = []
    lenLk = len(Lk) 
    for i in range(lenLk):
        for j in range(i+1, lenLk): #两两组合遍历 （1,2,3，5）
            L1 = list(Lk[i])[:k-2]  
            L2 = list(Lk[j])[:k-2]  #用列表储存 k-2 项的项集
            L1.sort(); L2.sort()
            if L1 == L2:
                retList.append(Lk[i] | Lk[j])   #若2个集合的前 k-2 个项相同时， 则将两个集合合并
    return retList

def apriori(dataSet, minSupport =0.5):
    C1 = create_C1(dataSet)
    D = list(map(set, dataSet))
    L1, supportData = scanD(D, C1, minSupport)  #生成L1
    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)        #在1 -项集上增加 2-项集 
        k +=1
    return L, supportData 

a= [1,2,3]
a.append([[12],[13],[16]])
print(a)    #[1, 2, 3, [[12], [13], [16]]]

#apriori 测试
print(‘------apriori test -------‘)
dataSet = load_dataset()
L, supportData = apriori(dataSet)

print(L)#[[frozenset({1}), frozenset({3}), frozenset({2}), frozenset({5})], [frozenset({3, 5}), frozenset({1, 3}), 
# frozenset({2, 5}), frozenset({2, 3})], [frozenset({2, 3, 5})], []]

print(L[0]) #  [frozenset({1}), frozenset({3}), frozenset({2}), frozenset({5})]
print(L[1]) #  [frozenset({3, 5}), frozenset({1, 3}), frozenset({2, 5}), frozenset({2, 3})]
print(L[2]) #[frozenset({2, 3, 5})]
print(L[3]) # [] 频繁项集为空， 所以的出频繁项集 为{2,3,5} 

#查看全部项集的支持度
print(supportData)  # 部分输出：{frozenset({5}): 0.75, frozenset({3}): 0.75, frozenset({2, 3, 5}): 0.5,

#从频繁项集中挖掘关联规则

#产生关联规则
#参数为 L 为频繁项集， supportData 为全部项集的支持度， mincof 设置最小的置信度为 0.7
def generateRules(L, supportData, minconf = 0.7):
    bigRuleList = []    #存储所有的关联规则
    for i in range(1,len(L)):   #只获取2 个或更多项集
        for freqSet in L[i]:
            #遍历L 中每一个频繁项集，对每个项集创建值包含单个元素的 列表 
            H1 = [frozenset([item]) for item in freqSet]
            #如果频繁项集数目超过2 个， 就对其进行进一步的合并
            if (i>1 ):
                rulesFromConseq(freqSet, H1, supportData, bigRuleList, minconf)
            else:
                #第一层时， 后件数为1
                calcConf(freqSet, H1, supportData, bigRuleList, minconf)
    return bigRuleList
    
#生成候选规则集合： 计算规则的置信度，以及找到满足最小置信度的规则
def calcConf(freqSet, H1, supportData, brl, minconf=0.7):
    #针对项集只有2 个元素时， 计算置信度
    prunedH = []    #返回一个满足最小置信度的规则列表
    for conseq in H1:       #遍历H 中的所有项集， 并计算它们的置信度
        conf =  supportData[freqSet] / supportData[freqSet-conseq]  #计算置信度
        if conf >= minconf:     ##满足最小置信度要求， 则打印
            print(freqSet-conseq, ‘-->‘, conseq,‘conf:‘, conf)
            brl.append((freqSet - conseq, conseq, conf))
            prunedH.append(conseq)
    return prunedH
    
#进行合并
def rulesFromConseq(freqSet, H1, supportData, brl, minconf = 0.7):
    #参数：freqSet是频繁项， H 是可以出现在规则右边的列表  
    m = len(H1[0])
    if (len(freqSet) > (m+1)):  #如果 频繁项集元素数目大于单个集合的元素数      
        Hmp1 = aprioriGen(H1, m+1)  #  合并具有相同部分的集合
        Hmp1 = calcConf(freqSet, Hmp1, supportData, brl, minconf)   #计算置信度
        if (len(Hmp1) > 1):
            #使用递归进一步组合
            rulesFromConseq(freqSet, Hmp1, supportData, brl, minconf)

#测试关联规则输出  
print()
print(‘-------generateRules test-------‘)      
rules = generateRules(L, supportData, minconf=0.5)    
print(rules)
# -------generateRules test-------
# frozenset({5}) --> frozenset({3}) conf: 0.6666666666666666
# frozenset({3}) --> frozenset({5}) conf: 0.6666666666666666
# frozenset({3}) --> frozenset({1}) conf: 0.6666666666666666
# frozenset({1}) --> frozenset({3}) conf: 1.0
# frozenset({5}) --> frozenset({2}) conf: 1.0
# frozenset({2}) --> frozenset({5}) conf: 1.0
# frozenset({3}) --> frozenset({2}) conf: 0.6666666666666666
# frozenset({2}) --> frozenset({3}) conf: 0.6666666666666666
# frozenset({5}) --> frozenset({2, 3}) conf: 0.6666666666666666
# frozenset({3}) --> frozenset({2, 5}) conf: 0.6666666666666666
# frozenset({2}) --> frozenset({3, 5}) conf: 0.6666666666666666
# [(frozenset({5}), frozenset({3}), 0.6666666666666666),。。。。。。。