机器学习--FP-grownth

Apriori算法可以用来发现数据集的频繁项以及关联规则，当发现频繁项时，每计算一个频繁项支持度时，需要计算遍历一遍数据集，当数据集较大时效率不高。

FP-grownth算法：扫描数据集两次，第一次构建FP树，从FP树中挖掘频繁项集。

FP频繁模式(Frequent Pattern)

树节点给出单个元素以及单个元素出现的次数，每个项可以出现多次，项集通过路径给出。从叶子到根为一个项集以及整个项集出现的次数，例如rz出现1次，tsyxz出现两次，z出现5次。

1.定义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)

name元素值  count出现次数   nodeLink连接相似项 parent 指向父节点指针  children叶子结点

2.FP树的构建

头指针表指向第一个实例元素的位置，可以快速访问给定元素类型的所有元素。

遍历数据集统计每个元素项的频率，去掉不满足最小支持度的元素项。读入每一个项集，过滤以及基于绝对出现频率来排序构建事务序列，从空集开始，若已存在现有元素，增加现有元素的值，如果不存在则向树中添加一个分支。

从空集开始，添加zr  z不存在添加一个新分支 计数=1  r也不存在在z之后添加一个新分支计数为1，继续添加zxyst  z已经存在计数加一，xyst依次新建分支添加。

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:
            #dataSet[trans]返回该项集总次数	dataSet字典类型	
            headerTable[item] = headerTable.get(item, 0) + dataSet[trans]
    #过滤掉出现次数小于minSup的项		
    for k in list(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
	#key value
    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

输入dataSet为字典类型 key为项集   value为次数。

首先计算每个项以及出现的次数用字典来保存

for trans in dataSet:#first pass counts frequency of occurance
        for item in trans:
            #dataSet[trans]返回该项集总次数    dataSet字典类型    
            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())

从字典中删除key时，需要转换成list,否则会报错：

修改头指针表  key为项  value为该项第一个出现的位置

新建一个空集

retTree = treeNode('Null Set', 1, None)

开始遍历数据集，取出每一个项集，例如zyxwvuts,如果项出现在频繁项集合中，则记录到localD即 zyxts 

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]

将localD排序为zxyst

orderedItems = [v[0] for v in sorted(localD.items(), key=lambda p: p[1], reverse=True)]

将排序后的事务序列添加进FP树：

updateTree(orderedItems, retTree, headerTable, count)

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)

之前树中已有zr  添加zxyst时，首先判断第一项z是否为上一个节点的子节点，若是则说明该项已经存在，则更新数量

if items[0] in inTree.children:#check if orderedItems[0] in retTree.children
        inTree.children[items[0]].inc(count)

如果不存在则直接新建一个节点

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]]

如果头指针不为空，说明该新增节点不是第一个出现的项节点，则从头指针headerTable[items[0]][1]开始依次遍历找到某个节点nodeLink==Node即该节点是该项出现的最后一个节点，将该节点的nodeLink指向新增节点inTree.children[items[0]]

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

接着继续放入其他项到FP树中xyst

if len(items) > 1:#call updateTree() with remaining ordered items
        updateTree(items[1::], inTree.children[items[0]], headerTable, count)

测试如下： 最小支持度 为3和1时

   

3.FP树中挖掘频繁项集

从FP树中抽取条件模式基，利用条件模式基来构建FP树，不断迭代，直到树中只有一个元素，返回。

条件模式基：以查找元素结尾的路经集合，计数值为起始元素的计数值。

r的条件模式基：  z 1      zxy 1       xs  1

       以头指针表为基准开始遍历，每一个元素开始沿nodeLink开始遍历，直到nodeLink==Node, 在这过程中每遇见一个元素x，则根据parent指针向上回溯，记录过程的所有元素作为x的一个条件模式基。

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

 ascendTree沿某个节点向父节点回溯，保存所有遇见的元素到prefixPath中

findPrefixPath 传入某个头指针表的元素  沿nodeLink往下遍历，没遇见一个元素treeNode,则调用ascendTree来获取该节点的前缀路径，放入到字典中  key为frozenset(prefixPath[1:]  prefixPath[0]为查找节点不需要放入  value为该查找元素的count

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
		#将条件模式基集合作为输入，继续创建FP树
        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)

排序头指针表，遍历每一个元素，返回该元素的条件模式基，利用这些基作为输入继续构建FP树直到树中只有一个元素，此时继续迭代下一个元素。

4.从新闻网站点击流中挖掘

数据格式：

每一行代表用户看过的新闻报道id list  找出至少被10万人看过的新闻报道Id或者报道集合有哪些

d =  [line.split() for line in open('kosarak.dat').readlines()]
s = fpGrowth.createInitSet(d)
t, h = fpGrowth.createTree(s, 100000)
fl = []
fpGrowth.mineTree(t, h, 100000, set([]), fl)

FP-growth可以从大量数据集中快速找到频繁集项。