FP-growth算法

FP-growth算法将数据集存储在一种称作FP树的紧凑数据结构中，然后发现频繁项集或者频繁项对，即常在一块出现的元素项的集合FP树。FP代表频繁模式（Frequent Pattern）。FP树通过链接（link）来连接相似元素，被连起来的元素项可以看成一个链表。

本文代码主要来源于《机器学习实战》书，为了适配python3.6，部分代码做了修改。

FP树的一个例子如下

FP-growth算法虽然能高效地发现频繁项集，但是不能用于发现关联规则。FP-growth算法的执行速度快于Apriori算法，通常性能要好两个数量级以上。

FP-growth算法只需要对数据集扫描两次，它发现频繁项集的过程如下：

• 构建FP树
• 从FP树中挖掘频繁项集

1. 构建FP树

步骤：

1. 扫描数据集，对所有元素项的出现次数进行计数，去掉不满足最小支持度的元素项；

2. 对每个集合进行过滤和排序，过滤是去掉不满足最小支持度的元素项，排序基于元素项的绝对出现频率来进行；

3. 创建只包含空集合的根节点，将过滤和排序后的每个项集依次添加到树中，如果树中已经存在该路径，则增加对应元素上的值。如果该路径不存在，则创建一条新路径。

   带头指针的FP树
   

python代码

class treeNode:
    """FP树的类定义"""
    def __init__(self,nameValue,numOccur,parentNode):
        self.name = nameValue  # 存放节点的名字
        self.count = numOccur  # 计数值
        self.nodeLink = None   # 用于链接相似的元素项
        self.parent = parentNode  # 指向当前节点的父节点
        self.children = {}   # 当前节点的子节点

    def inc(self,numOccur):
        """对count变量增加给定值"""
        self.count += numOccur

    def displayFPTree(self,ind=1):
        """将树以文本形式显示出来"""
        print("  "*ind,self.name,"  ",self.count)
        for child in self.children.values():
            child.displayFPTree(ind+1)

# FP树构建函数
def createTree(dataSet,minsup=1):
    """构建FP树，其中输入的数据集dataSet是字典类型"""
    # 对数据集进行第一次扫描，统计每个元素项出现的频率，将结果存在头指针表中
    headerTable = {}
    for trans in dataSet:
        for item in trans:
            headerTable[item] = headerTable.get(item,0) + dataSet[trans]
    # 去掉头指针表中出现次数小于最小支持度阈值的项
    for item in list(headerTable.keys()):
        if headerTable[item] < minsup:
            del (headerTable[item])
    freqItemSet = set(headerTable.keys())  # 获取频繁项
    # 如果没有元素项满足要求，则退出
    if len(freqItemSet) == 0:
        return None,None

    # 对头指针表进行扩展，以便可以保存计数值和指向每种类型第一个元素项的指针
    for item in headerTable:
        headerTable[item] = [headerTable[item], None]
    # 创建只包含空集合的根节点
    retTree = treeNode('Null Set', 1, None)
    # 对数据集进行第二次扫描，构建FP树
    for trans,count in dataSet.items():
        localD = {}
        # 对该项集进行过滤
        for item in trans:
            if item in freqItemSet: # 仅考虑频繁项
                localD[item] = headerTable[item][0]
        # 对该项集进行排序，按元素的频率来排序,如果两元素在频次相同按字母顺序排序
        if len(localD) > 0:
            # ord() 函数是以一个字符（长度为1的字符串）作为参数，返回对应的十进制ASCII数值，比如：ord('a') 返回97  ord('b') 返回98
            # 如果都是数字 -ord(p[0]) 改为 int(p[0])
            orderedItems = [v[0] for v in sorted(localD.items(), key=lambda p: (p[1], -ord(p[0])), reverse=True)]
            updateTree(orderedItems,retTree,headerTable,count)
    return retTree,headerTable


def updateTree(items,inTree,headerTable,count):
    """更新FP树，让FP树生长"""
    # 判断项集中第一个元素项是否作为子节点存在，如果存在，更新该元素项的计数
    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:
            updateHeadera(headerTable[items[0]][1], inTree.children[items[0]])
    # 不断调用自身函数，每次调用会去掉列表中第一个元素
    if len(items) > 1:
        updateTree(items[1:],inTree.children[items[0]],headerTable,count)

