fpgrowth 0.0.2 → 1

data/lib/fpgrowth/miner/pattern_base_extractor.rb

@@ -5,7 +5,7 @@ module FpGrowth
   module Miner
     class PatternBaseExtractor
 
-      def initialize(tree=FpTree.new, item)
+      def initialize(tree=FpTree::FpTree.new() , item)
         @tree = tree
         @horizontal_cursor = tree.heads[item]
         @conditional_item = item
@@ -52,7 +52,7 @@ module FpGrowth
       def down_to_top_traversal(current_branch=@current_branch, vertical_cursor=@vertical_cursor)
         @vertical_cursor = vertical_cursor
         while @vertical_cursor != nil and @vertical_cursor.item != nil
-          down_to_top_traversal_step()
+          down_to_top_traversal_step(current_branch)
           @vertical_cursor = @vertical_cursor.parent
         end
         current_branch.reverse!
@@ -62,9 +62,57 @@ module FpGrowth
       #
       # It just gather items
       #
-      def down_to_top_traversal_step(current_branch=@current_branch, vertical_cursor=@vertical_cursor, min_support=@min_support)
+      def down_to_top_traversal_step(current_branch=@current_branch, vertical_cursor=@vertical_cursor)
         current_branch << vertical_cursor.item
       end
+
+
+      #fonction qui sert uniquement pour les tests
+      def test_conditionnal_item(item )
+        if   item == @conditional_item
+        then  return true
+        end
+        return false
+      end
+
+      def test_patterns(patterns = [])
+        if  patterns == @patterns
+        then  return true
+        end
+        return false
+      end
+
+      def test_tree(tree = FpTree::FpTree.new() )
+        if  tree.threshold == @tree.threshold and tree.root == @tree.root
+        then  return true
+        end
+        return false
+      end
+
+      def test_min_support( min_support )
+        if  min_support == @min_support
+        then  return true
+        end
+        return false
+      end
+
+      def test_current_branch (current_branch)
+        if current_branch  == @current_branch
+        then  return true
+        end
+        return false
+      end
+
+      def vertical_cursor (vertical_cursor)
+        if vertical_cursor  == @vertical_cursor
+        then  return true
+        end
+        return false
+      end
+
+
+
+
     end
   end
 end

data/lib/fpgrowth/version.rb

@@ -1,3 +1,3 @@
 module FpGrowth
-  VERSION = "0.0.2"
+  VERSION = "1"
 end

data/test/tc_conditional_tree_builder.rb

@@ -17,6 +17,8 @@ class TestConditionalTreeBuilder < Test::Unit::TestCase
     @tableau_pattern_one_element << FpGrowth::Miner::Pattern.new(['a'], 12)
 
     @supports_exemple = {'a' => 1, 'b' => 5, 'c' => 4}
+    @supports_exemple_for_pruning = {'a' => 4, 'b' => 5, 'c' => 3}
+
     @pattern_exemple = FpGrowth::Miner::Pattern.new(['a', 'b'], 2)
   end
 
@@ -52,14 +54,51 @@ class TestConditionalTreeBuilder < Test::Unit::TestCase
 
   def test_execute
 
+    # no argument
+    conditional_tree_builder = nil
+    assert_nothing_raised { conditional_tree_builder = FpGrowth::Miner::ConditionalTreeBuilder.new() }
+    assert_nothing_raised { conditional_tree_builder.execute }
+    assert_equal(true, conditional_tree_builder.test_execute_threshold(1))
+    assert_equal(true, conditional_tree_builder.test_execute_pattern_base())
+
+    # One element
+    assert_nothing_raised { conditional_tree_builder = FpGrowth::Miner::ConditionalTreeBuilder.new(@tableau_pattern_one_element , 1) }
+    assert_nothing_raised { conditional_tree_builder.execute }
+    assert_equal(true, conditional_tree_builder.test_execute_threshold(1))
+    assert_equal(true, conditional_tree_builder.test_execute_pattern_base(@tableau_pattern_one_element))
+
+    # Three element
+    assert_nothing_raised { conditional_tree_builder = FpGrowth::Miner::ConditionalTreeBuilder.new(@tableau_pattern , 1) }
+    assert_nothing_raised { conditional_tree_builder.execute }
+    assert_equal(true, conditional_tree_builder.test_execute_threshold(1))
+    assert_equal(true, conditional_tree_builder.test_execute_pattern_base(@tableau_pattern))
 
   end
 
   def test_second_pass
+    # Test unit impossible (Fp-tree)
 
   end
 
   def test_first_pass
