【关联分析挖掘的Apriori算法】Python自行实现+应用实例

实验分析与设计思路

1.算法原理简述

（1）发现频繁项目集
通过用户给定的最小支持度，寻找所有频繁项目集，即满足support不小于Minsupport的所有项目子集。一般地，我们只关心那些不被其他频繁项目集所包含的所谓最大频繁项目集的集合。发现所有的频繁项目集是形成关联规则的基础。
（2）生成关联规则
通过用户给定的最小可信度，在每个最大频繁项目集中，寻找confidence不小于minconfidence的关联规则。

2.实验步骤

（1）发现频繁项目集
（2）生成关联规则

3.细化的伪代码

（1）算法3-1发现频繁项集

（2）算法3-2候选集产生

（3）算法3-3判断是否是候选集元素

（4）算法3-4 从给定的频繁项目集中生成强关联规则

Apriopri算法代码实现

1.定义给候选集计算支持数sup的函数

'''
输入：原数据集dataset
      候选集itemset_Ck，格式为[[1],[2],[3],[4],[5]]
输出：计算完sup的Ck，格式为[[[1], 2], [[2], 3], [[3], 3], [[4], 1], [[5], 3]]
'''
def C_sup(dataset,itemset_Ck):
    C_sup = []
    for c in itemset_Ck:
        count = 0  #计数
        for i in range(len(dataset)):
            if set(c) <= set(dataset[i]):  #选择不重复的元素
                count += 1
        C_sup.append([c,count])
    return C_sup

2.定义生成集合子集的生成器对象

'''
二进制法枚举所有子集
输入：列表items
输出：需要调用之后循环输出,列表形式

4 >> 1 = 2  ,4 >> 2 = 1(因为4=100，1向右移动1位得到010=2，向右移动2位得到001=1)

带有 yield 的函数不再是一个普通函数，而是一个生成器generator，可用于迭代
工作原理就是通过重复调用next()方法，直到捕获一个异常
'''
def PowerSetsBinary(items):    
    #生成n个元素items的所有组合
    n = len(items)    
    #枚举2**n个可能的组合(n个元素的集合的子集有2**n个)
    for i in range(2**n):        
        subset = []  #存放子集   
        #j控制要选取的元素当前的下标对应的值
        for j in range(n):            
            #i >> j 指i在二进制的形式将1向右移动j位
            #向右移动j次,判断结果除以2 余1 来得到是否要取当前的下标对应的值
            #因为二进制形式，用%2控制得数为0或1，测试一些数之后得到如果余1刚好j是要取的下标，很神奇
            if(i >> j ) % 2 == 1:                
                subset.append(items[j])
        #呼叫subset
        yield subset

3.定义输出最大频繁项集的函数

'''
最大频繁项集的元素，不为别的频繁项集的子集
输入：频繁项目集L
输出：最大频繁项集Lmax
'''
def max_frequentSet(L):
    L = L[1:]  #因为要考虑的是关联规则，频繁1项集生成的规则不是就关联规则，故不考虑
    Lmax = []  #存放最大频繁项集
    #对于每组频繁k-1项集，频繁k项集不考虑，因为其肯定为最大频繁项集
    for i in range(len(L)-1):
        L_compared = []  #存放要被拿来比较是否为子集的元素
        for j in range(i+1,len(L)):
            for k in range(len(L[j])):
                L_compared.append(L[j][k])
        #开始比较
        for j in range(len(L[i])):
            count = 0  #统计L_compared中元素不包含L[i][j]的个数
            for k in range(len(L_compared)):
                if set(L[i][j])<set(L_compared[k]):  #如果是子集，直接结束在L_compared中的比较
                    break
                else:
                    count += 1  #不是子集，则次数加一
            #如果L_compared中元素不包含L[i][j]的个数和L_compared的个数相等，则可以认为L[i][j]不是L_compared的子集
            if count == len(L_compared):
                Lmax.append(L[i][j])
                
    #将频繁k项集加入最大频繁项集
    for i in range(len(L[-1])):
        Lmax.append(L[-1][i]) 
        
    return Lmax

4.算法3-3 定义判断候选集的元素

'''
输入：一个候选k项集c，格式为[2, 3, 5]
      频繁k-1项集，格式为[[1,3],[2,3],[2,5],[3,5]]
输出：c是否从候选集中删除的布尔判断
      返回True删除
      返回False不删除
'''
def has_infrequent_subset