PF-growth项目案例测试完成

src/python/12.FrequentPattemTree/fpGrowth.py

@@ -24,7 +24,6 @@ class treeNode:
 
     def inc(self, numOccur):
         """inc(对count变量增加给定值)
-
         """
         self.count += numOccur
 
@@ -56,16 +55,16 @@ def createInitSet(dataSet):
 
 # this version does not use recursion
 def updateHeader(nodeToTest, targetNode):
-    """updateHeader(更新头指针，添加targetNode到nodeToTest的nodeLink上面)
+    """updateHeader(更新头指针，建立相同元素之间的关系，例如： 左边的r指向右边的r值，就是后出现的相同元素 指向 已经出现的元素)
 
     从头指针的nodeLink开始，一直沿着nodeLink直到到达链表末尾。这就是链表。
     性能：如果链表很长可能会遇到迭代调用的次数限制。
 
     Args:
-        nodeToTest  头节点
-        targetNode  目标节点
+        nodeToTest  满足minSup {所有的元素+(value, treeNode)}
+        targetNode  Tree对象的子节点
     """
-    # Do not use recursion to traverse a linked list!
+    # 建立相同元素之间的关系，例如： 左边的r指向右边的r值
     while (nodeToTest.nodeLink is not None):
         nodeToTest = nodeToTest.nodeLink
     nodeToTest.nodeLink = targetNode
@@ -74,15 +73,19 @@ def updateHeader(nodeToTest, targetNode):
 def updateTree(items, inTree, headerTable, count):
     """updateTree(更新FP-tree，第二次遍历)
 
+    # 针对每一行的数据
+    # 最大的key,  添加
     Args:
-        items      满足minSup 排序后的元素数组（大到小的排序）
-        inTree     空的Tree对象
-        headerTable   满足minSup {所有的元素+(value, treeNode)}
-        count      原数据集中每一组Kay出现的次数
+        items       满足minSup 排序后的元素key的数组（大到小的排序）
+        inTree      空的Tree对象
+        headerTable 满足minSup {所有的元素+(value, treeNode)}
+        count       原数据集中每一组Kay出现的次数
     """
-    # 判断满足minSup排序后的第一个元素，是否是inTree的子节点
+    # 取出 元素 出现次数最高的
+    # 如果该元素在 inTree.children 这个字典中，就进行累加
+    # 如果该元素不存在 就 inTree.children 字典中新增key，value为初始化的 treeNode 对象
     if items[0] in inTree.children:
-        # 如果是，那么这个子节点的key元素添加count次
+        # 更新 最大元素，对应的 treeNode 对象的count进行叠加
         inTree.children[items[0]].inc(count)
     else:
         # 如果不存在子节点，我们为该inTree添加子节点
@@ -90,11 +93,13 @@ def updateTree(items, inTree, headerTable, count):
         # 如果满足minSup的dist字典的value值第二位为null， 我们就设置该元素为 本节点对应的tree节点
         # 如果元素第二位不为null，我们就更新header节点
         if headerTable[items[0]][1] is None:
+            # headerTable只记录第一次节点出现的位置
             headerTable[items[0]][1] = inTree.children[items[0]]
         else:
+            # 本质上是修改headerTable的key对应的Tree，的nodeLink值
             updateHeader(headerTable[items[0]][1], inTree.children[items[0]])
     if len(items) > 1:
-        # print 'items[1::]=', items[1::]
+        # 递归的调用，在items[0]的基础上，添加item0[1]做子节点， count只要循环的进行累计加和而已，统计出节点的最后的统计值。
         updateTree(items[1::], inTree.children[items[0]], headerTable, count)
 
 
@@ -102,115 +107,135 @@ def createTree(dataSet, minSup=1):
     """createTree(生成FP-tree，第一次遍历)
 
     Args:
