教你学Python36-使用FP-growth算法来高效发现频繁项集

我们已经介绍了用 Apriori 算法发现 频繁项集 与 关联规则
本章将继续关注发现 频繁项集 这一任务,并使用 FP-growth 算法更有效的挖掘 频繁项集

FP-growth 算法简介

  • 一种非常好的发现频繁项集算法。
  • 基于Apriori算法构建,但是数据结构不同,使用叫做 FP树 的数据结构结构来存储集合。下面我们会介绍这种数据结构。

FP-growth 算法步骤

  • 基于数据构建FP树 
  • 从FP树种挖掘频繁项集 

FP树 介绍

  • FP树的节点结构如下:
class treeNode:
    def __init__(self, nameValue, numOccur, parentNode):
        self.name = nameValue     # 节点名称
        self.count = numOccur     # 节点出现次数
        self.nodeLink = None      # 不同项集的相同项通过nodeLink连接在一起
        # needs to be updated
        self.parent = parentNode  # 指向父节点
        self.children = {}        # 存储叶子节点

FP-growth 原理

基于数据构建FP树

步骤1:

  1. 遍历所有的数据集合,计算所有项的支持度。
  2. 丢弃非频繁的项。
  3. 基于 支持度 降序排序所有的项。
  4. 所有数据集合按照得到的顺序重新整理。
  5. 重新整理完成后,丢弃每个集合末尾非频繁的项。

步骤2:

  1. 读取每个集合插入FP树中,同时用一个头部链表数据结构维护不同集合的相同项。
    最终得到下面这样一棵FP树

从FP树中挖掘出频繁项集

步骤3:

  1. 对头部链表进行降序排序

  2. 对头部链表节点从小到大遍历,得到条件模式基,同时获得一个频繁项集。如上图,从头部链表 t 节点开始遍历,t 节点加入到频繁项集。找到以 t 节点为结尾的路径如下: 去掉FP树中的t节点,得到条件模式基<左边路径,左边是值>[z,x,y,s,t]:2,[z,x,y,r,t]:1 。条件模式基的值取决于末尾节点 t ,因为 t 的出现次数最小,一个频繁项集的支持度由支持度最小的项决定。所以 t 节点的条件模式基的值可以理解为对于以 t 节点为末尾的前缀路径出现次数。

  3. 条件模式基继续构造条件 FP树, 得到频繁项集,和之前的频繁项组合起来,这是一个递归遍历头部链表生成FP树的过程,递归截止条件是生成的FP树的头部链表为空。 根据步骤 2 得到的条件模式基 [z,x,y,s,t]:2,[z,x,y,r,t]:1 作为数据集继续构造出一棵FP树,计算支持度,去除非频繁项,集合按照支持度降序排序,重复上面构造FP树的步骤。最后得到下面 t-条件FP树 : 然后根据 t-条件FP树 的头部链表进行遍历,从 y 开始。得到频繁项集 ty 。然后又得到 y 的条件模式基,构造出 ty的条件FP树,即 ty-条件FP树。继续遍历ty-条件FP树的头部链表,得到频繁项集 tyx,然后又得到频繁项集 tyxz. 然后得到构造tyxz-条件FP树的头部链表是空的,终止遍历。我们得到的频繁项集有 t->ty->tyz->tyzx,这只是一小部分。

  • 条件模式基:头部链表中的某一点的前缀路径组合就是条件模式基,条件模式基的值取决于末尾节点的值。
  • 条件FP树:以条件模式基为数据集构造的FP树叫做条件FP树。

FP-growth 算法优缺点:

* 优点: 1. 因为 FP-growth 算法只需要对数据集遍历两次,所以速度更快。
        2. FP树将集合按照支持度降序排序,不同路径如果有相同前缀路径共用存储空间,使得数据得到了压缩。
        3. 不需要生成候选集。
        4. 比Apriori更快。
* 缺点: 1. FP-Tree第二次遍历会存储很多中间过程的值,会占用很多内存。
        2. 构建FP-Tree是比较昂贵的。
* 适用数据类型:标称型数据(离散型数据)。

FP-growth 代码讲解

main 方法大致步骤:

if __name__ == "__main__":
    simpDat = loadSimpDat()                       #加载数据集。
    initSet = createInitSet(simpDat)              #对数据集进行整理,相同集合进行合并。
    myFPtree, myHeaderTab = createTree(initSet, 3)#创建FP树。
    freqItemList = []
    mineTree(myFPtree, myHeaderTab, 3, set([]), freqItemList) #递归的从FP树中挖掘出频繁项集。
    print freqItemList