+    # no elements
+    conditional_tree_builder = nil
+    assert_nothing_raised { conditional_tree_builder = FpGrowth::Miner::ConditionalTreeBuilder.new() }
+    assert_nothing_raised { conditional_tree_builder.first_pass}
+    assert_equal(true, conditional_tree_builder.test_execute_threshold(1))
+    assert_equal(true, conditional_tree_builder.test_execute_pattern_base())
+
+    #One element
+    assert_nothing_raised { conditional_tree_builder = FpGrowth::Miner::ConditionalTreeBuilder.new(@tableau_pattern_one_element , 1) }
+    assert_nothing_raised { conditional_tree_builder.first_pass}
+    assert_equal(true, conditional_tree_builder.test_execute_threshold(1))
+    assert_equal(true, conditional_tree_builder.test_execute_pattern_base(@tableau_pattern_one_element))
+
+    #Three element
+    assert_nothing_raised { conditional_tree_builder = FpGrowth::Miner::ConditionalTreeBuilder.new(@tableau_pattern , 1) }
+    assert_nothing_raised { conditional_tree_builder.first_pass}
+    assert_equal(true, conditional_tree_builder.test_execute_threshold(1))
+    assert_equal(true, conditional_tree_builder.test_execute_pattern_base(@tableau_pattern))
 
   end
 
@@ -83,6 +122,33 @@ class TestConditionalTreeBuilder < Test::Unit::TestCase
 
   def test_pruning
 
+    conditional_tree_builder = nil
+    support_prining = nil
+
+    assert_nothing_raised { conditional_tree_builder = FpGrowth::Miner::ConditionalTreeBuilder.new() }
+    # with arguments
+    supports = @supports_exemple
+    pattern_base = @tableau_pattern_one_element
+    supports_pruning = nil
+    assert_nothing_raised {supports_pruning = conditional_tree_builder.pruning(pattern_base , supports , 1)}
+
+    # There must be no pruning, considering the very few element there is
+    assert_equal(3, supports_pruning.size, "Supports : "+@support_non_random.to_s)
+
+    # with arguments
+    supports = @supports_exemple
+    pattern_base = @tableau_pattern_one_element
+    supports_pruning = nil
+    assert_nothing_raised {supports_pruning = conditional_tree_builder.pruning(pattern_base , supports , 33)}
+
+    assert_equal(2, supports_pruning.size, "Supports : "+@support_non_random.to_s)
+    assert_equal(5, supports_pruning['b'])
+    assert_equal(4, supports_pruning['c'])
+
+    supports = @supports_exemple_for_pruning
+    pattern_base = @tableau_pattern
+    supports_pruning = conditional_tree_builder.pruning(pattern_base , supports , 1 )
+    assert_equal(4, supports_pruning['a'])
   end
 
   def test_sort
@@ -118,18 +184,23 @@ class TestConditionalTreeBuilder < Test::Unit::TestCase
     assert_equal(['b', 'a'], pattern_base.content, "en plus, #{fp_tree.supports.to_s}")
     assert_equal(2, pattern_base.support)
 
-    #Two element
+    #Three element
     assert_nothing_raised { pattern_base = conditional_tree_builder.sort_by_support(FpGrowth::Miner::Pattern.new(['a','b','c'],2), fp_tree) }
 
     assert_equal(['b', 'c', 'a'], pattern_base.content, "en plus, #{fp_tree.supports.to_s}")
     assert_equal(2, pattern_base.support)
-
-
   end
 
   def test_traverse
+    # Test unit impossible
+  end
 
+  def test_fork_pattern
+    # Test unit impossible (like traverse )
   end
 
+  def test_continue_pattern
+    # Test unit impossible (like traverse )
+  end
 
 end

data/test/tc_fp_tree.rb

@@ -23,32 +23,32 @@ class TestFpTree < Test::Unit::TestCase
 
     fp_tree = nil
     # no arguments
-    assert_nothing_raised {fp_tree = FpGrowth::FpTree::FpTree.new()}
-    assert_not_nil( fp_tree.root )
-    assert_instance_of( FpGrowth::FpTree::Node , fp_tree.root )
-    assert_instance_of( Hash , fp_tree.heads )
-    assert_equal( {} , fp_tree.supports )
+    assert_nothing_raised { fp_tree = FpGrowth::FpTree::FpTree.new() }
+    assert_not_nil(fp_tree.root)
+    assert_instance_of(FpGrowth::FpTree::Node, fp_tree.root)
+    assert_instance_of(Hash, fp_tree.heads)
+    assert_equal({}, fp_tree.supports)
 
     # list empty
