fpgrowth 0.0.2 → 1

data/README.md

@@ -44,12 +44,24 @@ Or install it yourself as:
 
 ## Usage
 
+### Basic Usage
+
+Just do it :
+
+```ruby
+transactions = [['a', 'b'], ['b'], ['b', 'c'], ['a', 'b']]
+patterns = FpGrowth.mine(transactions)
+```
+
+### Advanced Usage
+
+
 Build a tree from transactions and mine it
 
 ```ruby
 transactions = [['a', 'b'], ['b'], ['b', 'c'], ['a', 'b']]
 fp_tree = FpGrowth::FpTree.build(transactions)
-FpGrowth::Miner.fp_growth(fp_tree)
+FpGrowth::Miner.td_fp_growth(fp_tree)
 
 ```
 
@@ -61,10 +73,39 @@ The larger is the number of transactions, the smaller should be the threshold. I
 transactions = [['a', 'b'], ['b'], ['b', 'c'], ['a', 'b']]
 fp_tree = FpGrowth::FpTree.build(transactions, 30)
 # 30 stands for 30% of transactions. Here, 'c' would be pruned.
-FpGrowth::Miner.fp_growth(fp_tree)
+FpGrowth::Miner.td_fp_growth(fp_tree)
 
 ```
 
+If you want to avoid worst case, then you should make it a Bonzai !
+```ruby
+transactions = [['a', 'b'], ['b'], ['b', 'c'], ['a', 'b']]
+fp_tree = FpGrowth::FpTree.build(transactions, 30)
+bonzai = fp_tree.to_bonzai(20)
+FpGrowth::Miner.td_fp_growth(bonzai)
+
+```
+20 stands for a hardness of 20%. It mean that a node is cut from the tree if it's not greater than 20% of it's father support.
+
+There is two variant of FP-Growth.
+The first one is the TopDown, it's the most efficient, in most cases.
+For some reasons, it's alternative, the classical FpGrowth, it might be more efficient on a very small set.
+Use it this way :
+```ruby
+transactions = [['a', 'b'], ['b'], ['b', 'c'], ['a', 'b']]
+patterns = FpGrowth.fp_growth(transactions)
+```
+or
+ ```ruby
+ transactions = [['a', 'b'], ['b'], ['b', 'c'], ['a', 'b']]
+ fp_tree = FpGrowth::FpTree.build(transactions, 30)
+ bonzai = fp_tree.to_bonzai(20)
+ FpGrowth::Miner.fp_growth(bonzai)
+
+ ```
+
+
+
 ### Examples
 
 You can find in the test repository a few concrete example on Open Data.

data/Rakefile

@@ -4,7 +4,7 @@ require 'rake/testtask'
 
 Rake::TestTask.new do |t|
   t.libs << 'test'
-  t.test_files = FileList['test/tc_*.rb']
+  t.test_files = FileList['test/tc*.rb']
 end
 
 desc "Run tests"

data/lib/fpgrowth.rb

@@ -1,8 +1,20 @@
 require "fpgrowth/version.rb"
+require 'fpgrowth/fp_tree'
+require 'fpgrowth/miner'
 
 module FpGrowth
-  # Your code goes here...
-end
+  def self.mine(transactions, threshold=1)
+    td_fp_growth(transactions, threshold)
+  end
 
-require 'fpgrowth/fp_tree'
-require 'fpgrowth/miner'
+  def self.fp_growth(transactions, threshold=1)
+    fp_tree = FpTree.build(transactions, threshold)
+    Miner.fp_growth(fp_tree)
+  end
+
+  def self.td_fp_growth(transactions, threshold=1)
+    fp_tree = FpTree.build(transactions, threshold)
+    Miner.td_fp_growth(fp_tree)
+  end
+
+end

data/lib/fpgrowth/fp_tree.rb

@@ -1,5 +1,7 @@
 require_relative 'fp_tree/node'
 require_relative 'fp_tree/builder'
+require_relative 'fp_tree/bonzai_secateur'
+require_relative 'fp_tree/header_table'
 
 require 'graphviz'
 require 'etc'
@@ -18,8 +20,16 @@ module FpGrowth
         Builder.build(transactions, threshold)
       end
 
-      def initialize(supports={}, threshold=1)
-        @root = Node.new()
+      def to_bonzai(hardness=20)
+        return BonzaiSecateur.new(self, hardness).execute()
+      end
+
+      def to_bonzai!(hardness=20)
+        return BonzaiSecateur.new(self, hardness).execute!()
+      end
+
+      def initialize(supports={}, threshold=1, root=Node.new())
+        @root = root
         @heads = Hash.new nil
         @supports = supports
         #initialiser les clés
@@ -69,7 +79,7 @@ module FpGrowth
           node=row
           while node != nil
             for child in node.children
-              g.add_edges(nodonode[node], nodonode[child])
+              g.add_edges(nodonode[node], nodonode[child]) if nodonode[child]
             end
             node = node.lateral
           end
@@ -79,8 +89,8 @@ module FpGrowth
         for row in self.heads.values
           node=row
           while node != nil
-
-            g.add_edges(nodonode[node], nodonode[node.lateral], :style => :dashed, :constraint => :false) if node.lateral
+            g.add_edges(nodonode[node], nodonode[node.lateral], :style => :dashed, :color=> :green, :constraint => :false) if node.lateral
+            g.add_edges(nodonode[node], nodonode[node.parent], :style => :dashed, :color=> :red, :constraint => :false) if node.parent
             node = node.lateral
           end
         end
@@ -109,6 +119,49 @@ module FpGrowth
         end
       end
 
+      def cut_branch(node)
+        node.children.each { |child| cut_branch(child) }
+        remove(node)
+      end
+
+      def remove_from_lateral(node, verbose=false)
+        if @heads[node.item].equal?(node)
+          if node.lateral
+            @heads[node.item] = node.lateral
+          else
+            @heads.delete(node.item)
+          end
+        else
+          puts "node #{node.to_s}" if verbose
+          puts "pas head" if verbose
+          left = @heads[node.item]
+          while left != nil and not left.equal? node and not left.lateral.equal? node
+            left = left.lateral
+          end
+          puts "left found #{left.lateral}" if verbose
+          left.lateral = node.lateral if left
+          puts "left found #{left.lateral}" if verbose
+        end
+        node.lateral=nil
+      end
+
+      def remove(node)
+        # Remove from lateral linked list
+        remove_from_lateral(node)
+
+        # attach childrens
+        node.parent.children += node.children
+        node.children.each { |x| x.parent = node.parent }
+
+        # Remove from parents
+        node.parent.children.delete(node)
+
+        # Remove from support
+        @supports[node.item] -= node.support if @supports[node.item]
+
+
+      end
+
       def items_count
         sum=0
         for val in supports.values
@@ -146,6 +199,93 @@ module FpGrowth
         return @heads.empty?
       end
 
+      def clone
+        clone = FpTree.new(@supports, @threshold, @root.clone_deep)
+        clone.link_down()
+        return clone
+      end
+
+      def link_down(cursor=@root)
+        children = cursor.children.clone
+        cursor.children=[]
+        children.each { |child|
+          append_node(cursor, child)
+        }
+        children.each { |child| link_down(child) }
+      end
+
+      def size(subtree=@root)
+        sum = 1
+        subtree.children.each { |child| sum+= size(child) }
+        return sum
+      end
+
+      def sum
+        sum = 0
+        @supports.each { |key, value| sum+=value}
+        return sum
+      end
+
+      def lateral_sum
+        sum=0
+        for cursor in @heads.values
+          while cursor != nil
+            sum+=cursor.support
+            cursor = cursor.lateral
+          end
+
+        end
+        return sum
+      end
+
+      def max_width
+        max_width=0
+        for cursor in @heads.values
+          width=0
+          while cursor != nil
+            width+=1
+            cursor = cursor.lateral
+          end
+          max_width = width if max_width < width
+        end
+        return max_width
+      end
+
+      def has_lateral_cycle?
+        i = 0
+        while i < @heads.keys.size
+          key = @heads.keys[i]
+          cursor = @heads[key]
+          stack = []
+          flag = false
+          j=0
+          while cursor != nil and not flag
+            flag = true if stack.include?(cursor.object_id)
+            stack.push(cursor.object_id)
+            cursor = cursor.lateral
+            j += 1
+            #puts "#{i}/#{@heads.keys.size} - #{j}"
+          end
+          return key if flag
+          i += 1
+        end
+        return false
+      end
+
+      def header_table
+        unless @header_table
+          @header_table = HeaderTable.new()
+          for row in @heads.keys
+            node = @heads[row]
+            while node != nil
+              @header_table << [node.item, node.support, node]
+              node = node.lateral
+            end
+          end
+          return @header_table
+        end
+      end
+
     end
   end
 end

data/lib/fpgrowth/fp_tree/bonzai_secateur.rb

@@ -0,0 +1,30 @@
+module FpGrowth
+  module FpTree
+    class BonzaiSecateur
+
+      def initialize(fp_tree, hardness=20)
+        @fp_tree=fp_tree
+        @hardness=hardness
+      end
+
+      def execute(hardness=@hardness, fp_tree=@fp_tree.clone)
+        traverse(fp_tree)
+        return fp_tree
+      end
+
+      def execute!(hardness=@hardness)
+        return execute(hardness, @fp_tree)
+      end
+
+      def traverse(fp_tree, cursor = fp_tree.root, deepness=0)
+        children = cursor.children.clone
+        threshold = cursor.support.to_f / 100 * (@hardness + deepness)
+        children.each { |child|
+          fp_tree.cut_branch(child) if child.support < threshold
+        }
+        cursor.children.each { |child| traverse(fp_tree, child, deepness + 1) }
+      end
+
+    end
+  end
+end

data/lib/fpgrowth/fp_tree/builder.rb

@@ -1,4 +1,5 @@
 require_relative 'builder/first_pass'
+require_relative 'builder/header_table_builder'
 require_relative 'builder/second_pass'
 
 

data/lib/fpgrowth/fp_tree/builder/first_pass.rb

@@ -1,4 +1,3 @@
-
 module FpGrowth
   module FpTree
     module Builder
@@ -35,16 +34,12 @@ module FpGrowth
         def pruning(transactions=@transactions, supports=@supports, threshold=@threshold)
 
           minimum = transactions.size.to_f / 100 * threshold
-
           for transaction in transactions
-            for item in transaction
-
-              transaction.delete(item) if supports[item] < minimum
-            end
+            transaction.delete_if { |item| supports[item] < minimum }
           end
           transactions.delete([])
-          supports.delete_if { |key, value| value < minimum }
 
+          supports.delete_if { |key, value| value < minimum }
           return supports
         end
 

data/lib/fpgrowth/fp_tree/builder/header_table_builder.rb

@@ -0,0 +1,37 @@
+require_relative "../header_table"
+
+module FpGrowth
+  module FpTree
+    module Builder
+      class HeaderTableBuilder
+
+
+        def initialize(item, header_table)
+          @header_table = header_table
+          @item = item
+          @new_header_table = HeaderTable.new()
+        end
+
+        def execute()
+          # for each node n in header for item
+
+
+          for node in @header_table.nodes[@item]
+            # traverse tree from n to top
+            traverse_from_node_top_top(node.parent, node.support)
+          end
+          return @new_header_table
+        end
+
+        def traverse_from_node_top_top(node, support)
+          if node.item
+            # For each node m
+            @new_header_table << [node.item, support, node]
+            traverse_from_node_top_top(node.parent, support)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/fpgrowth/fp_tree/header_table.rb

@@ -0,0 +1,41 @@
+require 'set'
+module FpGrowth
+  module FpTree
+    class HeaderTable
+
+      def self.build(item, header_table)
+        builder = Builder::HeaderTableBuilder.new(item, header_table)
+        return builder.execute()
+      end
+
+
+      def initialize()
+        @count = Hash.new 0
+        @nodes = Hash.new { Set.new() }
+      end
+
+      attr_accessor :count, :nodes
+
+      def keys
+        @nodes.keys
+      end
+
+      # Append a Row
+      # @param row Array as  [item, support, node]
+      #
+      def << (row)
+        # Add a link for m in HeaderTable
+        @nodes[row[0]] = @nodes[row[0]] << row[2]
+        # Add support m = previous + n
+        @count[row[0]] += row[1]
+      end
+
+    end
+  end
+end
+
+class Set
+  def to_s
+    to_a.join(', ')
+  end
+end

data/lib/fpgrowth/fp_tree/node.rb

@@ -41,6 +41,7 @@ module FpGrowth
         return flag
       end
 
+
     end
   end
 end

data/lib/fpgrowth/miner.rb

@@ -15,6 +15,11 @@ module FpGrowth
       return miner.pattern_set
     end
 
+    def self.td_fp_growth(fp_tree)
+      miner = Miner.new()
+      miner.top_down_fp_growth(fp_tree)
+      return miner.pattern_set
+    end
 
     class Miner
 
@@ -42,7 +47,7 @@ module FpGrowth
               pattern_beta << node
             end
             @pattern_set << pattern_beta
-            #puts "Pattern extracted : #{pattern_beta.content.to_s}"
+            #puts "Pattern extracted : #{pattern_beta.content.to_s} - #{pattern_beta.support}"
           end
         else
           for item in fp_tree.supports.keys
@@ -56,7 +61,32 @@ module FpGrowth
           end
         end
       end
-    end
+
+      def top_down_fp_growth(header_table, pattern_alpha=Pattern.new(), min_support=0)
+
+        if header_table.instance_of? FpTree::FpTree
+          header_table = header_table.header_table
+        end
+
+
+        # For each row of header_table
+        for row in header_table.keys
+          # If Support of header_table > min_support
+          if header_table.count[row] > min_support then
+            # output pattern extended with row.item
+            pattern_beta = Pattern.new(pattern_alpha.content + [row], header_table.count[row])
+            @pattern_set << pattern_beta
+            # puts "Pattern extracted : #{pattern_beta.content.to_s} - #{pattern_beta.support}"
+            # Build new Header Table
+            header_table_new = FpTree::HeaderTable.build(row, header_table)
+            # Mine extended pattern, new header table
+            top_down_fp_growth(header_table_new, pattern_beta)
+          end
+        end
+
+      end
+
+    end #class
 
   end
 end