FP-growth算法
1.原理
- 相较于Apriori算法，FP-growth算法在发现频繁项集上有更快的速度。
- FP-growth算法将数据存储在FP树的紧凑数据结构中。与搜索树不同的是，一个元素可以在FP树中出现多次。FP树会储存项集的出现频率，每个项集以路径的方式储存在树中，并通过link连接相似元素。
- 构建FP树需要对原始数据集扫描两遍。第一次遍历数据集会获得每个元素项的出现频率，去除不满足最小支持率的元素项。第二次扫描只需要考虑频繁元素构建FP树。构建树时，将每个项集根据元素项的绝对出现频率进行排序，之后读入每个项集并将其添加到已存在的路径中，若该路径不存在则创建新路径。
2.代码
（1）创建FP树
# 用于保存树的节点
class TreeNode:
def __init__(self, nameValue, occurNum, parentNode):
self.name = nameValue # 节点名字
self.count = occurNum # 计数值
self.nodeLink = None # 链接相似的元素
self.parent = parentNode # 当前节点的父节点
self.children = {} # 当前节点的所有子节点
def increase(self, occurNum):
self.count += occurNum # 增加计数值
# 将树以文本形式显示
def display(self, space=1):
print(' ' * space, self.name, " ", self.count)
for child in self.children.values():
child.display(space + 1)
def createTree(dataset, minSup=1):
headerTable = {}
# 遍历整个数据集，对每个项集的每个元素项计数
for trans in dataset:
for item in trans:
"""get()方法返回字典中item对应的值，若找不到则返回0
item出现一次，计数+1"""
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值，以便同时保存每个频繁项的频数和该频繁项第一次出现的节点(将该节点作为指针)
headerTable[k] = [headerTable[k], None]
retTree = TreeNode('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:
# 生成一个按出现频率由大到小排列元素项的列表
"""sorted()函数按照可选参数key进行排序，reverse=True表示从大到小。
lambda函数用于封装简单的过程，冒号后是返回值，下面的过程表示返回y第二维的值
因此按照localD.items()的第二维值(计数值)从大到小排序，排序后返回localD的键，即元素项"""
orderItems = [x[0] for x in sorted(localD.items(), key=lambda y: y[1], reverse=True)]
updateTree(orderItems, retTree, headerTable, count) # 更新FP树
return retTree, headerTable
# 根据每条进行过滤排序后的交易记录构建FP树
def updateTree(items, inTree, headerTable, count):
if items[0] in inTree.children: # 第一个元素项在树的子节点中是否存在
inTree.children[items[0]].increase(count) # 若存在，则该节点的计数值增加count个
else:
inTree.children[items[0]] = TreeNode(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: # 继续对items列表中剩余元素项构建FP树
# items从第二个元素开始切片，后一个冒号表示步长默认为1。后面的元素在前一元素的子节点上进行更新
updateTree(items[1::], inTree.children[items[0]], headerTable, count)
# 更新指针链接
def updateHeader(node, targetNode):
while node.nodeLink is not None: # 指针从开始一直向下，直到链接到末尾的节点
node = node.nodeLink
node.nodeLink = targetNode # 将末尾节点链接到指定节点上
if __name__ == "__main__":
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']]
dict1 = {}
for i in simpdat:
dict1[frozenset(i)] = 1
tree, header=createTree(dict1,minSup=3)
tree.display()
# 结果
>>> Null Set 1
z 5
r 1
x 3
s 2
y 2
t 2
r 1
y 1
t 1
x 1
r 1
s 1
（2） 从构建好的FP树中抽取频繁项集
- 步骤：
（1）在FP树中获得指定项的条件模式基（条件模式基指所查找元素项为结尾的路径集合，即介于所查找元素项与根节点之间的内容）
（2）根据条件模式基，构建条件FP树
（3）重复上面两个步骤，直到树包含一个元素项 - 获得指定项的条件模式基↓↓↓
# 上溯整棵树
def ascendTree(leafNode, prefixPath):
if leafNode.parent is not None: # 若存在父节点
prefixPath.append(leafNode.name) # 将当前节点添加到前缀路径中
ascendTree(leafNode.parent, prefixPath) # 调用自身，直到找到最上层的节点
# 寻找指定项的路径
def findPrefixPath(treeNode):
condPat = {} # 存放条件模式基
while treeNode is not None:
prefixPath = [] # 前缀路径
ascendTree(treeNode, prefixPath) # 追溯到最顶端的节点，并把经过的节点保存在prefixPath中
if len(prefixPath) > 1: # 若存在前缀路径
# 将路径(不包含根节点)与当前节点的计数值保存在字典中
condPat[frozenset(prefixPath[1:])] = treeNode.count
# 根据节点的链接，到下一个相同元素项的节点
treeNode = treeNode.nodeLink
return condPat
if __name__ == "__main__":
tree, header = createTree(dict1, 3)
x = findPrefixPath(header['x'][1])
print(x)
>>> {frozenset({'z'}): 3}- 构建条件FP树：对于每个频繁的元素项以及频繁的元素项的组合构建条件FP树(如：频繁项‘x’可以构建FP树，如果’x’与‘t’的组合也是频繁的，那么需要也对[‘x’,‘t’]构建FP树)
# 创建条件FP树
def mineTree(headerTable, minSupp, preFix, freqItemList):
# 得到按照频率从小到大排序的元素项
bigL = [y[0] for y in sorted(headerTable.items(), key=lambda x: x[1][0])]
for basePatt in bigL: # 遍历所有频繁项
newFreqSet = preFix.copy()
newFreqSet.add(basePatt) # 存放当前频繁项
freqItemList.append(newFreqSet) # 储存所有频繁项(包括组合的频繁项)
condPatBases = findPrefixPath(headerTable[basePatt][1]) # 找到当前频繁项的所有前缀路径
mycondTree, myHead = createTree(condPatBases, minSupp) # 根据前缀路径建立条件FP树
if myHead is not None: # 如果FP树中存在元素项，则显示并继续调用自身
print('conditional tree for:', newFreqSet)
mycondTree.display(space=1)
mineTree(myHead, minSupp, newFreqSet, freqItemList)
if __name__ == "__main__":
freq = []
mineTree(header, 3, set([]), freq)
print('freqItems:', freq)
>>> conditional tree for: {'s'}
Null Set 1
x 3
conditional tree for: {'y'}
Null Set 1
x 3
z 3
conditional tree for: {'y', 'z'}
Null Set 1
x 3
conditional tree for: {'t'}
Null Set 1
y 3
x 3
z 3
……………………省略部分结果
freqItems: [{'r'}, {'s'}, {'s', 'x'}, {'y'}, {'y', 'x'}, {'y', 'z'}, {'y', 'x', 'z'}, {'t'}, {'t', 'y'}, {'t', 'x'}, {'t', 'x', 'y'}, {'t', 'z'}, {'t', 'z', 'y'}, {'t', 'x', 'z'}, {'t', 'x', 'z', 'y'}, {'x'}, {'x', 'z'}, {'z'}]
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