-    assert_nothing_raised {fp_tree = FpGrowth::FpTree::FpTree.new({})}
-    assert_not_nil( fp_tree.root )
-    assert_instance_of( FpGrowth::FpTree::Node , fp_tree.root )
-    assert_instance_of( Hash , fp_tree.heads )
-    assert_equal( {} , fp_tree.supports )
+    assert_nothing_raised { fp_tree = FpGrowth::FpTree::FpTree.new({}) }
+    assert_not_nil(fp_tree.root)
+    assert_instance_of(FpGrowth::FpTree::Node, fp_tree.root)
+    assert_instance_of(Hash, fp_tree.heads)
+    assert_equal({}, fp_tree.supports)
 
 
     # list with arguments
-    support =  { 'a' => 1, 'b' => 2}
-    assert_nothing_raised {fp_tree = FpGrowth::FpTree::FpTree.new(support)}
-    assert_not_nil( fp_tree.root )
-    assert_instance_of( FpGrowth::FpTree::Node , fp_tree.root )
-    assert_instance_of( Hash , fp_tree.heads )
-    assert( fp_tree.heads.has_key?('a') , "a n'existe pas")
-    assert( fp_tree.heads.has_key?('b') ,"b n'existe pas !" )
-    assert_equal( 2 , fp_tree.heads.length )
-    assert( fp_tree.supports.has_key?('a') , "a n'existe pas")
-    assert( fp_tree.supports.has_key?('b') ,"b n'existe pas !" )
-    assert_equal( 2 , fp_tree.supports.length )
+    support = {'a' => 1, 'b' => 2}
+    assert_nothing_raised { fp_tree = FpGrowth::FpTree::FpTree.new(support) }
+    assert_not_nil(fp_tree.root)
+    assert_instance_of(FpGrowth::FpTree::Node, fp_tree.root)
+    assert_instance_of(Hash, fp_tree.heads)
+    assert(fp_tree.heads.has_key?('a'), "a n'existe pas")
+    assert(fp_tree.heads.has_key?('b'), "b n'existe pas !")
+    assert_equal(2, fp_tree.heads.length)
+    assert(fp_tree.supports.has_key?('a'), "a n'existe pas")
+    assert(fp_tree.supports.has_key?('b'), "b n'existe pas !")
+    assert_equal(2, fp_tree.supports.length)
 
   end
 
@@ -58,16 +58,16 @@ class TestFpTree < Test::Unit::TestCase
     # look up with fp_tree nul
     fp_tree = nil
     # no arguments
-    assert_nothing_raised {fp_tree = FpGrowth::FpTree::FpTree.new()}
+    assert_nothing_raised { fp_tree = FpGrowth::FpTree::FpTree.new() }
     lookup = fp_tree.item_order_lookup
-    assert_equal( {} , lookup )
+    assert_equal({}, lookup)
 
     # look up with fp_tree non null
-    support =  { 'a' => 1, 'b' => 2}
-    assert_nothing_raised {fp_tree = FpGrowth::FpTree::FpTree.new(support)}
+    support = {'a' => 1, 'b' => 2}
+    assert_nothing_raised { fp_tree = FpGrowth::FpTree::FpTree.new(support) }
     lookup = fp_tree.item_order_lookup
-    assert_equal( 0  , lookup['a'] )
-    assert_equal( 1  , lookup['b'] )
+    assert_equal(0, lookup['a'])
+    assert_equal(1, lookup['b'])
 
   end
 
@@ -145,7 +145,7 @@ class TestFpTree < Test::Unit::TestCase
   def test_single_path
     child = FpGrowth::FpTree::Node.new('a')
 
-    fptree = FpGrowth::FpTree.build([ ['b','a']*3])
+    fptree = FpGrowth::FpTree.build([['b', 'a']*3])
 
     assert_equal(true, fptree.single_path?)
 
@@ -156,13 +156,64 @@ class TestFpTree < Test::Unit::TestCase
   end
 
   def test_combination
+
     fp_tree = FpGrowth::FpTree.build([['a', 'b'], ['b'], ['b', 'c', 'a'], ['a', 'b']], 0)
     assert_equal(true, fp_tree.single_path?)
     power_set = nil
     assert_nothing_raised { power_set = fp_tree.combinations }
 
