使用Apriori算法进行关联分析--代码学习

#-*- coding: utf-8 -*-
def loadDataSet():
    return [[1,3,4],[2,3,5],[1,2,3,5],[2,5]]

#构建集合C1，C1是大小为1的所有候选项集的集合
def createC1(dataSet):
    C1 = [] #创建一个空列表，用来存储所有不重复的项值
    #遍历数据集中的所有交易记录，transaction依次为数据集中的每条交易记录，即每个项集，
    # 如依次为[1,3,4],[2,3,5],[1,2,3,5],[2,5]
    for transaction in dataSet:
        for item in transaction: #遍历记录中的每一个项，item是每条交易记录中的物品，如项集[1,3,4]中的1,3,4
            if not [item] in C1:#如果某个物品项没有在C1中出现，则将其添加到C1中
                #不是简单地添加每个物品项，而是添加只包含该物品项的一个列表，
                # 目的是为每个物品构建一个集合，因为后面要进行集合操作
                C1.append([item])
    C1.sort() #对大列表进行排序
    #将列表中的每个单元素列表映射到frozenset()，最后返回frozenset的列表
    #frozenset是指被冰冻的集合，就是它们是不可改变的，这里必须使用frozenset而不是set类型，因为之后
    #必须要将这些集合作为字典键值使用，使用frozenset可以实现，而set却做不到
    return map(frozenset, C1)

#数据集Ck，包含候选集合的列表D，感兴趣项集的最小支持度minSupport
def scanD(D,Ck,minSupport):
    ssCnt = {}
    for tid in D:#遍历数据集中的所有交易记录
        for can in Ck: #遍历C1中的所有候选集
            if can.issubset(tid): #如果C1中的集合是记录的一部分，那么增加字典中对应的计数值
                if not ssCnt.has_key(can):  ssCnt[can] = 1
                else: ssCnt[can] += 1
    numItems = float(len(D)) #numItems是数据集中交易记录的条数
    retList = []
    supportData = {}
    for key in ssCnt:
        support = ssCnt[key] / numItems #计算支持度
        if support >= minSupport:
            retList.insert(0,key) #retList列表中包含了满足最小支持度要求的集合，insert(0,key)表示在列表的首部插入新的集合
        supportData[key] = support #以字典的形式将满足最小支持度要求的集合和其支持度存储在supportData
    return retList, supportData


#*********************** Apriori算法 **********************


# 输入参数为频繁项集列表Lk，k位输出的合成的项集的元素个数，
# 如当k = 2时，输出为CK [frozenset([1, 3]), frozenset([1, 2]), frozenset([1, 5]), frozenset([2, 3]), frozenset([3, 5]), frozenset([2, 5])]
# 输出中，每个项集都是两个元素
def aprioriGen(Lk,k):
    retList = [] #创建一个空列表
    lenLk = len(Lk) #计算Lk中的元素数目
    for i in range(lenLk):
        for j in range(i+1, lenLk):
            #从这步开始，就是取列表Lk中每个集合的前面k-2个元素进行比较，
            # 如果相等，就将这两个集合合为一个大小为k的集合
            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) # 创建C1
    D = map(set, dataSet) # 读入数据集并将其转化为D(集合列表)
    L1,supportData = scanD(D,C1,minSupport) # 利用scanD创建L1，
    L = [L1] # 将L1放入列表L中，L会包含L1，L2， L3 ....通过下面的while循环依次放入，直到下一个大的项集为空
    k = 2
    while(len(L[k-2]) > 0): # 代表直到下一个大的项集为空时，停止循环
        CK = aprioriGen(L[k-2], k) # 首先使用aprioriGen来创建Ck
        # 使用scanD基于Ck来创建Lk，Ck是一个候选项集列表，然后scanD会遍历Ck，丢掉不满足最小支持度要求的项集
        LK, supK = scanD(D, CK, minSupport)
        supportData.update(supK)
        L.append(LK) # Lk列表被添加到L中
        k += 1 # 同时增加k的值
    return L, supportData

#主函数
# 输入参数为频繁项集列表，包含那些频繁项集支持数据的字典，最小可信度阈值
# 函数输出为一个包含可信度的规则列表
def generateRules(L, supportData, minConf = 0.7):
    bigRuleList = []
    # 因为无法从单元素项集中构建关联规则，所以要从包含两个或更多元素的项集开始构建
    for i in range(1, len(L)):  #只可获取有两个或更多元素的集合，所以i从1开始
        for freqSet in L[i]:# 遍历L中的每一个频繁项集，并对每个频繁项集创建只包含单个元素集合的列表H1
            H1 = [frozenset([item]) for item in freqSet]
            if (i > 1):
                rulesFromConseq(freqSet, H1, supportData, bigRuleList, minConf) # 如果i > 1，频繁项集的元素数目超过2，则进一步合并
            else:
                calcConf( freqSet, H1, supportData, bigRuleList, minConf) # 当i=1时，频繁项集的元素数目为2，此时直接进行计算可信度
    return bigRuleList

# 计算规则的可信度以找到满足最小可信度要求的规则
def calcConf(freqSet, H, supportData, brl, minConf = 0.7):
    prunedH = [] #创建一个空列表，用来保存符合最小可信度要求的规则列表
    for conseq in H: #遍历H中的所有项集
        # 根据可信度的计算式：一条规则P--> H的可信度定义为support(P | H) / support(P)
        # 所有一个项集 conseq的可信度计算如下：
        conf = supportData[freqSet] / supportData[freqSet - conseq]  # 计算可信度
        if conf >= minConf:
            print freqSet-conseq, '-->',conseq,'conf:',conf # 如果满足最小可信度，则将规则输出到屏幕显示
            brl.append((freqSet - conseq, conseq, conf)) # 将通过检查的规则保存在brl中，即是bigRuleList
            prunedH.append(conseq) # 保存符合最小可信度要求的规则列表，并返回
    return prunedH

# 输入参数，freqSet是频繁项集，H是可以出现在规则右部的元素列表
def rulesFromConseq(freqSet, H, supportData, brl, minConf = 0.7):
    m = len(H[0]) # 计算H中的频繁集大小为m
    if (len(freqSet) > (m+1)): #看该频繁项集是否大到可以移除大小为m的子集
        Hmp1 = aprioriGen(H, m+1) # 生成H中元素的无重复组合，结果存储在Hmp1中，这也是下一次迭代的H列表，Hmp1中包含所有的规则
        Hmp1 = calcConf( freqSet, Hmp1, supportData, brl, minConf) # 测试Hmp1中的规则的可信度以确定规则是否满足要求，返回一个符合最小可信度要求的规则列表
        if (len(Hmp1) > 1): #如果不止一天规则满足，那么使用Hmp1迭代调用函数rulesFromConseq
            rulesFromConseq(freqSet, Hmp1, supportData, brl, minConf)

dataSet = loadDataSet()
L, supportData = apriori(dataSet, 0.5)
rules = generateRules(L, supportData, minConf = 0.5)
print rules