def updateHeadera(nodeToTest,targetNode):
    """确保节点链接指向树中该元素项的每一个实例"""
    # 从头指针表的nodeLink开始，一直沿着nodeLink直到到达链表末尾
    while (nodeToTest.nodeLink != None):
        nodeToTest = nodeToTest.nodeLink
    nodeToTest.nodeLink = targetNode

2. 从一棵FP树中挖掘频繁项集

步骤：

1. 从FP树中获得条件模式基；
2. 利用条件模式基，构建一个条件FP树；
3. 迭代重复步骤1-2，直到树包含一个元素项为止。

抽取条件模式基

条件模式基（conditional pattern base）是以所查询元素项为结尾的路径集合。每条路径其实都是一条前缀路径（prefix path）。总之，一条前缀路径是介于所查询元素项与树根节点之间的所有内容。

通过创建的头指针表来得到前缀路径。头指针表包含相同类型元素链表的起始指针。一旦到达了每一个元素项，就可以上溯这棵树直到根节点为止。

例如下图，元素"r"的前缀路径是{z}、{z,x,y}和{x,s}。同时，每一个路径要与起始元素的计数值关联 。

相关python代码如下

# 发现以给定元素项结尾的所有路径函数
def ascendTree(leafNode,prefixPath):
    if leafNode.parent != None:
        prefixPath.append(leafNode.name)
        ascendTree(leafNode.parent,prefixPath)

def findPrefixPath(treeNode):
    condPats = {}
    while treeNode != None:
        prefixPath = []
        ascendTree(treeNode,prefixPath)  # 迭代上溯整棵树
        if len(prefixPath) > 1:
            # 前缀路径对应的计数值
            condPats[frozenset(prefixPath[1:])] = treeNode.count
        treeNode = treeNode.nodeLink
    return condPats

创建条件FP树

对于每一个频繁项，都要创建一棵条件树。上面我们对每一个频繁项提取了条件模式基，现在就用它作为输入数据，即把每一个前缀路径当成一个样本，调用createFPtree()构造一棵FP树，即条件FP树。然后，对这个条件FP树，递归地挖掘。由于createFPtree()中含有过滤的功能，因此最终总能获得所有满足最小支持度的频繁项，即我们所需要的频繁项集。

例如，为频繁项t创建一个条件FP树，然后对{t,x}、{t,y}、…重复该过程。以元素项t的条件FP树的构建过程如下图

# 递归查找频繁项集的mineTree
def mineTree(inTree,headerTable,minsup,preFix,freqItemList):
    # 从头指针表的低端开始
    # headerTable.items():类似[('z', [5, None]），('r', [3,None]]格式，所以按p[1][0]排序
    bigL = [v[0] for v in sorted(headerTable.items(),key=lambda p:p[1][0])]

    for basePat in bigL:
        newFreqSet = preFix.copy()
        newFreqSet.add(basePat)  # set类型的用add方法添加
        freqItemList.append(newFreqSet)
        # 从条件模式基中构建条件FP树
        condPattBase = findPrefixPath(headerTable[basePat][1])
        myCondTree, myHead = createTree(condPattBase,minsup)
        # 挖掘条件FP树
        if myHead != None:
            print('conditional tree for :',newFreqSet)
            myCondTree.displayFPTree()
            mineTree(myCondTree,myHead,minsup,newFreqSet,freqItemList)

实例测试

# 简单数据和数据包装器
def loadData():
    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

dataSet = loadData()
initSet = createInitSet(dataSet)
minsup=3
myFPTree,myheaderTable = createTree(initSet, minsup)
print('构建的FP树：')
myFPTree.displayFPTree()
freqItems = []
print("显示所有的条件树")
mineTree(myFPTree,myheaderTable,minsup,set([]),freqItems)
print('频繁项集：\n',freqItems)

由于对排序部分的脚本进行了修改，满足了“优先按频率排序，如果频率相同，则按字母顺序排序”。所以，下面的运行结果可能与上面画的FP树等不太一样。运行结果如下

频繁项集：
 [{'r'}, {'s'}, {'x', 's'}, {'y'}, {'y', 'z'}, {'y', 'z', 'x'}, {'y', 'z', 'x', 't'}, {'y', 'z', 't'}, {'y', 'x'}, {'y', 'x', 't'}, {'y', 't'}, {'t'}, {'z', 't'}, {'z', 'x', 't'}, {'x', 't'}, {'x'}, {'z', 'x'}, {'z'}]

相关链接

书籍：《机器学习实战》

机器学习实战-FP-growth算法