使用FP-growth算法来高效发现频繁项集
FP-growth算法基于Apriori构建，但采用了高级的数据结构减少扫描次数，大大加快了算法速度。FP-growth算法只需要对数据库进行两次扫描，而Apriori算法对于每个潜在的频繁项集都会扫描数据集判定给定模式是否频繁，因此FP-growth算法的速度要比Apriori算法快。
FP-growth算法发现频繁项集的基本过程如下：
- 构建FP树
- 从FP树中挖掘频繁项集
FP-growth算法
- 优点：一般要快于Apriori。
- 缺点：实现比较困难，在某些数据集上性能会下降。
- 适用数据类型：离散型数据。
1.1 FP树：用于编码数据集的有效方式
FP-growth算法将数据存储在一种称为FP树的紧凑数据结构中。FP代表频繁模式（Frequent Pattern）。一棵FP树看上去与计算机科学中的其他树结构类似，但是它通过链接（link）来连接相似元素，被连起来的元素项可以看成一个链表。图5给出了FP树的一个例子。
图5 一棵FP树，和一般的树结构类似，包含着连接相似节点（值相同的节点）的连接
与搜索树不同的是，一个元素项可以在一棵FP树种出现多次。FP树辉存储项集的出现频率，而每个项集会以路径的方式存储在数中。存在相似元素的集合会共享树的一部分。只有当集合之间完全不同时，树才会分叉。 树节点上给出集合中的单个元素及其在序列中的出现次数，路径会给出该序列的出现次数。
相似项之间的链接称为节点链接（node link），用于快速发现相似项的位置。
举例说明，下表用来产生图5的FP树：
| 事务ID | 事务中的元素项 |
| 001 | r, z, h, j, p |
| 002 | z, y, x, w, v, u, t, s |
| 003 | z |
| 004 | r, x, n, o, s |
| 005 | y, r, x, z, q, t, p |
| 006 | y, z, x, e, q, s, t, m |
对FP树的解读：
图5中，元素项z出现了5次，集合{r, z}出现了1次。于是可以得出结论：z一定是自己本身或者和其他符号一起出现了4次。集合{t, s, y, x, z}出现了2次，集合{t, r, y, x, z}出现了1次，z本身单独出现1次。就像这样，FP树的解读方式是读取某个节点开始到根节点的路径。路径上的元素构成一个频繁项集，开始节点的值表示这个项集的支持度。根据图5，我们可以快速读出项集{z}的支持度为5、项集{t, s, y, x, z}的支持度为2、项集{r, y, x, z}的支持度为1、项集{r, s, x}的支持度为1。FP树中会多次出现相同的元素项，也是因为同一个元素项会存在于多条路径，构成多个频繁项集。但是频繁项集的共享路径是会合并的，如图中的{t, s, y, x, z}和{t, r, y, x, z}
和之前一样，我们取一个最小阈值，出现次数低于最小阈值的元素项将被直接忽略。图5中将最小支持度设为3，所以q和p没有在FP中出现。
FP-growth算法的工作流程如下。首先构建FP树，然后利用它来挖掘频繁项集。为构建FP树，需要对原始数据集扫描两遍。第一遍对所有元素项的出现次数进行计数。数据库的第一遍扫描用来统计出现的频率，而第二遍扫描中只考虑那些频繁元素。
1.2 构建FP树
1 创建FP树的数据结构
由于树节点的结构比较复杂，我们使用一个类表示。
'''
每个树节点由五个数据项组成：
name：节点元素名称，在构造时初始化为给定值
count：出现次数，在构造时初始化为给定值
nodeLink：指向下一个相似节点的指针，默认为None
parent：指向父节点的指针，在构造时初始化为给定值
children：指向子节点的字典，以子节点的元素名称为键，指向子节点的指针为值，初始化为空字典
成员函数：
inc()：增加节点的出现次数值
disp()：输出当前节点和子节点的FP树结构
'''
class treeNode:
def __init__(self, nameValue, numOccur, parentNode):
self.name = nameValue
self.count = numOccur
self.nodeLink = None
self.parent = parentNode # needs to be updated
self.children = {}
def inc(self, numOccur):
self.count += numOccur
def disp(self, ind=1):
print(' ' *ind, self.name, ' ', self.count)
for child in self.children.values():
child.disp(ind +1)rootNode = treeNode('pyramid', 9, None)
rootNode.children['eye'] = treeNode('eye', 13, None)
rootNode.children['phoenix'] = treeNode('phoenix', 3, None)
rootNode.disp()结果:
pyramid 9
phoenix 3
eye 13
2 构建FP树
头指针表
FP-growth算法还需要一个称为头指针表的数据结构，其实很简单，就是用来记录各个元素项的总出现次数的数组，再附带一个指针指向FP树中该元素项的第一个节点。这样每个元素项都构成一条单链表。图示说明：
图6 带头指针表的FP树，头指针表作为一个起始指针来发现相似元素项
这里使用Python字典作为数据结构，来保存头指针表。以元素项名称为键，保存出现的总次数和一个指向第一个相似元素项的指针。
第一次遍历数据集会获得每个元素项的出现频率，去掉不满足最小支持度的元素项，生成这个头指针表。
元素项排序
上文提到过，FP树会合并相同的频繁项集（或相同的部分）。因此为判断两个项集的相似程度需要对项集中的元素进行排序（不过原因也不仅如此，还有其它好处）。排序基于元素项的绝对出现频率（总的出现次数）来进行。在第二次遍历数据集时，会读入每个项集（读取），去掉不满足最小支持度的元素项（过滤），然后对元素进行排序（重排序）。
对示例数据集进行过滤和重排序的结果如下：
| 事务ID | 事务中的元素项 | 过滤及重排序后的事务 |
| 001 | r, z, h, j, p | z, r |
| 002 | z, y, x, w, v, u, t, s | z, x, y, s, t |
| 003 | z | z |
| 004 | r, x, n, o, s | x, s, r |
| 005 | y, r, x, z, q, t, p | z, x, y, r, t |
| 006 | y, z, x, e, q, s, t, m | z, x, y, s, t |
构建FP树
在对事务记录过滤和排序之后，就可以构建FP树了。从空集开始，将过滤和重排序后的频繁项集一次添加到树中。如果树中已存在现有元素，则增加现有元素的值；如果现有元素不存在，则向树添加一个分支。对前两条事务进行添加的过程：
图7 FP树构建过程示意（添加前两条事务）
算法：构建FP树
输入：数据集、最小值尺度
输出：FP树、头指针表
1. 遍历数据集，统计各元素项出现次数，创建头指针表
2. 移除头指针表中不满足最小值尺度的元素项
3. 第二次遍历数据集，创建FP树。对每个数据集中的项集：
3.1 初始化空FP树
3.2 对每个项集进行过滤和重排序
3.3 使用这个项集更新FP树，从FP树的根节点开始：
3.3.1 如果当前项集的第一个元素项存在于FP树当前节点的子节点中，则更新这个子节点的计数值
3.3.2 否则，创建新的子节点，更新头指针表
3.3.3 对当前项集的其余元素项和当前元素项的对应子节点递归3.3的过程
# 返回一个事物列表
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): # 把每条事务记录由列表转换为frozenset类型，并且其键对应的值为1
retDict = {}
for trans in dataSet:
retDict[frozenset(trans)] = 1
return retDict
# 更新头指针表
def updateHeader(nodeToTest, targetNode): # nodeToTest是节点对象,targetNode也是节点对象
'''
:param nodeToTest: 理解为当前元素的头指针
:param targetNode: 要插入的元素
:return:
'''
while (nodeToTest.nodeLink != None):
nodeToTest = nodeToTest.nodeLink
nodeToTest.nodeLink = targetNode
# 更新树
def updateTree(items, inTree, headerTable, count):
'''
:param items: 数据集中的每一个列表进行循环
:param inTree: 树的链表
:param headerTable: 头指针的集合
:param count: 当前数据集的含有一个 默认为1
:return:
'''
if items[0] in inTree.children: # 事务中的第一个元素是否作为子节点存在
inTree.children[items[0]].inc(count) # 如果存在则更新该元素项的计数
else: # 如果不存在则将其作为一个子节点添加到树中
inTree.children[items[0]] = treeNode(items[0], count, inTree) # inTree是父节点，count=1，item[0]是节点名
inTree.disp()
if headerTable[items[0]][1] == None: # [items[0]][1]是第一个键的值(列表)的第二个元素
headerTable[items[0]][1] = inTree.children[items[0]] # 把节点对象赋给headerTable的[items[0]][1]
else: # 头指针表也要更新以指向新的节点
updateHeader(headerTable[items[0]][1], inTree.children[items[0]])
if len(items) > 1: # inTree.children[items[0]]头指针表也要指向新的节点
updateTree(items[1::], inTree.children[items[0]], headerTable, count)
'''
dataSet: 数据
minSup: 相当于支持度理解，这里是个数
'''
def createTree(dataSet, minSup=1): #create FP-tree from dataset but don't mine
'''
:param dataSet: 数据
:param minSup: 相当于支持度理解，这里是个数
:return: retTree: 树的链表 ,headerTable: 每一个元素的头指针集合，指向树中的元素
'''
''' 创建FP树 '''
# 第一次遍历数据集，创建头指针表
headerTable = {} #计算所有元素出现的次数
for trans in dataSet:
for item in trans:
#print(headerTable.get(item, 0))
#print(dataSet[trans])
headerTable[item] = headerTable.get(item, 0) + dataSet[trans] # dataSet[trans] = 1 好傻逼的写法
#print(headerTable[item])
#{'v': 1, 't': 3, 's': 3, 'e': 1, 'j': 1, 'x': 4, 'p': 2, 'w': 1, 'q': 2, 'r': 3, 'z': 5, 'u': 1, 'n': 1, 'm': 1, 'y': 3, 'o': 1, 'h': 1}
#移除不满足最小支持度的元素项
for key in list(headerTable.keys()):
if headerTable[key] < minSup:
del(headerTable[key])
# 空元素集，返回空
freqItemSet = set(headerTable.keys())
if len(freqItemSet) == 0:
return None, None
for k in headerTable: # 遍历过滤后的头指针表
headerTable[k] = [headerTable[k], None] # 每个项(字典键)的值是[计数值，元素项指针]
retTree = treeNode('Null Set', 1, None) # 创建根节点
print('大话')
for tranSet, count in dataSet.items():
#print(tranSet, count)
localD = {} # 对一个项集tranSet，记录其中每个元素项的全局频率，用于排序
for item in tranSet:
print(item)
if item in freqItemSet:
localD[item] = headerTable[item][0] # 注意这个[0]，因为之前加过一个数据项
print(localD)
if len(localD) > 0:
orderedItems = [v[0] for v in sorted(localD.items(), key=lambda p: p[1], reverse=True)] # 排序
print(orderedItems)
updateTree(orderedItems, retTree, headerTable, count) # 更新FP树
return retTree, headerTablece测试:
simpDat = loadSimpDat()
initSet = createInitSet(simpDat)
print(initSet)
myFPtree, myHeaderTab = createTree(initSet, 3)
print(myFPtree.disp())1.3 从一棵FP树种挖掘频繁项集
到现在为止大部分比较困难的工作已经处理完了。有了FP树之后，就可以抽取频繁项集了。这里的思路与Apriori算法大致类似，首先从单元素项集合开始，然后在此基础上逐步构建更大的集合。
从FP树中抽取频繁项集的三个基本步骤如下：
- 从FP树中获得条件模式基；
- 利用条件模式基，构建一个条件FP树；
- 迭代重复步骤1步骤2，直到树包含一个元素项为止。
1 抽取条件模式基
（这个翻译是什么鬼……英文是conditional pattern base）
首先从头指针表中的每个频繁元素项开始，对每个元素项，获得其对应的条件模式基（conditional pattern base）。条件模式基是以所查找元素项为结尾的路径集合。每一条路径其实都是一条前缀路径（prefix path）。简而言之，一条前缀路径是介于所查找元素项与树根节点之间的所有内容。
将图5重新贴在这里：
则每一个频繁元素项的所有前缀路径（条件模式基）为：
| 频繁项 | 前缀路径 |
| z | {}: 5 |
| r | {x, s}: 1, {z, x, y}: 1, {z}: 1 |
| x | {z}: 3, {}: 1 |
| y | {z, x}: 3 |
| s | {z, x, y}: 2, {x}: 1 |
| t | {z, x, y, s}: 2, {z, x, y, r}: 1 |
发现规律了吗，z存在于路径{z}中，因此前缀路径为空，另添加一项该路径中z节点的计数值5构成其条件模式基；r存在于路径{r, z}、{r, y, x, z}、{r, s, x}中，分别获得前缀路径{z}、{y, x, z}、{s, x}，另添加对应路径中r节点的计数值（均为1）构成r的条件模式基；以此类推。
前缀路径将在下一步中用于构建条件FP树，暂时先不考虑。如何发现某个频繁元素项的所在的路径？利用先前创建的头指针表和FP树中的相似元素节点指针，我们已经有了每个元素对应的单链表，因而可以直接获取。
下面的程序给出了创建前缀路径的代码：
def findPrefixPath(basePat, treeNode): # treeNode comes from header table
'''
:param basePat: 这个元素在其中没有使用，很困惑
:param treeNode: 数中某一个节点
:return: 某一个元素的前缀
'''
condPats = {}
while treeNode != None:
prefixPath = []
ascendTree(treeNode, prefixPath)
if len(prefixPath) > 1:
#取除查找元素的本身
condPats[frozenset(prefixPath[1:])] = treeNode.count
treeNode = treeNode.nodeLink
return condPats该函数代码用于为给定元素项生成一个条件模式基（前缀路径），这通过访问树中所有包含给定元素项的节点来完成。参数basePet表示输入的频繁项，treeNode为当前FP树种对应的第一个节点（可在函数外部通过headerTable[basePat][1]获取）。函数返回值即为条件模式基condPats，用一个字典表示，键为前缀路径，值为计数值。
辅助函数：ascendTree
def ascendTree(leafNode, prefixPath): # ascends from leaf node to root
'''
:param leafNode: 需要自己理解下，树中的某一个节点
:param prefixPath: 前缀列表
:return:
'''
if leafNode.parent != None:
prefixPath.append(leafNode.name)
ascendTree(leafNode.parent, prefixPath)这个函数直接修改prefixPath的值，将当前节点leafNode添加到prefixPath的末尾，然后递归添加其父节点。最终结果，prefixPath就是一条从treeNode（包括treeNode）到根节点（不包括根节点）的路径。在主函数findPrefixPath()中再取prefixPath[1:]，即为treeNode的前缀路径。
测试:
findPrefixPath('x', myHeaderTab['x'][1])
findPrefixPath('z', myHeaderTab['z'][1])
findPrefixPath('r', myHeaderTab['r'][1])2 创建条件FP树
对于每一个频繁项，都要创建一棵条件FP树。可以使用刚才发现的条件模式基作为输入数据，并通过相同的建树代码来构建这些树。例如，对于r，即以“{x, s}: 1, {z, x, y}: 1, {z}: 1”为输入，调用函数createTree()获得r的条件FP树；对于t，输入是对应的条件模式基“{z, x, y, s}: 2, {z, x, y, r}: 1”。
代码（直接调用createTree()函数）：
|
1
2
|
condPattBases
=
findPrefixPath(basePat, headerTable[basePat][
1
])
myCondTree, myHead
=
createTree(condPattBases, minSup)
|
示例：t的条件FP树
图8 t的条件FP树的创建过程
在图8中，注意到元素项s以及r是条件模式基的一部分，但是它们并不属于条件FP树。因为在当前的输入中，s和r不满足最小支持度的条件。
3 递归查找频繁项集
有了FP树和条件FP树，我们就可以在前两步的基础上递归得查找频繁项集。
递归的过程是这样的：
输入：我们有当前数据集的FP树（inTree，headerTable）
1. 初始化一个空列表preFix表示前缀
2. 初始化一个空列表freqItemList接收生成的频繁项集（作为输出）
3. 对headerTable中的每个元素basePat（按计数值由小到大），递归：
3.1 记basePat + preFix为当前频繁项集newFreqSet
3.2 将newFreqSet添加到freqItemList中
3.3 计算t的条件FP树（myCondTree、myHead）
3.4 当条件FP树不为空时，继续下一步；否则退出递归
3.4 以myCondTree、myHead为新的输入，以newFreqSet为新的preFix，外加freqItemList，递归这个过程
函数如下：
def mineTree(inTree, headerTable, minSup, preFix, freqItemList) :
'''
:param inTree: 相当于是树的链表
:param headerTable: 数每一个元素的所有次数的集合链表 ['x', [次数,下一个元素的指针],[],[]]
:param minSup: 最小的支持度
:param preFix: 每一个元素的前缀 初始化为null
:param freqItemList: 支持度大于等于3的，所有元素
:return: 无 数据存储在freqItemList中
'''
'''
-----------------
('t', [3, <__main__.treeNode object at 0x7f466bae1ef0>])
('y', [3, <__main__.treeNode object at 0x7f466bae1f60>])
('x', [4, <__main__.treeNode object at 0x7f466bae1eb8>])
('r', [3, <__main__.treeNode object at 0x7f466bae1e80>])
('z', [5, <__main__.treeNode object at 0x7f466bae1e48>])
('s', [3, <__main__.treeNode object at 0x7f466bae1f98>])
-----------------
'''
# 对头指针表中元素项按照其出现频率进行排序，默认是从小到大
bigL = [ v[0] for v in sorted(headerTable.items(), key=lambda p:str(p[1])) ]
# 默认是从小到大，下面过程是从头指针的底端开始
for basePat in bigL :
newFreqSet = preFix.copy()
newFreqSet.add(basePat)
# 将每个频繁项添加到频繁项集列表freqItemList中
freqItemList.append(newFreqSet)
# 使用findPrefixPath()创建条件基
condPattBases = findPrefixPath(basePat, headerTable[basePat][1])
# 将条件基condPattBases作为新数据集传递给createTree()函数
# 这里为函数createTree()添加足够的灵活性，确保它可以被重用于构建条件树
myCondTree, myHead = createTree(condPattBases, minSup)
# 如果树中有元素项的话，递归调用mineTree()函数
if myHead != None :
print('conditional tree for: ', newFreqSet)
myCondTree.disp()
mineTree(myCondTree, myHead, minSup, newFreqSet, freqItemList)
输入参数：
- inTree和headerTable是由createTree()函数生成的数据集的FP树
- minSup表示最小支持度
- preFix请传入一个空集合（set([])），将在函数中用于保存当前前缀
- freqItemList请传入一个空列表（[]），将用来储存生成的频繁项集
测试代码：
|
1
2
3
|
freqItems
=
[]
mineTree(myFPtree, myHeaderTab,
3
,
set
([]), freqItems)
freqItems
|
[set(['y']), set(['y', 'x']), set(['y', 'z']), set(['y', 'x', 'z']), set(['s']), set(['x', 's']), set(['t']), set(['z', 't']), set(['x', 'z', 't']), set(['y', 'x', 'z', 't']), set(['y', 'z', 't']), set(['x', 't']), set(['y', 'x', 't']), set(['y', 't']), set(['r']), set(['x']), set(['x', 'z']), set(['z'])]
想这一段代码解释清楚比较难，因为中间涉及到很多递归。直接举例说明，我们在这里分解输入myFPtree和myHeaderTab后，“for basePat in bigL:”一行当basePat为’t’时的过程：
图9 mineTree函数解构图（basePat = ‘t’）
图中红色加粗的部分即实际添加到freqItemList中的频繁项集。