Machine Learning in Action 读书笔记---第12章使用FP-growth算法来高效发现频繁项集

喜欢ヅ旅行 2022-09-08 11:51 98阅读 0赞

# Machine Learning in Action 读书笔记 #

第12章 使用FP-growth算法来高效发现频繁项集

--------------------

### 文章目录 ###

*  Machine Learning in Action 读书笔记
 *  一、FP-growth算法
 *   *  1.FP-growth优缺点
     *  2.FP-growth的一般流程
 *  二、构建FP树
 *   *  1.创建FP树的数据结构
     *  2.构建FP树
 *  三、从FP树中挖掘频繁项集
 *   *  1.抽取条件模式基
     *  2.创建条件FP树
 *  四、全部代码

--------------------

# 一、FP-growth算法 #

**FP**代表频繁模式（**F**requent **P**attern），一颗FP树看起来和其他树结构类似，但是它通过链接（link）来连接相似元素，被连起来的元素项可以看成一个链表。

将数据集存储在一个特定的称作FP树的结构之后发现频繁项集或者频繁项对，即常在一起出现的元素项的集合FP树，该做法的执行速度要快于Apriori算法。

FP-growth算法只需要对数据库进行两次扫描，而Apriori算法对于每个潜在的频繁项集都会扫描数据集判定给定模式是否频繁。为构建FP树，需要对原始数据集扫描两遍：

*  第一遍对所有元素项的出现次数进行计数，用于统计出现的频率
 *  第二遍扫描中只考虑那些频繁元素

小tips:

1.  在FP树中，一个元素项可以在一颗FP树中出现多次。
2.  FP树会存储项集的出现频率，每个项集会以**路径**的方式存储在树中。
3.  存在**相似元素的集合会共享树的一部分**，只有当集合之间完全不同时，树才会分叉。
4.  **树节点上给出集合中的单个元素及其在序列中的出现次数**，**路径会给出该序列的出现次数**。
5.  相似项之间的链接即**节点链接（node link）**，用于快速发现相似项的位置。

## 1.FP-growth优缺点 ##

*  优点：一般要快于Apriori算法
 *  缺点：实现相对困难，在某些数据集上性能会下降
 *  适用数据类型：标称型数据

## 2.FP-growth的一般流程 ##

1.  收集数据：适用任意方法
2.  准备数据：由于存储的是集合，所以需要**离散数据**。如果想要处理连续数据，需要将它们量化为离散值
3.  分析数据：适用任意方法
4.  训练数据：**构建一个FP树，并对树进行挖掘**
5.  测试算法：没有测试过程
6.  使用算法：**可用于识别经常出现的元素项，从而用于制定决策，推荐元素或进行预测等应用中**

FP-growth会扫描数据集两次，发现频繁项集的基本过程如下：

1.  构建FP树
2.  从FP树中挖掘频繁项集

# 二、构建FP树 #

## 1.创建FP树的数据结构 ##

FP树比其他树要复杂，所以要创建一个类来保存树的每个节点

class treeNode:
        def __init__(self, nameValue, numOccur, parentNode):
            self.name = nameValue # 存放节点名字的变量
            self.count = numOccur  # 计数值
            self.nodeLink = None  # 用来链接相似元素项
            self.parent = parentNode # 使用父变量指向当前节点的父节点
            self.children = {
        }   # 用于存放节点的子节点
        # 对count变量增加给定值
        def inc(self, numOccur):
            self.count += numOccur
        # 用于将树以文本形式显示，该操作对于树构建并不必要，但是它对于调试非常有用
        def disp(self, ind=1):
            print(' '*ind, self.name, ' ', self.count)# 使用ind来控制文本的缩进，通过缩进可以判断树节点的层数
            for child in self.children.values():
                child.disp(ind + 1)

## 2.构建FP树 ##

除了FP树以外，还需要一个**头指针表**来指向给定类型的第一个实例，利用头指针表，可以快速访问FP树中一个给定类型的所有元素。使用**字典**作为数据结构，来保存头指针表。除了存放指针外，头指针表还可以用来保存FP树中每类元素的总数。