-    fail("ToDo")
+    assert_not_nil(power_set)
+    assert_not_nil(power_set[1])
+    assert_not_nil(power_set[2])
+    assert_not_nil(power_set[3])
+    assert_not_nil(power_set[4])
+
+  end
+
+  def test_remove_from_lateral
+    fp_tree = FpGrowth::FpTree.build([['a', 'b'], ['b'], ['b', 'c'], ['a', 'b'], ['a', 'b', 'c']], 0)
+
+    assert_equal(false, fp_tree.has_lateral_cycle?)
+    fp_tree.remove_from_lateral(fp_tree.heads['c'].lateral)
+    assert_equal(false, fp_tree.has_lateral_cycle?)
+    assert_nil(fp_tree.heads['c'].lateral)
+
+
+    fp_tree = FpGrowth::FpTree.build([['a', 'b'], ['b'], ['b', 'c'], ['a', 'b'], ['a', 'b', 'c']], 0)
+    lebon = fp_tree.heads['c'].lateral
+
+    assert_equal(false, fp_tree.has_lateral_cycle?)
+    fp_tree.remove_from_lateral(fp_tree.heads['c'])
+    assert_equal(false, fp_tree.has_lateral_cycle?)
+    assert_nil(fp_tree.heads['c'].lateral)
+    assert_same(lebon,fp_tree.heads['c'])
+
+    fp_tree = FpGrowth::FpTree.build([['a', 'b'], ['b'], ['b', 'c'], ['a', 'b'], ['a', 'b', 'c']], 0)
+    fp_tree.graphviz
+    fp_tree.heads['c'].lateral.lateral = FpGrowth::FpTree::Node.new('c')
+    apres = fp_tree.heads['c'].lateral.lateral
+    avant = fp_tree.heads['c']
+
+    assert_equal(false, fp_tree.has_lateral_cycle?)
+
+    fp_tree.remove_from_lateral(fp_tree.heads['c'].lateral)
+
+    assert_equal(false, fp_tree.has_lateral_cycle?)
+    assert_nil(fp_tree.heads['c'].lateral.lateral)
+    assert_same(apres,fp_tree.heads['c'].lateral)
+    assert_same(avant,fp_tree.heads['c'])
+
+
+  end
+
+  def test_clone
+    fp_tree = FpGrowth::FpTree.build([['a', 'b'], ['b'], ['b', 'c'], ['a', 'b'], ['a', 'b', 'c']], 0)
+
+#    fail("ToDo")
+  end
 
+  def test_remove
+    #fail("ToDo")
   end
 
 end

data/test/tc_miner.rb

@@ -12,8 +12,8 @@ class TestMiner < Test::Unit::TestCase
 
     conditional_tree = FpGrowth::Miner.build_conditional_tree(fp_tree, 'a')
 
-    fp_tree.graphviz()
-    conditional_tree.graphviz("conditional")
+    #fp_tree.graphviz()
+    #conditional_tree.graphviz("conditional")
 
 
     assert_equal('b', conditional_tree.root.children.first.item)
@@ -53,8 +53,8 @@ class TestMiner < Test::Unit::TestCase
     fp_tree = FpGrowth::FpTree.build(@random_transactions, 1)
     conditional_tree = FpGrowth::Miner.build_conditional_tree(fp_tree, fp_tree.heads.keys[-2])
 
-    fp_tree.graphviz()
-    conditional_tree.graphviz("conditional-#{fp_tree.heads.keys[-2]}")
+    #fp_tree.graphviz()
+    #conditional_tree.graphviz("conditional-#{fp_tree.heads.keys[-2]}")
 
   end
 

data/test/tc_open_data_enel.rb

@@ -4,6 +4,9 @@ class TestEnelOpenData < Test::Unit::TestCase
 
 
   def setup
+
+    puts "Setup Test : Open Data Enel"
+
     @transactions_canada_processi_prodotti = []
     CSV.foreach("test/enel/3_canada_i_processi_e_i_prodotti_1.csv", {:headers => true, :header_converters => :symbol, :header_converters => :symbol, :converters => :all, :col_sep => "\t"}) do |row|
       @transactions_canada_processi_prodotti << row.to_a
@@ -32,19 +35,52 @@ class TestEnelOpenData < Test::Unit::TestCase
 
   def test_canada_processi_prodotti
 
+
+    total_item = 0
+    min = @transactions_canada_processi_prodotti[0].size
+    max = 0
+    @transactions_canada_processi_prodotti.each { |transaction|
+      total_item += transaction.size
+      min = transaction.size if transaction.size < min
+      max = transaction.size if transaction.size > max
+    }
+    average = total_item / @transactions_canada_processi_prodotti.size
+
+    puts "Test Canada Processi Prodotti"
+    puts "Extracted #{@transactions_canada_processi_prodotti.size} transactions"
+    puts "With a total of #{total_item} items"
+    puts "min:#{min} avg:#{average} max:#{max} items/sets"
+    transactions_canada_processi_prodotti1 = @transactions_canada_processi_prodotti.clone
+    transactions_canada_processi_prodotti2 = @transactions_canada_processi_prodotti.clone
+
     start = Time.now
