西电数据挖掘作业——关联规则aprior算法python实现

def loadDataSet（）:
   
    ‘‘‘‘‘创建一个用于测试的简单的数据集‘‘‘
    return [[1 3 4 5] [2 3 5] [1 2 3 4 5] [2 3 4 5]]


def createC1（dataSet）:
    ‘‘‘‘‘
        构建初始候选项集的列表，即所有候选项集只包含一个元素，
        C1是大小为1的所有候选项集的集合
    ‘‘‘
    C1 = []
    for transaction in dataSet:
        for item in transaction:
            if [item] not in C1:
                C1.append（[item]）
    C1.sort（）
    # return map（ frozenset C1 ）
    # return [var for var in map（frozensetC1）]
    return [frozenset（var） for var in C1]


def scanD（D Ck minSupport）:
    ‘‘‘‘‘
        计算Ck中的项集在数据集合D（记录或者transactions）中的支持度
        返回满足最小支持度的项集的集合，和所有项集支持度信息的字典。
    ‘‘‘
    ssCnt = {}
    for tid in D:  # 对于每一条transaction
        for can in Ck:  # 对于每一个候选项集can，检查是否是transaction的一部分 # 即该候选can是否得到transaction的支持
            if can.issubset（tid）:
                ssCnt[can] = ssCnt.get（can 0） + 1
    numItems = float（len（D））
    retList = []
    supportData = {}
    for key in ssCnt:
        support = ssCnt[key] / numItems  # 每个项集的支持度
        if support >= minSupport:  # 将满足最小支持度的项集，加入retList
            retList.insert（0 key）
        supportData[key] = support  # 汇总支持度数据
    return retList supportData


def aprioriGen（Lk k）:  # Aprior算法
    ‘‘‘‘‘
        由初始候选项集的集合Lk生成新的生成候选项集，
        k表示生成的新项集中所含有的元素个数
    ‘‘‘
    retList = []
    lenLk = len（Lk）
    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


def apriori（dataSet minSupport=0.5）:
    C1 = createC1（dataSet）  # 构建初始候选项集C1
    # D = map（ set dataSet ）                                 # 将dataSet集合化，以满足scanD的格式要求
    # D=[var for var in map（setdataSet）]
    D = [set（var） for var in dataSet]
    L1 suppData = scanD（D C1 minSupport）  # 构建初始的频繁项集，即所有项集只有一个元素
    L = [L1]  # 最初的L1中的每个项集含有一个元素，新生成的
    k = 2  # 项集应该含有2个元素，所以 k=2

    while （len（L[k - 2]） > 0）:
        Ck = aprioriGen（L[k - 2] k）
        Lk supK = scanD（D Ck minSupport）
        suppData.update（supK）  # 将新的项集的支持度数据加入原来的总支持度字典中
        L.append（Lk）  # 将符合最小支持度要求的项集加入L
        k += 1  # 新生成的项集中的元素个数应不断增加
    return L suppData  # 返回所有满足条件的频繁项集的列表，和所有候选项集的支持度信息


def calcConf（freqSet H supportData brl minConf=0.7）:  # 规则生成与评价
    ‘‘‘‘‘
        计算规则的可信度，返回满足最小可信度的规则。
        freqSet（frozenset）:频繁项集
        H（frozenset）:频繁项集中所有的元素
        supportData（dic）:频繁项集中所有元素的支持度