1.  第一次遍历数据集会**获得每个元素项的出现频率**，**去掉不满足最小支持度的元素项**，然后构建FP树，在构建时，读入每个项集并将其**添加**到一条已经存在的**路径**中，如果该路径不存在，则创建一条新路径。
2.  另外，每个事务就是一个无序集合，\{z,x,y\}和\{y,z,r\}在FP树中为相同项，只表示一次，所以在将集合添加到树之前，需要对每个集合进行**排序**，排序基于元素项的绝对出现频率来进行。
3.  在对事务记录过滤和排序之后，就可以构建FP树了。从空集开始。

'''FP树构建函数'''
    # 创建树
    def createTree(dataSet, minSup=1): #参数：数据集字典、最小支持度
        headerTable = {
        } # 用于存储头指针
        #遍历数据集两次
        for trans in dataSet:#第一遍遍历扫描数据集并统计每个元素项出现的频度，存储到headerTable中
            for item in trans:
                headerTable[item] = headerTable.get(item, 0) + dataSet[trans] # get()方法返回指定键的值，如果指定键不存在，则放回默认值
        for k in list(headerTable.keys()):  #扫描头指针表删掉那些出现次数少于最小可信度的项
            if headerTable[k] < minSup:
                del(headerTable[k])
        # print('headerTable: ',headerTable) # headerTable:  {'z': 5, 'r': 3, 'y': 3, 'x': 4, 't': 3, 's': 3}
        freqItemSet = set(headerTable.keys()) # 频繁项元素
        # print('freqItemSet: ', freqItemSet) # freqItemSet:  {'y', 'x', 't', 's', 'z', 'r'}
        if len(freqItemSet) == 0: return None, None  # 如果所有项都不频繁，就不需要进行下一步处理
        for k in headerTable:
            headerTable[k] = [headerTable[k], None] #格式化headerTable使用节点链接，后一个项相当于一个指针，指向相似项
        # print('headerTable: ',headerTable) # headerTable:  {'z': [5, None], 'r': [3, None], 'y': [3, None], 'x': [4, None], 't': [3, None], 's': [3, None]}
        retTree = treeNode('Null Set', 1, None) # 创建树，值为空集，出现次数为1，无父母节点
        for tranSet, count in dataSet.items():  #第二次扫描数据集
        	# print(tranSet, count) # frozenset({'r', 'z', 'p', 'h', 'j'}) 1
            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 #返回构建的FP树和头指针表
    # 填充树
    def updateTree(items, inTree, headerTable, count):# 排序过的路径集合，当前树，头指针表，在数据集中该路径出现的次数
        if items[0] in inTree.children:#测试事务中的第一个元素项是否作为子节点存在
            inTree.children[items[0]].inc(count)  #如果存在则更新该元素项的计数
        else:   #如果不存在，则创建一个新的treeNode并将其作为一个子节点添加到树中
            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]]) #头指针表也要更新以指向新的节点，调用函数updateHeader更新头指针表
        if len(items) > 1:#对剩下的元素项迭代，每调用一次updateTree就会去掉列表中第一个元素
            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
    # 将列表转换为字典，该字典用于输入到createTree中
    def createInitSet(dataSet):
        retDict = {
        }
        for trans in dataSet:
            retDict[frozenset(trans)] = 1
        return retDict

# 三、从FP树中挖掘频繁项集 #

有了FP树之后就可以抽取频繁项集了。从FP树中抽取频繁项集的三个基本步骤如下：

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

## 1.抽取条件模式基 ##