-    fp_tree = FpGrowth::FpTree.build(@transactions_canada_processi_prodotti, 1)
+    fp_tree = FpGrowth::FpTree.build(transactions_canada_processi_prodotti1, 1)
+
     loop = Time.now
-    puts "Tree built in #{loop - start}"
+    puts "Tree built of size #{fp_tree.size} in #{loop - start}"
 
     patterns = FpGrowth::Miner.fp_growth(fp_tree)
 
     finish = Time.now
-    puts "Tree Mined in #{finish -start}"
+    puts "Tree Mined in #{finish - loop}"
 
     patterns.sort! { |a, b| a.support <=> b.support }.reverse!
 
-    #patterns.each { |pattern| puts "<#{pattern.content}:#{pattern.support}>"}
+    assert_not_equal(0, patterns.size)
+
+    start_td = Time.now
+    fp_tree_td = FpGrowth::FpTree.build(transactions_canada_processi_prodotti2, 1)
+
+    loop_td = Time.now
+    puts "Tree built of size #{fp_tree.size} in #{loop_td - start_td}"
+
+    patterns_td = FpGrowth::Miner.td_fp_growth(fp_tree_td)
+
+    finish_td = Time.now
+
+    puts "Tree built in #{loop_td - start_td} TDMined in #{finish_td - loop_td}"
+
+    puts "Found #{patterns_td.size} rather than #{patterns.size} with a DeltaTime of #{finish_td - start_td - (finish - start)} it's a #{-(finish_td - start_td - (finish - start)) / (finish - start) * 100}% speedup"
 
 
     assert_not_equal(0, patterns.size)
@@ -53,20 +89,51 @@ class TestEnelOpenData < Test::Unit::TestCase
 
   def test_canada_produzione_impianti_termoelecttrici
 
+
+    total_item = 0
+    min = @transactions_produzione_impianti_termoelecttrici[0].size
+    max = 0
+    @transactions_produzione_impianti_termoelecttrici.each { |transaction|
+      total_item += transaction.size
+      min = transaction.size if transaction.size < min
+      max = transaction.size if transaction.size > max
+    }
+    average = total_item / @transactions_produzione_impianti_termoelecttrici.size
+
+    puts "Test Canada Produzione Impianti Termoelecttrici"
+    puts "Extracted #{@transactions_produzione_impianti_termoelecttrici.size} transactions"
+    puts "With a total of #{total_item} items"
+    puts "min:#{min} avg:#{average} max:#{max} items/sets"
+    transactions_produzione_impianti_termoelecttrici1 = @transactions_produzione_impianti_termoelecttrici.clone
+    transactions_produzione_impianti_termoelecttrici2 = @transactions_produzione_impianti_termoelecttrici.clone
+
     start = Time.now
-    fp_tree = FpGrowth::FpTree.build(@transactions_produzione_impianti_termoelecttrici, 1)
+    fp_tree = FpGrowth::FpTree.build(transactions_produzione_impianti_termoelecttrici1, 1)
     loop = Time.now
-    puts "Tree built in #{loop - start}"
+    puts "Tree built of size #{fp_tree.size} in #{loop - start}"
     patterns = FpGrowth::Miner.fp_growth(fp_tree)
     finish = Time.now
-    puts "Tree Mined in #{finish - start}"
+    puts "Tree Mined in #{finish - loop}"
+
+    assert_not_equal(0, patterns.size)
+
+    start_td = Time.now
+    fp_tree_td = FpGrowth::FpTree.build(transactions_produzione_impianti_termoelecttrici2, 1)
+
+    loop_td = Time.now
+    puts "Tree built of size #{fp_tree_td.size} in #{loop_td - start_td}"
+
+    patterns_td = FpGrowth::Miner.td_fp_growth(fp_tree_td)
+
+    finish_td = Time.now
+
+    puts "Tree built in #{loop_td - start_td} TDMined in #{finish_td - loop_td}"
+
+    puts "Found #{patterns_td.size} rather than #{patterns.size} with a DeltaTime of #{finish_td - start_td - (finish - start)} it's a #{-(finish_td - start_td - (finish - start)) / (finish - start) * 100}% speedup"
 
-    patterns.sort! { |a, b| a.support <=> b.support }
-    patterns.sort! { |a, b| a.content.length <=> b.content.length }
 
     assert_not_equal(0, patterns.size)
 
-    #patterns.each { |pattern| puts "<#{pattern.content}:#{pattern.support}>" if pattern.support > 1}
 
   end