-        dataSet  dist字典对象
+        dataSet  dist{行：出现次数}的样本数据
         minSup   最小的支持度
     Returns:
         retTree  FP-tree
         headerTable 满足minSup {所有的元素+(value, treeNode)}
     """
-    # 创建一个满足支持度>=minSup的dist字典
+    # 支持度>=minSup的dist{所有元素：出现的次数}
     headerTable = {}
-    # 循环得到dist字典所有的key
+    # 循环 dist{行：出现次数}的样本数据
     for trans in dataSet:
-        # 对所有的key进行循环，得到key里面的所有元素
+        # 对所有的行进行循环，得到行里面的所有元素
+        # 统计每一行中，每个元素出现的总次数
         for item in trans:
-            # 存储每个元素和它对应的次数： 本身+dataSet该元素出现的次数
+            # 例如： {'ababa': 3}  count(a)=3+3+3=9   count(b)=3+3=6
             headerTable[item] = headerTable.get(item, 0) + dataSet[trans]
-    # 循环所有元素出现的次数，然后remove到小于minSup的元素
+    # 删除 headerTable中，元素次数<最小支持度的元素
     for k in headerTable.keys():
         if headerTable[k] < minSup:
             del(headerTable[k])
 
-    # 求出满足minSup元素的集合
+    # 满足minSup: set(各元素集合)
     freqItemSet = set(headerTable.keys())
-    # 如果不存在满足minSup的元素就直接返回None
+    # 如果不存在，直接返回None
     if len(freqItemSet) == 0:
         return None, None
     for k in headerTable:
-        # reformat headerTable to use Node link
-        # value值为一个元组
+        # 格式化： dist{元素key: [元素次数, None]}
         headerTable[k] = [headerTable[k], None]
 
     # create tree
     retTree = treeNode('Null Set', 1, None)
+    # 循环 dist{行：出现次数}的样本数据
     for tranSet, count in dataSet.items():
+        # print 'tranSet, count=', tranSet, count
+        # localD = dist{元素key: 元素次数}
         localD = {}
         for item in tranSet:
             # 判断是否在满足minSup的集合中
             if item in freqItemSet:
                 # print 'headerTable[item][0]=', headerTable[item][0], headerTable[item]
                 localD[item] = headerTable[item][0]
+        # print 'localD=', localD
         if len(localD) > 0:
             # p=key,value; 所以是通过value值的大小，进行从大到小进行排序
-            # orderedItems表示取出元组的key值，也就是字母本身，但是字母本身是存在顺序的
+            # orderedItems 表示取出元组的key值，也就是字母本身，但是字母本身是大到小的顺序
             orderedItems = [v[0] for v in sorted(localD.items(), key=lambda p: p[1], reverse=True)]
-            # print 'sorted(localD.items(), key=lambda p: p[1], reverse=True)]=', sorted(localD.items(), key=lambda p: p[1], reverse=True)
-            # print 'orderedItems=', orderedItems
-
-            # 使用有序freq项集来填充树
+            # print 'orderedItems=', orderedItems, 'headerTable', headerTable, '\n\n\n'
+            # 填充树，通过有序的orderedItems的第一位，进行顺序填充 第一层的子节点。
             updateTree(orderedItems, retTree, headerTable, count)
 
     return retTree, headerTable
 
 
-def ascendTree(leafNode, prefixPath): #ascends from leaf node to root
+def ascendTree(leafNode, prefixPath):
+    """ascendTree(如果存在父节点，就记录当前节点的name值)
+
+    Args:
+        leafNode   查询的节点对于的nodeTree
+        prefixPath 要查询的节点值
+    """
     if leafNode.parent is not None:
         prefixPath.append(leafNode.name)
         ascendTree(leafNode.parent, prefixPath)
 
 
-def findPrefixPath(basePat, treeNode): #treeNode comes from header table
+def findPrefixPath(basePat, treeNode):
+    """findPrefixPath 基础数据集
+
+    Args:
+        basePat  要查询的节点值
+        treeNode 查询的节点所在的当前nodeTree
+    Returns:
+        condPats 对非basePat的倒叙值作为key,赋值为count数
+    """
     condPats = {}
+    # 对 treeNode的link进行循环
     while treeNode is not None:
         prefixPath = []
+        # 寻找改节点的父节点，相当于找到了该节点的频繁项集
         ascendTree(treeNode, prefixPath)
-        if len(prefixPath) > 1: 
+        # 避免 单独`Z`一个元素，添加了空节点
+        if len(prefixPath) > 1:
+            # 对非basePat的倒叙值作为key,赋值为count数
+            # prefixPath[1:] 变frozenset后，字母就变无须了
+            # condPats[frozenset(prefixPath)] = treeNode.count
             condPats[frozenset(prefixPath[1:])] = treeNode.count
+        # 递归，寻找改节点的上一个 相同值的链接节点
         treeNode = treeNode.nodeLink
+        # print treeNode
     return condPats
 
 
-if __name__ == "__main__":
-    rootNode = treeNode('pyramid', 9, None)
-    rootNode.children['eye'] = treeNode('eye', 13, None)
-    rootNode.children['phoenix'] = treeNode('phoenix', 3, None)
-    # 将树以文本形式显示
-    # print rootNode.disp()
-
-    # load样本数据
-    simpDat = loadSimpDat()
-    # print simpDat, '\n'
-    # 重新装载 frozen set 格式化样本数据，用dist存储数据和对应的次数
-    initSet = createInitSet(simpDat)
-    # print initSet
-
-    # 创建FP树
-    myFPtree, myHeaderTab = createTree(initSet, 3)
-    myFPtree.disp()
-    # print myHeaderTab
-
-
-
-
-
 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
+    """mineTree(创建条件FP树)
+
+    Args:
+        inTree       myFPtree
+        headerTable  满足minSup {所有的元素+(value, treeNode)}
+        minSup       最小支持项集
+        preFix       preFix为newFreqSet上一次的存储记录，一旦没有myHead，就不会更新
+        freqItemList 用来存储频繁子项的列表
+    """
+    # 通过value进行从小到大的排序， 得到频繁项集的key
+    # 最小支持项集的key的list集合
+    bigL = [v[0] for v in sorted(headerTable.items(), key=lambda p: p[1])]
+    # print '-----', sorted(headerTable.items(), key=lambda p: p[1])
+    print 'bigL=', bigL
+    # 循环遍历 最频繁项集的key，从小到大的递归寻找对应的频繁项集
+    for basePat in bigL:
+        # preFix为newFreqSet上一次的存储记录，一旦没有myHead，就不会更新
         newFreqSet = preFix.copy()
         newFreqSet.add(basePat)
-        #print 'finalFrequent Item: ',newFreqSet    #append to set
+        print 'newFreqSet=', newFreqSet, preFix
+
         freqItemList.append(newFreqSet)
+        print 'freqItemList=', freqItemList
         condPattBases = findPrefixPath(basePat, headerTable[basePat][1])
-        #print 'condPattBases :',basePat, condPattBases
-        #2. construct cond FP-tree from cond. pattern base
+        print 'condPattBases=', basePat, condPattBases
+
+        # 构建FP-tree
         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)            
+        print 'myHead=', myHead
+        # 挖掘条件 FP-tree, 如果
+        if myHead is not None:
+            myCondTree.disp(1)
+            print '\n\n\n'
+            # 递归 myHead 找出频繁项集
             mineTree(myCondTree, myHead, minSup, newFreqSet, freqItemList)
-
-
+        print '\n\n\n'
 
 
 import twitter
@@ -218,23 +243,19 @@ from time import sleep
 import re
 
 
-def textParse(bigString):
-    urlsRemoved = re.sub('(http:[/][/]|www.)([a-z]|[A-Z]|[0-9]|[/.]|[~])*', '', bigString)    
-    listOfTokens = re.split(r'\W*', urlsRemoved)
-    return [tok.lower() for tok in listOfTokens if len(tok) > 2]
-
-
 def getLotsOfTweets(searchStr):
+    """
+    获取 100个搜索结果页面
+    """
     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
+    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):
+    for i in range(1, 15):
         print "fetching page %d" % i
         searchResults = api.GetSearch(searchStr, per_page=100, page=i)
         resultsPages.append(searchResults)
@@ -242,7 +263,19 @@ def getLotsOfTweets(searchStr):
     return resultsPages
 
 
+def textParse(bigString):
+    """
+    解析页面内容
+    """
+    urlsRemoved = re.sub('(http:[/][/]|www.)([a-z]|[A-Z]|[0-9]|[/.]|[~])*', '', bigString)    
+    listOfTokens = re.split(r'\W*', urlsRemoved)
+    return [tok.lower() for tok in listOfTokens if len(tok) > 2]
+
+
 def mineTweets(tweetArr, minSup=5):
+    """
+    获取频繁项集
+    """
     parsedList = []
     for i in range(14):
         for j in range(100):
@@ -254,10 +287,51 @@ def mineTweets(tweetArr, minSup=5):
     return myFreqList
 
 
-#minSup = 3
-#simpDat = loadSimpDat()
-#initSet = createInitSet(simpDat)
-#myFPtree, myHeaderTab = createTree(initSet, minSup)
-#myFPtree.disp()
-#myFreqList = []
-#mineTree(myFPtree, myHeaderTab, minSup, set([]), myFreqList)
+if __name__ == "__main__":
+    # rootNode = treeNode('pyramid', 9, None)
+    # rootNode.children['eye'] = treeNode('eye', 13, None)
+    # rootNode.children['phoenix'] = treeNode('phoenix', 3, None)
+    # # 将树以文本形式显示
+    # # print rootNode.disp()
+
+    # # load样本数据
+    # simpDat = loadSimpDat()
+    # # print simpDat, '\n'
+    # # frozen set 格式化 并 重新装载 样本数据，对所有的行进行统计求和，格式: {行：出现次数}
+    # initSet = createInitSet(simpDat)
+    # # print initSet
+
+    # # 创建FP树
+    # # 输入：dist{行：出现次数}的样本数据  和  最小的支持度
+    # # 输出：最终的PF-tree，通过循环获取第一层的节点，然后每一层的节点进行递归的获取每一行的字节点，也就是分支。然后所谓的指针，就是后来的指向已存在的
+    # myFPtree, myHeaderTab = createTree(initSet, 3)
+    # myFPtree.disp()
+
+    # # 抽取条件模式基
+    # # 查询树节点的，频繁子项
+    # # print findPrefixPath('x', myHeaderTab['x'][1])
+    # # print findPrefixPath('z', myHeaderTab['z'][1])
+    # # print findPrefixPath('r', myHeaderTab['r'][1])
+
+    # # 创建条件模式基
+    # freqItemList = []
+    # mineTree(myFPtree, myHeaderTab, 3, set([]), freqItemList)
+    # print freqItemList
+
+    # # 项目实战
+    # # 1.twitter项目案例
+    # # 无法运行，因为没发链接twitter
+    # lotsOtweets = getLotsOfTweets('RIMM')
+    # listOfTerms = mineTweets(lotsOtweets, 20)
+    # print len(listOfTerms)
+    # for t in listOfTerms:
+    #     print t
+
+    # 2.新闻网站点击流中挖掘
+    parsedDat = [line.split() for line in open('testData/FPGrowth_kosarak.dat').readlines()]
+    initSet = createInitSet(parsedDat)
+    myFPtree, myHeaderTab = createTree(initSet, 100000)
+
+    myFreList = []
+    mineTree(myFPtree, myHeaderTab, 100000, set([]), myFreList)
+    print myFreList