从上一节已经保存在头指针中的单个频繁元素项开始，**对于每个元素项**，**获得其对应的条件模式基（conditional pattern base）**。**条件模式基是以所查找元素项为结尾的路径集合**，每个路径其实都是一条**前缀路径（prefix path）**。**一条前缀路径是介于所查找元素项和树根节点之间的所有内容**。前缀路径将被用于构建条件FP树。每一条前缀路径都与一个计数值关联，该**计数值等于起始元素项的计数值**，该计数值给了每条路径上该元素项的数目。  
**获得前缀路径**：头指针表包含相同类型元素链表的起始指针。一旦到达了每个元素项，就可以上溯这棵树直到根节点为止。  
发现以给定元素项结尾的所有路径的函数：

'''为给定元素项生成一个条件模式基：发现给定元素项结尾的所有路径的函数'''
    # 每遇到一个元素项目都会调用ascendTree来上溯FP树，并收集所有遇到的元素项的名称
    def ascendTree(leafNode, prefixPath):  # 从叶子节点到根节点上溯，参数：叶子节点，用于存放前缀路径的列表
        if leafNode.parent != None:
            prefixPath.append(leafNode.name)
            ascendTree(leafNode.parent, prefixPath)
    
    # findPrefixPath函数用于遍历列表，直到到达结尾
    def findPrefixPath(basePat, treeNode):  # 树节点来自于头指针表，第一个参数没有用到
        condPats = {
        }
        while treeNode != None:
            prefixPath = []
            ascendTree(treeNode, prefixPath)
            if len(prefixPath) > 1:
                condPats[frozenset(prefixPath[1:])] = treeNode.count # 路径的计数值等于起始元素项的计数值
            treeNode = treeNode.nodeLink
        return condPats #返回条件模式基字典

## 2.创建条件FP树 ##

对于每一个频繁项，都要创建一颗条件FP树。  
递归查找频繁项集的mineTree函数：从

'''递归查找频繁项集的mineTree函数'''
    def mineTree(inTree, headerTable, minSup, preFix, freqItemList):# 创建树的数据集（条件模式基），头指针表，最小支持度，前缀路径，频繁项列表
        bigL = [v[0] for v in sorted(headerTable.items(), key=lambda p: p[1])]#对头指针表中的元素项按照其出现频率进行排序
        for basePat in bigL: # 遍历头指针中的每个频繁项，为每个频繁项创建一颗条件FP树
            newFreqSet = preFix.copy()
            newFreqSet.add(basePat)
            freqItemList.append(newFreqSet) # 将每一个频繁项添加到频繁项集列表freqItemList中
            condPattBases = findPrefixPath(basePat, headerTable[basePat][1]) # 递归调用程序findPrefixPath函数来创建条件基
            myCondTree, myHead = createTree(condPattBases, minSup)  # 从条件模式基来构建条件FP树
            if myHead != None:     # 挖掘条件FP树：如果树中有元素项，递归调用mineTree()函数
                mineTree(myCondTree, myHead, minSup, newFreqSet, freqItemList)

# 四、全部代码 #

