【Python】实现Apriori算法和FP-growth算法(附源代码）

1、Apriori算法

def item(dataset):  # 求第一次扫描数据库后的 候选集，（它没法加入循环）
    c1 = []  # 存放候选集元素

    for x in dataset:  # 就是求这个数据库中出现了几个元素，然后返回
        for y in x:
            if [y] not in c1:
                c1.append([y])
    c1.sort()
    # print(c1)
    return c1


def get_frequent_item(dataset, c, min_support):
    cut_branch = {}  # 用来存放所有项集的支持度的字典
    for x in c:
        for y in dataset:
            if set(x).issubset(set(y)):  # 如果 x 不在 y中，就把对应元素后面加 1
                cut_branch[tuple(x)] = cut_branch.get(tuple(x),
                                                      0) + 1  # cut_branch[y] = new_cand.get(y, 0)表示如果字典里面没有想要的关键词，就返回0
    # print(cut_branch)

    Fk = []  # 支持度大于最小支持度的项集，  即频繁项集
    sup_dataK = {}  # 用来存放所有 频繁 项集的支持度的字典

    for i in cut_branch:
        if cut_branch[i] >= min_support:  # Apriori定律1  小于支持度，则就将它舍去，它的超集必然不是频繁项集
            Fk.append(list(i))
            sup_dataK[i] = cut_branch[i]
    return Fk, sup_dataK


def get_candidate(Fk, K):  # 求第k次候选集
    ck = []  # 存放产生候选集

    for i in range(len(Fk)):
        for j in range(i + 1, len(Fk)):
            L1 = list(Fk[i])[:K - 2]
            L2 = list(Fk[j])[:K - 2]
            L1.sort()
            L2.sort()  # 先排序，在进行组合

            if L1 == L2:
                if K > 2:  # 第二次求候选集，不需要进行减枝，因为第一次候选集都是单元素，且已经减枝了，组合为双元素肯定不会出现不满足支持度的元素
                    new = list(set(Fk[i]) ^ set(Fk[j]))  # 集合运算 对称差集 ^ （含义，集合的元素在t或s中，但不会同时出现在二者中）
                    # new表示，这两个记录中，不同的元素集合
                    # 为什么要用new？ 比如 1，2     1，3  两个合并成 1，2，3   我们知道1，2 和 1，3 一定是频繁项集，但 2，3呢，我们要判断2，3是否为频繁项集
                    # Apriori定律1 如果一个集合不是频繁项集，则它的所有超集都不是频繁项集
                else:
                    new = set()
                for x in Fk:
                    if set(new).issubset(set(x)) and list(
                            set(Fk[i]) | set(Fk[j])) not in ck:  # 减枝 new是 x 的子集，并且 还没有加入 ck 中
                        ck.append(list(set(Fk[i]) | set(Fk[j])))
    # print(ck)
    return ck


def Apriori(dataset, min_support=2):
    c1 = item(dataset)  # 返回一个二维列表，里面的每一个一维列表，都是第一次候选集的元素
    f1, sup_1 = get_frequent_item(dataset, c1, min_support)  # 求第一次候选集

    F = [f1]  # 将第一次候选集产生的频繁项集放入 F ,以后每次扫描产生的所有频繁项集都放入里面
    sup_data = sup_1  # 一个字典，里面存放所有产生的候选集，及其支持度

    K = 2  # 从第二个开始循环求解，先求候选集，在求频繁项集

    while (len(F[K - 2]) > 1):  # k-2是因为F是从0开始数的     #前一个的频繁项集个数在2个或2个以上，才继续循环，否则退出
        ck = get_candidate(F[K - 2], K)  # 求第k次候选集
        fk, sup_k = get_frequent_item(dataset, ck, min_support)  # 求第k次频繁项集

        F.append(fk)  # 把新产生的候选集假如F
        sup_data.update(sup_k)  # 字典更新，加入新得出的数据
        K += 1
    return F, sup_data  # 返回所有频繁项集， 以及存放频繁项集支持度的字典


if __name__ == '__main__':
    n = int(input("共有几组数据？"))
    testList = [[] for i in range(n)]
    for i in range(n):
        testList[i] = list(map(str, input().split(' ')))  # 装入数据 二维列表
    print(testList)
    F, sup_data = Apriori(testList, min_support=2)  # 最小支持度设置为2

    print("具有关联的商品是{}".format(F))  # 带变量的字符串输出,必须为字典符号表示
    print('------------------')
    print("对应的支持度为{}".format(sup_data))
    

2、F-Growth算法

import copy

class FpNode():

    def __init__(self, name='', childs={}, parent={}, nextCommonId={}, idCount=0):
        self.idName = name  # 名字
        self.childs = childs  # 所有孩子结点
        self.parent = parent  # 父节点
        self.nextCommonId = nextCommonId  # 下一个相同的 id名字 结点
        self.idCount = idCount  # id 计数

    def getName(self):  # 获取该节点名字
        return self.idName

    def getAllChildsName(self):  # 获取该节点所有孩子节点的名字
        ch = self.childs
        keys = list(ch.keys())
        names = []
        for i in keys:
            names.append(list(i))
        return names

    def printAllInfo(self):  # 打印该节点所有信息
        print(self.idName, self.idCount, list(self.childs.keys()), list(self.parent.keys()), self.nextCommonId.items())

    @classmethod
    def checkFirstTree(cls, rootNode):  # 前序遍历整个树（这不是二叉树，没有中序遍历）
        if rootNode is None:
            return ''
        # parent1 = rootNode.parent.keys()      #要加一个 强转 ，否则它会变成 Nopetype 型，
        rootNode.printAllInfo()  # print(rootNode.idName, type(rootNode.parent))  报错 root <class 'NoneType'>

        if rootNode.childs is not None:
            keys = list(rootNode.childs.keys())
            for i in keys:
                cls.checkFirstTree(rootNode.childs[i])

    @classmethod
    def checkBehindTree(cls, rootNode):  # 后序遍历整个树
        if rootNode is None:
            return ''
        if rootNode.childs is not None:
            keys = list(rootNode.childs.keys())
            for i in keys:
                cls.checkBehindTree(rootNode.childs[i])
        rootNode.printAllInfo()


def scan1_getCand1(database):  # 第一次扫描统计出现的次数
    c1 = {}  # 候选集

    for i in database:
        for j in i:
            c1[j] = c1.get(j, 0) + 1  # 表示如果字典里面没有想要的关键词，就返回0
    # print(c1)
    return c1


# 返回排好序的字典

# 对数据进行排序，按支持度由大到小排列
def sortData(**d):  # 形参前添加两个 '*'——字典形式  形参前添加一个 '*'——元组形式
    sortKey = list(d.keys())  # 直接使用sorted(my_dict.keys())就能按key值对字典排序
    sortValue = list(d.values())

    length = len(sortKey)
    for i in range(length - 1):  # 按照支持度大小，由大到小排序的算法
        for j in (i, length - 1 - 1):  # 必须 -1 （1，len）虽然不包含 len本身 但是数组【len-1】时最后一个元素，必须减去这个元素
            if sortValue[i] < sortValue[j + 1]:
                sortValue[i], sortValue[j + 1] = sortValue[j + 1], sortValue[i]  # 如果它的支持度小与另一个，交换位置
                sortKey[i], sortKey[j + 1] = sortKey[j + 1], sortKey[i]

    new_c1 = {}  # 存放排完序的数据记录
    for i in range(length):
        new_c1[sortKey[i]] = sortValue[i]

    return new_c1  # 返回排好序的字典


# 得到 database 的频繁项集
def getFreq(database, minSup=3, **c1):  # 返回频繁项集，和频繁项集的支持度

    c1 = scan1_getCand1(database)  # 第一次扫面数据库，求第一次候选集，返回的是字典
    new_c1 = sortData(**c1)  # 排序，大到小

    keys = list(new_c1.keys())
    for i in keys:
        if new_c1[i] < minSup:  # 若支持度小于最小支持度，则删除该商品
            del new_c1[i]

    f1 = []  # 第一次频繁项集
    new_keys = list(new_c1.keys())
    for i in new_keys:
        if [i] not in f1:
            f1.append([i])  # 每个元素自成一项
    # print(f1,new_c1)
    return f1, new_c1


def createRootNode():  # 创建一个根节点
    rootNode = FpNode('root', {}, {}, {}, -1)  # name, childs, parent, nextCommonId, idCount
    return rootNode


def buildTree(database, rootNode, f1):  # 构建频繁模式树 FpTree

    for i in database:  # 第二次扫描数据库
        present = rootNode  # 指向当前节点
        next = FpNode(name='', childs={}, parent={}, nextCommonId={}, idCount=0)  # 创建一个新节点，并初始化
        for j in f1:  # 按支持度从大到小的顺序进行构建节点
            if set(j).issubset(set(i)):  # j如果在i里面
                if (present.getName() == 'root') and j not in rootNode.getAllChildsName():
                    next.idName = str(j[0])  # 对新创建的节点进行赋值
                    next.idCount = next.idCount + 1
                    next.nextCommonId = {str(j[0]): 0}

                    next.parent.update({rootNode.idName: rootNode})
                    temp = copy.copy(next)
                    rootNode.childs.update({str(j[0]): temp})  # 往它插入父亲节点
                    ##print(temp.parent)

                    present = temp  # present = next 这样直接赋值是 引用 ，一定要注意
                    next = FpNode(name='', childs={}, parent={}, nextCommonId={}, idCount=0)  # 创建并初始化下一个新节点

                else:
                    if j in present.getAllChildsName():  # 如果需要插入的节点已经存在
                        temp2 = present.childs[str(j[0])]
                        present = temp2
                        present.idCount = present.idCount + 1  # count+1即可
                    else:
                        next.idName = str(j[0])  # 对新插入的节点赋值
                        next.idCount = next.idCount + 1
                        next.nextCommonId = {str(j[0]): 0}
                        next.parent.update({present.idName: present})
                        # temp3 = copy.copy(next)
                        present.childs.update({str(j[0]): next})  # 往它插入父亲节点
                        # temp3.childs = {}

                        present = next
                        next = FpNode(name='', childs={}, parent={}, nextCommonId={}, idCount=0)

                # present = next
                # next = FpNode()
    # print(rootNode.getAllChildsName())
    # print('前序遍历如下：')
    # FpNode.checkFirstTree(rootNode)
    # print('后序遍历如下：')
    # FpNode.checkBehindTree(rootNode)
    return None


# 构建线索，填节点的nextCommonId这个属性
def buildIndex(rootNode, d1):  # 传 列表或字典时，列表前，加*， 字典前加 ** 表示传给函数的是一个地址，在函数内部改变这个参数，不会影响到函数外的变量

    if rootNode is None:
        return ''
    next = rootNode  # 指向下一个节点，当前赋值为根节点
    value = rootNode.idName
    # print(value)
    # print(d1[str(value)])             #d1[value] {KeyError}'a'???????????????   如果value是根节点root，就会出错，表中本来就没有root这个值
    # print(d1)
    if value != 'root':
        indexAds1 = {value: d1[value]}
        if d1[value] == 0:  # 线索构造   我已经把初始化了所有的 nextCommonId 为 {'': 0}
            # 所以后面只要 这个节点的 nextCommonId字典的值为0，就说明这个字典就是构建的链表链尾
            d1[value] = next
            # print(indexAds1)
        else:
            while indexAds1[value] != 0:
                indexAds1 = indexAds1[value].nextCommonId  # 以链表形式把最后一个 表尾元素找出来
                # print(indexAds1)
            indexAds1[value] = next  # 这个元素后面加入 当前所在树的这个节点的地址
            # print(next.nextCommonId)
    if rootNode.childs is not None:  # 根节点孩子不是null，则对它的每个孩子，依次递归进行线索构建
        keys = list(rootNode.childs.keys())
        for i in keys:
            buildIndex(rootNode.childs[i], d1)


def createIndexTableHead(**indexTableHead):  # 创建一个表头，用来构建线索，表头的名字是相应节点的名字
    keys = list(indexTableHead.keys())
    # print(keys)
    for i in keys:
        indexTableHead[i] = 0

    return indexTableHead


def getNewRecord(idK, **indexTableHead):  # 得到新的数据记录
    newData = []
    address = indexTableHead[idK]

    while address != 0:
        times = 0
        times = address.idCount  # 当前节点count数
        l = []  # 临时存放这个分支上的所有节点元素，单个单个存储 二维列表
        getOneNewR = []  # 和l一样，是l的倒叙，因为l本来是倒叙的，现在把它改成倒叙
        # print(list(address.parent.keys())[0])  #这样写才是 字符 c  而不是 'c'
        nextAdress = copy.copy(address)  # 一个指针，指向父亲节点，初始化为表头第一个的地址
        while list(nextAdress.parent.keys())[0] != 'root':  # 该节点发父亲节点不是根节点。则
            # print(address.parent)
            l.append(list(nextAdress.parent.keys()))  # 把它的父亲节点加入l中

            parentIdName = list(nextAdress.parent.keys())[0]  # 父亲节的名字
            nextAdress = nextAdress.parent[parentIdName]  # 指向该节点父亲节点
        if l != []:
            for j in l:
                getOneNewR.append(j[0])

        if getOneNewR != []:
            for k in range(times):  # 若最后的那个 idk 计数为多次，要把它多次添加到新产生的newData中
                newData.append(list(getOneNewR))
        # 把得到的记录加入新的数据集中

        address = address.nextCommonId[idK]  # 指向下一个表头元素的开始地址，进行循环

    return newData


#    idK表示当前新产生的数据集是在去除这个字母后形成的，  fk是去除掉idk后，新的第一次频繁项集  dk是fk的支持度
def getAllConditionBase(newDatabase, idK, fk, minSup, **dk):  # 返回条件频繁项集 base， 和支持度

    if fk != []:  # 频繁项集非空
        newRootNode = createRootNode()  # 创建新的头节点
        buildTree(newDatabase, newRootNode, fk)
        # newIndexTableHead = {}  #创建新表头
        newIndexTableHead = createIndexTableHead(**dk)  # **dk 就是传了个值，给了它一个拷贝，修改函数里面的这个拷贝，不会影响到外面的这个变量的值
        buildIndex(newRootNode, newIndexTableHead)
    else:
        return [idK], {idK: 9999}  # 频繁项集是空的，则返回idk的名字，支持度设为最大值9999，这样会出现一些问题，最后已经解决了，在主函数代码中有表现出来

    if len(newRootNode.getAllChildsName()) < 2:  # 新的FpTree只有1条分支，（这里只认为根节点只有1个孩子，就说他只有一条分支）
        # 若是实际数据，就不能这样写了，应当在写一个函数，从根节点开始遍历，确保每个节点都只有1个孩子，才能认为只有1条分支
        base = [[]]  # 条件基
        node = newRootNode
        while node.getAllChildsName() != []:  # 当前节点有孩子节点
            childName = list(node.childs.keys())  # 一个列表，孩子节点的所有名字，其实就1个孩子，前面已经判断了是单节点
            base.append(list(childName[0]))  # 把孩子节点加入条件基
            # print(node.childs)
            # print(childName)
            node = node.childs[childName[0]]  # 指向下一个节点
            # print(base)
        itemSup = {node.idName: node.idCount}  # 这一条分支出现的次数，最后求频繁项集支持度需要用到
        # print(itemSup)
        return base, itemSup  # 返回条件基，还有这一条分支出现的次数，
    else:  # 分支不止1条，进行递归查找，重复最开始的操作
        base = [[]]
        for commonId in fk[-1::-1]:  # 倒叙进行
            newIdK = str(commonId[0])
            newDataK = getNewRecord(newIdK, **newIndexTableHead)  # 传入这个表头的一个拷贝
            fk2, dk2 = getFreq(newDataK, minSup)
            conditionBase, itemSup = getAllConditionBase(newDataK, newIdK, fk2, minSup, **dk2)  # 得到该条件基下的条件基，及各个分支出现次数
            # 递归进行
            base.append(conditionBase)

        return base, itemSup


# FpGrowth算法本身（Frequent Pattern Growth—-频繁模式增长）
def FpGrowth(database, minSup=3):
    f1, d1 = getFreq(database, minSup)  # 求第一次频繁项集,并返回一个字典存放支持度，且按大到小排序，返回频繁项和存放频繁项支持度的字典
    rootNode = createRootNode()  # 创建根节点
    # print(f1,d1)        #[['a'], ['b'], ['c'], ['d']]      {'a': 4, 'b': 4, 'c': 4, 'd': 3}

    # 第一步建造树
    buildTree(database, rootNode, f1)
    # indexTableHead = {}     #创建线索的表头，一个链表
    indexTableHead = createIndexTableHead(**d1)  # **d1 就是传了个值，给了它一个拷贝，修改函数里面的这个拷贝，不会影响到外面的这个变量的值
    buildIndex(rootNode, indexTableHead)  # 创建线索，用这个表头

    # print('构建线索后，前序遍历如下：')
    # FpNode.checkFirstTree(rootNode)
    # print('构建线索后，后序遍历如下：')
    # FpNode.checkBehindTree(rootNode)

    freAll = []  # 所有频繁项集
    freAllDic = {}  # 所有频繁项集的支持度

    # 第二步    进行频繁项集的挖掘，从表头header的最后一项开始。
    for commonId in f1[-1::-1]:  # 倒叙 从支持度小的到支持度大的，进行挖掘
        idK = str(commonId[0])
        newDataK = getNewRecord(idK, **indexTableHead)  # 传入这个表头的一个拷贝， 函数返回挖掘出来的新记录
        fk, dk = getFreq(newDataK, minSup)  # 对新数据集求频繁项集
        # print(fk,dk)
        base, itemSup = getAllConditionBase(newDataK, idK, fk, minSup, **dk)  # 得到当前节点的条件频繁模式集，返回
        # 有可能会发生这样一种情况，条件基是 a ，然后fk，dk为空，结果这个函数又返回了 a，那么最后的结果中，就会出现 a，a  这种情况，处理方法请往下看

        # print(base，idK)
        for i in base:
            # print(i)
            t = list(i)
            t.append(idK)
            t = set(t)  # 为了防止出现 重复 的情况，因为我的getAllConditionBase(newDataK, idK, fk, minSup, **dk)方法的编写，可能会形成重复，如   a，a
            t = list(t)

            freAll.append(t)
            itemSupValue = list(itemSup.values())[0]

            x = tuple(t)  # 列表不能做字典的关键字，因为他可变，，而元组可以
            # <class 'list'>: ['c', 'd']
            # print(t[0])     # t是列表，字典的关键字不能是可变的列表， 所以用 t[0] 来取出里面的值
            freAllDic[x] = min(itemSupValue, d1[idK])
    # print(freAll)
    # print(freAllDic)

    return freAll, freAllDic


if __name__ == '__main__':
    n = int(input("共有几组数据？"))
    testList = [[] for i in range(n)]
    for i in range(n):
        testList[i] = list(map(str, input().split(' ')))  # 装入数据 二维列表
    print("原始数据：", testList)

    freAll, freAllDic = FpGrowth(testList, minSup=3)  # 设置最小支持度为3

    print("频繁项集", freAll)
    print("各个频繁项集的支持度依次为：")
    for i in freAllDic.keys():
        print(i, ":", freAllDic[i])

3、两种算法比较

在以下情况下，FP-growth算法比Apriori算法好：
①数据量大。因为Apriori算法需要生成大量的候选项集，并对每个候选项集进行频繁项集的计数，这会消耗大量的时间和内存，而FP-growth算法通过构建FP树，将数据集压缩成了一个紧凑的数据结构，大大减少了存储空间和计算时间的开销。
②数据分布不均匀。因为Apriori算法在生成候选项集时，需要遍历数据集多次，对于数据分布不均匀的情况，频繁项集的计算会受到影响。而FP-growth算法通过构建FP树，将频繁项集的计算转化为对FP树的遍历，不受数据分布的影响。
③最小支持度阈值较低。因为Apriori算法在生成候选项集时，需要对每个候选项集进行频繁项集的计数，当最小支持度阈值较低时，需要计算大量的候选项集，导致计算时间较长。而FP-growth算法通过构建FP树，只需要遍历一次数据集，计算频繁项集，所以FP-growth算法更快速。