数据挖掘 fp-growth 算法频繁模式挖掘

最新推荐文章于 2024-04-07 10:40:38 发布

yonggeno1

最新推荐文章于 2024-04-07 10:40:38 发布

阅读量3.1k

点赞数

分类专栏： python 文章标签： python 数据挖掘频繁模式挖掘频繁项集

本文链接：https://blog.csdn.net/yonggeno1/article/details/15174279

版权

python 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

FP的全称是Frequent Pattern，在算法中使用了一种称为频繁模式树（Frequent Pattern Tree）的数据结构。FP-tree是一种特殊的前缀树，由频繁项头表和项前缀树构成。FP-Growth算法基于以上的结构加快整个挖掘过程。

1 算法背景

提出背景

众所周知，Apriori算法 [1] 在产生频繁模式完全集前需要对数据库进行多次扫描，同时产生大量的候选频繁集，这就使Apriori算法时间和空间复杂度较大。但是Apriori算法中有一个很重要的性质：频繁项集的所有非空子集都必须也是频繁的。但是Apriori算法在挖掘额长频繁模式的时候性能往往低下，Jiawei Han提出了FP-Growth算法 [2] 。

预备知识

FP-Tree：将事务数据表中的各个事务数据项按照支持度排序后，把每个事务中的数据项按降序依次插入到一棵以 NULL为根结点的树中，同时在每个结点处记录该结点出现的支持度。

条件模式基：包含FP-Tree中与后缀模式一起出现的前缀路径的集合

条件树：将条件模式基按照FP-Tree的构造原则形成的一个新的FP-Tree

2 算法思想

基本思路：不断地迭代FP-tree [4] 的构造和投影过程

算法描述如下：

1、对于每个频繁项，构造它的条件投影数据库和投影FP-tree。

2、对每个新构建的FP-tree重复这个过程，直到构造的新FP-tree为空，或者只包含一条路径。

3、当构造的FP-tree为空时，其前缀即为频繁模式；当只包含一条路径时，通过枚举所有可能组合并与此树的前缀连接即可得到频繁模式。

3 算法描述

构造FP-Tree

挖掘频繁模式前首先要构造FP-Tree，算法为码如下：

输入:一个交易数据库DB和一个最小支持度threshold.

输出:它的FP-tree.

步骤:

1.扫描数据库DB一遍.得到频繁项的集合F和每个频繁项的支持度.把F按支持度递降排序,结果记为L.

2.创建FP-tree的根节点,记为T,并且标记为’null’.然后对DB中的每个事务Trans做如下的步骤.

根据L中的顺序,选出并排序Trans中的事务项.把Trans中排好序的事务项列表记为[p|P],其中p是第一个元素,P是列表的剩余部分.调用insert_tree([p|P],T).

函数insert_tree([p|P],T)的运行如下.

如果T有一个子结点N,其中N.item-name=p.item-name,则将N的count域值增加1;否则,创建一个新节点N,使它的count为1,使它的父节点为T,并且使它的node_link和那些具有相同item_name域串起来.如果P非空,则递归调用insert_tree(P,N).

注：构造FP-Tree的算法理解上相对简单，所以不过多描述

挖掘频繁模式

对FP-Tree进行挖掘，算法如下：

输入:一棵用算法一建立的树Tree

输出:所有的频繁集

步骤:

调用FP-growth(Tree,null).

procedure FP-Growth ( Tree, x)

{

(1) if (Tree只包含单路径P) then

(2) 对路径P中节点的每个组合（记为B）

(3) 生成模式B并x，支持数=B中所有节点的最小支持度

(4) else 对Tree头上的每个ai， do

{

(5) 生成模式B= ai 并 x，支持度=ai.support；

(6) 构造B的条件模式库和B的条件FP树TreeB；

(7) if TreeB != 空集

(8) then call FP-Growth ( TreeB , B )

}

4 演示图

下图给出了整个算法的演示过程：

FP-Growth算法实例演示图(3张)

使用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)

def createTree(dataSet, minSup=1): #create FP-tree from dataset but don't mine
    headerTable = {}
    #go over dataSet twice
    for trans in dataSet:#first pass counts frequency of occurance
        for item in trans:
            headerTable[item] = headerTable.get(item, 0) + dataSet[trans]
    for k in headerTable.keys():  #remove items not meeting minSup
        if headerTable[k] < minSup:
            del(headerTable[k])
    freqItemSet = set(headerTable.keys())
    #print 'freqItemSet: ',freqItemSet
    if len(freqItemSet) == 0: return None, None  #if no items meet min support -->get out
    for k in headerTable:
        headerTable[k] = [headerTable[k], None] #reformat headerTable to use Node link
    #print 'headerTable: ',headerTable
    retTree = treeNode('Null Set', 1, None) #create tree
    for tranSet, count in dataSet.items():  #go through dataset 2nd time
        localD = {}
        for item in tranSet:  #put transaction items in order
            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)#populate tree with ordered freq itemset
    return retTree, headerTable #return tree and header table

def updateTree(items, inTree, headerTable, count):
    if items[0] in inTree.children:#check if orderedItems[0] in retTree.children
        inTree.children[items[0]].inc(count) #incrament count
    else:   #add items[0] to inTree.children
        inTree.children[items[0]] = treeNode(items[0], count, inTree)
        if headerTable[items[0]][1] == None: #update header table
            headerTable[items[0]][1] = inTree.children[items[0]]
        else:
            updateHeader(headerTable[items[0]][1], inTree.children[items[0]])
    if len(items) > 1:#call updateTree() with remaining ordered items
        updateTree(items[1::], inTree.children[items[0]], headerTable, count)

def updateHeader(nodeToTest, targetNode):   #this version does not use recursion
    while (nodeToTest.nodeLink != None):    #Do not use recursion to traverse a linked list!
        nodeToTest = nodeToTest.nodeLink
    nodeToTest.nodeLink = targetNode

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

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:  #start from bottom of header table
        newFreqSet = preFix.copy()
        newFreqSet.add(basePat)
        #print 'finalFrequent Item: ',newFreqSet    #append to set
        freqItemList.append(newFreqSet)
        condPattBases = findPrefixPath(basePat, headerTable[basePat][1])
        #print 'condPattBases :',basePat, condPattBases
        #2. construct cond FP-tree from cond. pattern base
        myCondTree, myHead = createTree(condPattBases, minSup)
        #print 'head from conditional tree: ', myHead
        if myHead != None: #3. mine cond. FP-tree
            print 'conditional tree for: ',newFreqSet
            myCondTree.disp(1)
            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




def main():
    simpDat=loadSimpDat()
    #print simpDat
    initSet=createInitSet(simpDat)
   # print initSet
    myFPtree,myHeaderTab=createTree(initSet,3)
    #myFPtree.disp()
    a=findPrefixPath('x',myHeaderTab['x'][1])
    b=findPrefixPath('z',myHeaderTab['z'][1])

    c=findPrefixPath('r',myHeaderTab['r'][1])
    #print a,b,c
    freqItem=[]
    mineTree(myFPtree,myHeaderTab,3,set([]),freqItem)


if __name__ == '__main__':
    main()

yonggeno1

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
数据挖掘 fp-growth 算法频繁模式挖掘

class treeNode: def __init__(self, nameValue, numOccur, parentNode): self.name = nameValue self.count = numOccur self.nodeLink = None self.parent = parentNode
复制链接

扫一扫