关联分析之发现频繁项集--使用Apriori算法（1）

转自微信公众号--每日一Python

 

从大规模数据集中寻找物品间的隐含关系被称为关联分析，最有名的案例应该是啤酒和尿布了。这些关系可以用两种方式来量化，一个是使用频繁项集，给出经常在一起出现的元素项；一个是关联规则，每条关联规则意味着元素项之间的“如果……那么”（A-->B）的关系；要先找到频繁项集然后才能获得关联规则。

本文主要是先讲找到频繁项集（本文中的代码使用的是Python3）。

发现元素之间的关系是一个非常耗时的任务，可以使用Apriori算法来减少在数据库上进行检查的集合的数目。Apriori原理是如果一个元素项是不频繁的，则那些包含该元素的所有超级也是不频繁的（例A是不频繁出现的，则AB也是不频繁的）；Apriori算法从单元素项集开始，通过组合满足最小支持度要求的项集来形成更大的集合。

1. 发现频繁项集

   先产生一个只有一个元素的项集的候选集：

 def loadDataset():
     return [[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]]
     
  
 def creatC1(dataset):
     C1 = []
     for transaction in dataset:
         for item in transaction:
             if not [item] in C1:
                 C1.append([item])
     C1.sort()
     return list(map(frozenset, C1))
#frozenset 是不可变类型，可以将集合作为字典健值使用，set不能；

然后再统计C1中元素出现的次数，以计算是否满足最小支持度，满足最小支持度的元素才添加到频繁项集列表中：

def scanD(Dset, Ck, minSupport):
#Dset是数据集，Ck是候选项集列表，minSupport是最小支持度
    ssCnt = {}
    #创建一个空字典ssCnt用来保存候选子集和候选子集对应的频数
    for tid in Dset:
        for can in Ck:
            if can.issubset(tid):
                if not ssCnt.__contains__(can):
                    ssCnt[can] = 1
                else:
                    ssCnt[can] += 1
                    
   #计算字典中的每个元素，计算支持度                 
    numItems = float(len(Dset))
    retList = []
    supportData = {}
    for key in ssCnt:
        support = ssCnt[key]/numItems
        if support >= minSupport:
            retList.inset(0, key)
        supportData[key] = support
        
return retList, supportData
#retList是返回的频繁项集， supportData是对应的的支持度

以上只是返回只有一个元素的频繁项集，还需要完善代码以返回由k项组成的频繁项集，步骤与上述相同，也是先产生含K项的候选集列表，然后判断是否满足最小支持度，这里为了减少开销，要使用Apriori原理；

def aprioriGen(Lk, k):
#Lk是频繁项集列表，K是项集元素个数，函数返回的是CK，即含有K个元素的候选项集
    retlist = []
    lenLk = len(Lk)
#计算频繁项集的元素个数，然后比较项集中每一个元素和其他元素（两个for循环）
#如果一个元素和另一个元素的前k-2项重复，则将两个元素合并成一个大小为K的集合
    for i in range(lenLk):
        for j in range(i+1, lenLk):
            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

创建一个主函数apriori封装上面几个函数，

def apriori(dataset, minsupport = 0.5):
    C1 = createC1(dataset)
    D = list(map(set, dataset))
    L1, supportdata = scanD(D,C1 ,minsupport)
    L = [L1]
#先调用createC1和scanD产生只有一个元素的频繁项集

#然后基于L调用apriorigen产生只有两个元素的候选集，再调用scanD来生成含有
#两个元素的频繁项集，之后K加一，循环调用产生含有三个元素的频繁项集，一直循环
#直到L(K-2)的长度=0
    k =2
    while (len(L[k-2]) > 0):
        Ck = apriorigen(L[k-2], k)
        Lk, supk = scanD(D, Ck, 0.2)
        supportdata.update(supk)
        L.append(Lk)
        k += 1
    return L, supportdata

直接调用apirio()主函数就可以得到满足最小支持度的频繁项集啦，例如L, SupportData = apriori(dataset,minsupport=0.7)，L就是出现次数大于70%以上的所有项集。