'''FP树要比其他树更加复杂，因此需要创建一个类来保存树的每一个节点'''
    class treeNode:
        def __init__(self, nameValue, numOccur, parentNode):
            self.name = nameValue # 存放节点名字的变量
            self.count = numOccur  # 计数值
            self.nodeLink = None  # 用来链接相似元素项
            self.parent = parentNode # 使用父变量指向当前节点的父节点
            self.children = {
        }   # 用于存放节点的子节点
        # 对count变量增加给定值
        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)
    '''FP树构建函数'''
    # 创建树
    def createTree(dataSet, minSup=1): #参数：数据集字典、最小支持度
        headerTable = {
        } # 用于存储头指针
        #遍历数据集两次
        for trans in dataSet:#第一遍遍历扫描数据集并统计每个元素项出现的频度，存储到headerTable中
            for item in trans:
                headerTable[item] = headerTable.get(item, 0) + dataSet[trans] # get()方法返回指定键的值，如果指定键不存在，则放回默认值
        for k in list(headerTable.keys()):  #扫描头指针表删掉那些出现次数少于最小可信度的项
            if headerTable[k] < minSup:
                del(headerTable[k])
        # print('headerTable: ',headerTable) # headerTable:  {'z': 5, 'r': 3, 'y': 3, 'x': 4, 't': 3, 's': 3}
        freqItemSet = set(headerTable.keys()) # 频繁项元素
        # print('freqItemSet: ', freqItemSet) # freqItemSet:  {'y', 'x', 't', 's', 'z', 'r'}
        if len(freqItemSet) == 0: return None, None  # 如果所有项都不频繁，就不需要进行下一步处理
        for k in headerTable:
            headerTable[k] = [headerTable[k], None] #格式化headerTable使用节点链接，后一个项相当于一个指针，指向相似项
        # print('headerTable: ',headerTable) # headerTable:  {'z': [5, None], 'r': [3, None], 'y': [3, None], 'x': [4, None], 't': [3, None], 's': [3, None]}
        retTree = treeNode('Null Set', 1, None) # 创建树
        # print(dataSet.items())
        for tranSet, count in dataSet.items():  #第二次扫描数据集
            # print(tranSet, count) # frozenset({'r', 'z', 'p', 'h', 'j'}) 1
            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 #返回构建的FP树和头指针表
    # 填充树
    def updateTree(items, inTree, headerTable, count): # 排序过的路径集合，当前树，头指针表，在数据集中该路径出现的次数
        if items[0] in inTree.children:#测试事务中的第一个元素项是否作为子节点存在
            inTree.children[items[0]].inc(count)  #如果存在则更新该元素项的计数
        else:   #如果不存在，则创建一个新的treeNode并将其作为一个子节点添加到树中
            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]]) #头指针表也要更新以指向新的节点，调用函数updateHeader更新头指针表
        if len(items) > 1:#对剩下的元素项迭代，每调用一次updateTree就会去掉列表中第一个元素
            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
    # 将列表转换为字典，该字典用于输入到createTree中
    def createInitSet(dataSet):
        retDict = {
        }
        for trans in dataSet:
            retDict[frozenset(trans)] = 1
        return retDict
    
    '''为给定元素项生成一个条件模式基：发现给定元素项结尾的所有路径的函数'''
    # 每遇到一个元素项目都会调用ascendTree来上溯FP树，并收集所有遇到的元素项的名称
    def ascendTree(leafNode, prefixPath):   # 从叶子节点到根节点上溯
        if leafNode.parent != None:
            prefixPath.append(leafNode.name)
            ascendTree(leafNode.parent, prefixPath)
    
    # findPrefixPath函数用于遍历列表，直到到达结尾
    def findPrefixPath(basePat, treeNode):  # 树节点来自于头指针表
        condPats = {
        }
        while treeNode != None:
            prefixPath = []
            ascendTree(treeNode, prefixPath)
            if len(prefixPath) > 1:
                condPats[frozenset(prefixPath[1:])] = treeNode.count
            treeNode = treeNode.nodeLink
        return condPats #返回条件模式基字典
    
    '''递归查找频繁项集的mineTree函数'''
    def mineTree(inTree, headerTable, minSup, preFix, freqItemList):
        bigL = [v[0] for v in sorted(headerTable.items(), key=lambda p: p[1][0])]#对头指针表中的元素项按照其出现频率进行排序; p[1][0]明确指定比较的元素是第一列，如果相等则按照原有顺序排列
        for basePat in bigL:# 遍历头指针中的每个频繁项，为每个频繁项创建一颗条件FP树
            newFreqSet = preFix.copy()
            newFreqSet.add(basePat)
            freqItemList.append(newFreqSet) # 将每一个频繁项添加到频繁项集列表freqItemList中
            condPattBases = findPrefixPath(basePat, headerTable[basePat][1]) # 递归调用程序findPrefixPath函数来创建条件基
            myCondTree, myHead = createTree(condPattBases, minSup)  # 从条件模式基来构建条件FP树
            if myHead != None:     # 挖掘条件FP树：如果树中有元素项，递归调用mineTree()函数
                # print('conditional tree for: ', newFreqSet)
                # myCondTree.disp(1)
                mineTree(myCondTree, myHead, minSup, newFreqSet, freqItemList)
    
    '''访问Twitter python库的代码'''
    import twitter
    from time import sleep
    import re
    
    def getLotsOfTweets(searchStr):
        CONSUMER_KEY = ''
        CONSUMER_SECRET = ''
        ACCESS_TOKEN_KEY = ''
        ACCESS_TOKEN_SECRET = ''
        api = twitter.Api(consumer_key=CONSUMER_KEY, consumer_secret=CONSUMER_SECRET,
                          access_token_key=ACCESS_TOKEN_KEY,
                          access_token_secret=ACCESS_TOKEN_SECRET)
        #you can get 1500 results 15 pages * 100 per page
        resultsPages = []
        for i in range(1,15):
            print("fetching page %d" % i)
            searchResults = api.GetSearch(searchStr, count=100, lang=i)
            resultsPages.append(searchResults)
            sleep(6)
        return resultsPages
    # 文本解析及合成代码
    # textParse函数用于去除任何URL
    def textParse(bigString):
        urlsRemoved = re.sub('(http[s]?:[/][/]|www.)([a-z]|[A-Z]|[0-9]|[/.]|[~])*', '', bigString) #sub(pat, repl):将字符串中的所有pat的匹配项用repl代替
        listOfTokens = re.split(r'\W*', urlsRemoved) #def split(pat, string):根据模式的匹配项来分割字符串
        return [tok.lower() for tok in listOfTokens if len(tok) > 2]
    # 创建FP树，并对其进行挖掘，最后返回所有频繁项集组成的列表
    def mineTweets(tweetArr, minSup=5):
        parsedList = []
        for i in range(14):
            for j in range(100):
                parsedList.append(textParse(tweetArr[i][j].text))
        initSet = createInitSet(parsedList)
        myFPtree, myHeaderTab = createTree(initSet, minSup)
        myFreqList = []
        mineTree(myFPtree, myHeaderTab, minSup, set([]), myFreqList)
        return myFreqList
    
    if __name__ == '__main__':
        rootNode = treeNode('pyramid', 9, None)
        rootNode.children['eye'] = treeNode('eye', 13, None)
        # rootNode.disp()
        rootNode.children['phoenix'] = treeNode('phoenix', 3, None)
        # rootNode.disp()
    
        simpDat = loadSimpDat()
        # print(simpDat)
        initSet = createInitSet(simpDat)
        # print(initSet) # {frozenset({'j', 'h', 'z', 'r', 'p'}): 1, frozenset({'y', 'v', 'w', 'x', 't', 's', 'z', 'u'}): 1, frozenset({'z'}): 1,...
        myFPtree, myHeaderTab = createTree(initSet, 3)
        # print('myHeaderTab:', myHeaderTab) # {'r': [3, <__main__.treeNode object at 0x000001EDF1C48C40>], 'z': [5, <__main__.treeNode object at 0x000001EDF1C48CA0>],
        # myFPtree.disp()
        '''
        其中每个缩进表示所处的树的深度
          Null Set   1
           z   5
            r   1
            x   3
             y   3
              t   3
               s   2
               r   1
           x   1
            s   1
             r   1
        '''
        # 获得条件模式基
        # print(findPrefixPath('x', myHeaderTab['x'][1])) # {frozenset({'z'}): 3} #myHeaderTab为头指针表
        # print(findPrefixPath('z', myHeaderTab['z'][1])) # {}
        # print(findPrefixPath('r', myHeaderTab['r'][1])) # {frozenset({'z'}): 1, frozenset({'x'}): 1, frozenset({'x', 't', 'z'}): 1}
    
        freqItems = []
        mineTree(myFPtree, myHeaderTab, 3, set([]), freqItems)
    
        '''示例：在Twitter源中发现一些共现词'''
        lotsOtweets = getLotsOfTweets('RIMM') # 搜索一只名为RIMM的股票