基于FP树的频繁项挖掘 | 工业数据分析 | 冰水数据智能

1 FP树

FP 表示的是频繁模式，其通过链接来连接相似元素，被连起来的元素可以看成是一个链表。将事务数据表中的各个事务对应的数据项按照支持度排序后，把每个事务中的数据项按降序依次插入到一棵以 NULL 为根节点的树中，同时在每个结点处记录该结点出现的支持度。 FP-growth 算法的流程为：首先构造 FP 树，然后利用它来挖掘频繁项集。在构造 FP 树时，需要对数据集扫描两边，第一遍扫描用来统计频率，第二遍扫描至考虑频繁项集。

2 构建FP树

在第二次扫描数据集时会构建一棵 FP 树，并采用一个容器来保存树。

首先创建一个类来保存树的每一个节点，代码如下：

#coding:utf-8 from numpy import *

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) ''' #test

rootNode = treeNode('pyramid',9,None)

rootNode.children['eye'] = treeNode('eye',13,None) a = rootNode.disp() print a '''

这样，FP 树对应的数据结构就建好了，现在就可以构建 FP 树了，FP 树的构建函数如下: #FP 构建函数

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 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 = 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:            

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]] = treeNode(items[0], count, inTree)    

if headerTable[items[0]][1] == 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 != None):      

  nodeToTest = nodeToTest.nodeLink  

 nodeToTest.nodeLink = targetNode

在运行上例之前还需要一个真正的数据集，结合之前的数据自定义数据集：

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

 运行：

 #test

simpDat = loadSimpDat() initSet  = createInitSet(simpDat)

myFPtree,myHeaderTab = createTree(initSet,3) a = myFPtree.disp() print a

这样就构建了 FP 树，接下来就是使用它来进行频繁项集的挖掘。

3 频繁项挖掘

在构建了 FP 树之后，就可以抽取频繁项集了，这里的思想和 Apriori 算法大致类似，首先从元素项集合开始，然后在此基础上逐步构建更大的集合。大致分为三个步骤：

（1）从 FP 树中获得条件模式基；

（2）利用条件模式基，构建一个条件 FP 树；

（3）迭代重复（1）和（2），直到树包含一个元素项为止。

首先，获取条件模式基。条件模式基是以所查找元素项为结尾的路径集合，表示的是所查找的元素项与树根节点之间的所有内容。结合构建FP树绘制的图，r的前缀路径就是{x,s}、 {z,x,y}和{z},其中的每条前缀路径都与一个计数值有关，该计数值表示的是每条路径上r的数目。

为了得到这些前缀路径，结合之前所得到的头指针表，头指针表中包含相同类型元素链表的起始指针，根据每一个元素项都可以上溯到这棵树直到根节点为止。该过程对应的代码如下：

def ascendTree(leafNode, prefixPath): #ascends from leaf node to root    

if leafNode.parent != None:        

prefixPath.append(leafNode.name)      

 ascendTree(leafNode.parent, prefixPath)    

 def findPrefixPath(basePat, treeNode): #treeNode comes from header table     condPats = {}    

while treeNode != None:      

 prefixPath = []        

ascendTree(treeNode, prefixPath)      

  if len(prefixPath) > 1:          

  condPats[frozenset(prefixPath[1:])] = treeNode.count      

  treeNode = treeNode.nodeLink    

return condPats

#test simpDat = loadSimpDat() initSet  = createInitSet(simpDat)

myFPtree,myHeaderTab = createTree(initSet,3) a = myFPtree.disp() b = findPrefixPath('x',myHeaderTab['x'][1]) print b

运行代码，与所给数据一致。接下来就可以创建条件 FP 树了。对于每一个频繁项，都需要创建一棵条件 FP 树，使用刚才创建的条件模式基作为输入，采用相同的建树代码来构建树，相应的递归发现频繁项、发现条件模式基和另外的条件树。对应的递归查找频繁项集的函数如下：

def mineTree(inTree, headerTable, minSup, preFix, freqItemList):    

bigL = [v[0]

for v in sorted(headerTable.items(), key=lambda p: p[1])]#(sort header table)    

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 != None:                    

mineTree(myCondTree, myHead, minSup, newFreqSet, freqItemList)

结合之前的数据验证发现无误。

基于FP树的频繁项挖掘 | 工业数据分析 | 冰水数据智能 | 5th