大家看懂原理,再仔细跟踪一下代码。基本就没有问题了。

喜欢点下关注,你的关注是我写作的最大支持

以下是使用Python实现FP-growth算法寻找频繁项集的示例代码: ```python class FPTreeNode: def __init__(self, item, count, parent): self.item = item self.count = count self.parent = parent self.children = {} self.nodeLink = None def inc(self, count): self.count += count def disp(self, ind=1): print(' ' * ind, self.item, ' ', self.count) for child in self.children.values(): child.disp(ind + 1) def createTree(dataSet, minSup=1): headerTable = {} for trans in dataSet: for item in trans: headerTable[item] = headerTable.get(item, 0) + dataSet[trans] for k in list(headerTable.keys()): if headerTable[k] < minSup: del (headerTable[k]) freqItemSet = set(headerTable.keys()) if len(freqItemSet) == 0: return None, None for k in headerTable: headerTable[k] = [headerTable[k], None] retTree = FPTreeNode('Null Set', 1, None) for tranSet, count in dataSet.items(): localD = {} for item in tranSet: if item in freqItemSet: localD[item] = headerTable[item][0] if len(localD) > 0: orderedItems = [v[0] for v in sorted(localD.items(), key=lambda p: p[1], reverse=True)] updateTree(orderedItems, retTree, headerTable, count) return retTree, headerTable def updateTree(items, inTree, headerTable, count): if items[0] in inTree.children: inTree.children[items[0]].inc(count) else: inTree.children[items[0]] = FPTreeNode(items[0], count, inTree) if headerTable[items[0]][1] is None: headerTable[items[0]][1] = inTree.children[items[0]] else: updateHeader(headerTable[items[0]][1], inTree.children[items[0]]) if len(items) > 1: updateTree(items[1:], inTree.children[items[0]], headerTable, count) def updateHeader(nodeToTest, targetNode): while nodeToTest.nodeLink is not None: nodeToTest = nodeToTest.nodeLink nodeToTest.nodeLink = targetNode def ascendTree(leafNode, prefixPath): if leafNode.parent is not None: prefixPath.append(leafNode.item) ascendTree(leafNode.parent, prefixPath) def findPrefixPath(basePat, treeNode): condPats = {} while treeNode is not None: prefixPath = [] ascendTree(treeNode, prefixPath) if len(prefixPath) > 1: condPats[frozenset(prefixPath[1:])] = treeNode.count treeNode = treeNode.nodeLink return condPats def mineTree(inTree, headerTable, minSup, preFix, freqItemList): bigL = [v[0] for v in sorted(headerTable.items(), key=lambda p: p[1])] for basePat in bigL: newFreqSet = preFix.copy() newFreqSet.add(basePat) freqItemList.append(newFreqSet) condPattBases = findPrefixPath(basePat, headerTable[basePat][1]) myCondTree, myHead = createTree(condPattBases, minSup) if myHead is not None: mineTree(myCondTree, myHead, minSup, newFreqSet, freqItemList) def loadSimpDat(): simpDat = [['r', 'z', 'h', 'j', 'p'], ['z', 'y', 'x', 'w', 'v', 'u', 't', 's'], ['z'], ['r', 'x', 'n', 'o', 's'], ['y', 'r', 'x', 'z', 'q', 't', 'p'], ['y', 'z', 'x', 'e', 'q', 's', 't', 'm']] return simpDat def createInitSet(dataSet): retDict = {} for trans in dataSet: retDict[frozenset(trans)] = 1 return retDict if __name__ == '__main__': simpDat = loadSimpDat() initSet = createInitSet(simpDat) myFPtree, myHeaderTab = createTree(initSet, 3) freqItems = [] mineTree(myFPtree, myHeaderTab, 3, set([]), freqItems) print(freqItems) ``` 这段代码首先定义了`FPTreeNode`类,表示FP树的节点。`createTree`函数用于创建FP树,它首先统计每个项在所有事务中出现的频率,然后删除不满足最小支持度的项,最后以每个事务中的项作为键,频率作为值,构建FP树。`updateTree`函数用于向FP树中插入新事务。`updateHeader`函数用于更新每个项的链表,方便后续查找。`ascendTree`函数用于回溯FP树,生成条件模式基。`findPrefixPath`函数用于查找指定项的条件模式基。`mineTree`函数用于递归地挖掘FP树,生成频繁项集。`loadSimpDat`函数用于加载测试数据,`createInitSet`函数用于将数据集转换为字典格式。在主程序中,我们使用测试数据集构建FP树,并使用`mineTree`函数挖掘频繁项集
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值