fpgrowth 0.0.1

data/test/tc_node.rb

@@ -0,0 +1,101 @@
+require 'test/unit'
+require "fpgrowth/fp_tree/node"
+
+class TestNode < Test::Unit::TestCase
+
+  # Called before every test method runs. Can be used
+  # to set up fixture information.
+  def setup
+    # Do nothing
+  end
+
+  # Called after every test method runs. Can be used to tear
+  # down fixture information.
+
+  def teardown
+    # Do nothing
+  end
+
+  # Test initialize
+  def test_initialize
+    # Test initialize for node = nil
+    node = nil
+    assert_nothing_raised { node = FpGrowth::FpTree::Node.new() }
+    assert_equal(nil, node.item)
+    assert_equal(1, node.support)
+    assert_equal([], node.children)
+    assert_equal(nil, node.lateral)
+
+    # Test initialize for node with first parameter
+    assert_nothing_raised { node = FpGrowth::FpTree::Node.new(14) }
+    assert_equal(14, node.item)
+    assert_equal(1, node.support)
+
+    # Test initialize for node with two parameter
+    assert_nothing_raised { node = FpGrowth::FpTree::Node.new(14, 32) }
+    assert_equal(14, node.item)
+    assert_equal(32, node.support)
+
+  end
+
+  def test_clone_tail_deep
+    node = FpGrowth::FpTree::Node.new('a')
+
+    nodeChild10 = FpGrowth::FpTree::Node.new('b')
+    nodeChild11 = FpGrowth::FpTree::Node.new('b')
+    nodeChild12 = FpGrowth::FpTree::Node.new('b')
+
+    node.children += [nodeChild10, nodeChild11, nodeChild12]
+
+    nodeChild20 = FpGrowth::FpTree::Node.new('c')
+    nodeChild21 = FpGrowth::FpTree::Node.new('c')
+    nodeChild22 = FpGrowth::FpTree::Node.new('c')
+
+
+    node.children.first.children += [nodeChild20, nodeChild21, nodeChild22]
+
+    assert_equal(nodeChild11, nodeChild12)
+
+    result = nil
+
+    assert_nothing_raised { result = node.clone_tail_deep }
+
+    for i in (0..result.size-1)
+      assert_not_same(node.children[i], result[i])
+      assert_equal(node.children[i], result[i])
+    end
+
+    assert_not_same(node.children, result)
+    assert_equal(node.children, result)
+
+
+    node = node.children.first
+    result = result.first.children
+
+    assert_not_same(node.children, result)
+    assert_equal(node.children, result)
+    for i in (0..result.size-1)
+      assert_not_same(node.children[i], result[i])
+      assert_equal(node.children[i], result[i])
+    end
+
+  end
+
+  def test_equal
+    a = FpGrowth::FpTree::Node.new('c', 2)
+    b = FpGrowth::FpTree::Node.new('c', 2)
+
+    assert_equal(a, a)
+    assert_equal(a, b)
+
+  end
+
+  def test_clone
+    a = FpGrowth::FpTree::Node.new('c', 2)
+    b = FpGrowth::FpTree::Node.new('c', 2)
+
+    assert_equal(a, b)
+    assert_not_same(a, b)
+  end
+
+end

data/test/tc_open_data_sondage_montreal.rb

@@ -0,0 +1,49 @@
+require 'test/unit'
+require 'fpgrowth'
+require 'csv'
+
+class TestOpenDataMTLSondage < Test::Unit::TestCase
+
+
+  def setup
+
+    @transactions = []
+    CSV.foreach("test/montreal-sondage/mtlsat12.csv", {:headers => true, :header_converters => :symbol, :header_converters => :symbol, :converters => :all, :encoding => 'windows-1251:utf-8'}) do |row|
+      transaction = row.to_a
+      transaction.delete_if { |item|
+        item[0].to_s.include?("dm") or (item[0].to_s.include?("sd80m") and item[1].to_s == '2') or item[1] == nil  or item[1] == nil or item[1].to_s == " "  or item[1].to_s.empty?
+      }
+      @transactions << transaction
+
+    end
+
+  end
+
+
+  def teardown
+    # Do nothing
+  end
+
+  # Fake test
+  def test_fp_growth
+
+    d = Time.now
+    puts "Start time : "+d.to_s
+
+    fp_tree = FpGrowth::FpTree.build(@transactions, 1)
+
+    puts "Tree built at :"+Time.now.to_s
+    patterns = FpGrowth::Miner.fp_growth(fp_tree)
+
+    f=Time.now
+    puts "Mining took #{(f-d)}sec"
+
+    patterns.sort! { |a, b| a.support <=> b.support }.reverse!
+
+    for pattern in patterns
+      puts "#{pattern.content} #{pattern.support}"
+    end
+
+    assert_not_equal(0, patterns.size)
+  end
+end

data/test/tc_open_data_velo_montreal.rb

@@ -0,0 +1,58 @@
+require 'test/unit'
+require 'fpgrowth'
+require 'csv'
+
+class TestOpenDataVelo < Test::Unit::TestCase
+
+
+  def setup
+
+    @transactions = []
+    CSV.foreach("test/montreal-velos-comptage/2012.csv", {:headers => true, :header_converters => :symbol, :header_converters => :symbol, :converters => :all, :encoding => 'windows-1251:utf-8', :col_sep => ";"}) do |row|
+      date = Date.parse(row[:date])
+      @transactions << [ [:wday, date.wday], [:month, date.month], [:date, row[:date]], [:berri, row[:berri_1]], [:ctesaintecatherine, row[:ctesaintecatherine]], [:maisonneuve_1, row[:maisonneuve_1]], [:maisonneuve_2, row[:maisonneuve_2]], [:du_parc, row[:du_parc]], [:pierredupuy, row[:pierredupuy]], [:rachel, row[:rachel1]]]
+    end
+
+
+    CSV.foreach("test/montreal-velos-comptage/2011.csv", {:headers => true, :header_converters => :symbol, :header_converters => :symbol, :converters => :all, :encoding => 'windows-1251:utf-8', :col_sep => ";"}) do |row|
+
+      date = Date.parse(row[:date])
+      mois = date.month
+      mois = 2 if row[:date].to_s.match("/f.vr/")
+      mois = 3 if row[:date].to_s.include?("avr")
+      mois = 5 if row[:date].to_s.include?("mai")
+      mois = 6 if row[:date].to_s.include?("juin")
+      mois = 7 if row[:date].to_s.include?("juil")
+      mois = 8 if row[:date].to_s.match("/ao.t/")
+      mois = 9 if row[:date].to_s.match("/d.c/")
+      date = Date.new(2011, mois, date.day)
+      transaction = [ [:wday, date.wday], [:month, date.month], [:date, row[:date]], [:berri, row[:berri]], [:ctesaintecatherine, row[:ctesaintecatherine]], [:maisonneuve_1, row[:maisonneuve_1]], [:maisonneuve_2, row[:maisonneuve_2]], [:du_parc, row[:du_parc]], [:pierredupuy, row[:pierredupuy]], [:rachel, row[:rachel]]]
+
+      transaction.delete_if { |x| x[1]==nil }
+      @transactions << transaction
+    end
+
+
+  end
+
+
+  def teardown
+    # Do nothing
+  end
+
+  # Fake test
+  def test_fp_growth
+    fp_tree = FpGrowth::FpTree.build(@transactions, 1)
+    patterns = FpGrowth::Miner.fp_growth(fp_tree)
+
+    patterns.sort! { |a, b| a.support <=> b.support }.reverse!
+
+=begin
+    for pattern in patterns
+      puts "#{pattern.content} #{pattern.support}"
+    end
+=end
+
+    assert_not_equal(0, patterns.size)
+  end
+end

data/test/tc_pattern.rb

@@ -0,0 +1,56 @@
+require 'test/unit'
+require 'fpgrowth/miner/pattern'
+
+class TestPattern < Test::Unit::TestCase
+
+  def test_initialize
+    pattern = nil
+    assert_nothing_raised { pattern = FpGrowth::Miner::Pattern.new() }
+    assert_equal(0, pattern.support)
+    assert_equal([], pattern.content)
+
+    assert_nothing_raised { pattern = FpGrowth::Miner::Pattern.new(['a', 'b', 'c'], 3) }
+    assert_equal(['a', 'b', 'c'], pattern.content)
+    assert_equal(3, pattern.support)
+
+  end
+
+  def test_add
+    pattern = FpGrowth::Miner::Pattern.new(['a', 'b', 'c'], 3)
+    pattern2 = FpGrowth::Miner::Pattern.new(['d', 'e'], 2)
+    union = nil
+    assert_nothing_raised { union = pattern + pattern2 }
+
+    assert_equal(union.size, pattern.size + pattern2.size)
+    assert_equal(5, union.size)
+    assert_equal(['a', 'b', 'c', 'd', 'e'], union.content)
+    assert_equal(pattern.content + pattern2.content, union.content)
+    assert_equal(2, union.support)
+  end
+
+  def test_insert
+    pattern = FpGrowth::Miner::Pattern.new(['a', 'b', 'c'], 3)
+    node1 = FpGrowth::FpTree::Node.new('d', 2)
+    node2 = FpGrowth::FpTree::Node.new('e', 3)
+
+    node3 = FpGrowth::FpTree::Node.new('f', 1)
+    node4 = FpGrowth::FpTree::Node.new('g', 2)
+    node_array = [node3, node4]
+
+    assert_nothing_raised { pattern << node1 }
+    assert_equal('d', pattern.content.last)
+    assert_equal(2, pattern.support)
+
+    assert_nothing_raised { pattern << node2 }
+    assert_equal('e', pattern.content.last)
+    assert_equal(2, pattern.support)
+
+    assert_nothing_raised { pattern << node_array }
+    assert_equal('g', pattern.content[-1])
+    assert_equal('f', pattern.content[-2])
+    assert_equal(1, pattern.support)
+
+
+  end
+
+end

data/test/tc_second_pass.rb

@@ -0,0 +1,148 @@
+require 'test/unit'
+require 'fpgrowth/fp_tree/builder/second_pass'
+require 'fpgrowth/fp_tree/builder/first_pass'
+
+
+class TestSecondPass < Test::Unit::TestCase
+
+
+  def setup
+    items= ['a', 'b', 'c', 'd', 'e']
+
+    r = Random.new
+
+    @n = r.rand(100..500)
+
+    @random_transactions = []
+    for i in (0..@n)
+
+
+      @m = r.rand(1..5)
+      @random_transactions[i]=[]
+      for j in (0..@m)
+        x = r.rand(10)
+        if x == 9
+          # Trick pour que le 'e' se fasse pruner
+        then
+          @random_transactions[i] << items[r.rand(items.size)]
+        else
+          @random_transactions[i] << items[r.rand(items.size - 1)]
+        end
+      end
+
+    end
+
+    @non_random = [['a', 'b'], ['b'], ['b', 'c'], ['a', 'b']]
+
+
+    firstPass = FpGrowth::FpTree::Builder::FirstPass.new()
+
+    @supports_random = firstPass.execute(@random_transactions)
+    @supports_non_random = firstPass.execute(@non_random)
+  end
+
+  # Called after every test method runs. Can be used to tear
+  # down fixture information.
+
+  def teardown
+    # Do nothing
+  end
+
+  def test_sort_by_support
+
+    secondPass = FpGrowth::FpTree::Builder::SecondPass.new(@supports_non_random)
+
+    support_sorted = []
+
+
+    for transaction in @non_random
+      support_sorted << secondPass.sort_by_support(transaction)
+    end
+
+    assert_equal(@supports_non_random.keys.first, support_sorted.first.first)
+    assert_equal(@supports_non_random.keys[1], support_sorted.first[1])
+
+
+    secondPass = FpGrowth::FpTree::Builder::SecondPass.new(@supports_random)
+
+    for transaction in @random_transactions
+      secondPass.sort_by_support(transaction)
+    end
+
+
+  end
+
+  def test_continue_pattern
+    parent = FpGrowth::FpTree::Node.new('a')
+    secondPass = FpGrowth::FpTree::Builder::SecondPass.new(@supports_non_random)
+
+    transaction = ['a', 'b']
+
+    assert_nothing_raised() { secondPass.continue_pattern(parent, transaction) }
+    assert_equal(2, parent.support)
+
+  end
+
+  def test_fork_pattern
+    parent = FpGrowth::FpTree::Node.new(nil)
+    secondPass = FpGrowth::FpTree::Builder::SecondPass.new(@supports_non_random)
+
+    transaction = ['a', 'b']
+
+    assert_nothing_raised() { secondPass.fork_pattern(parent, transaction) }
+    assert_equal('a', parent.children.last.item)
+    assert_equal('b', parent.children.last.children.first.item)
+
+    # Test 2
+
+    parent = FpGrowth::FpTree::Node.new('a')
+    secondPass = FpGrowth::FpTree::Builder::SecondPass.new(@supports_non_random)
+
+    transaction = ['a', 'a', 'b']
+
+    assert_nothing_raised() { secondPass.fork_pattern(parent, transaction) }
+    assert_equal('a', parent.children.last.item)
+    assert_equal(2, parent.children.last.support)
+    assert_equal('b', parent.children.last.children.first.item)
+
+
+  end
+
+  def test_traverse
+
+    parent = FpGrowth::FpTree::Node.new(nil)
+    secondPass = FpGrowth::FpTree::Builder::SecondPass.new(@supports_non_random)
+
+    transaction = ['a', 'a', 'b']
+
+    assert_nothing_raised() { secondPass.traverse(parent, transaction) }
+    assert_equal(2, parent.children.first.support)
+    assert_equal('a', parent.children.first.item)
+
+    assert_equal('b', parent.children.first.children.first.item)
+    assert_equal(1, parent.children.first.children.first.support)
+
+  end
+
+  def test_initialize
+    secondPass = nil
+    assert_nothing_raised { secondPass = FpGrowth::FpTree::Builder::SecondPass.new(@supports_non_random) }
+
+    assert_not_nil(secondPass.fp_tree)
+    assert_equal(@supports_non_random.keys, secondPass.fp_tree.heads.keys)
+    assert_equal(@supports_non_random, secondPass.fp_tree.supports)
+  end
+
+  def test_execute
+    secondPass = nil
+    assert_nothing_raised { secondPass = FpGrowth::FpTree::Builder::SecondPass.new(@supports_non_random) }
+
+    assert_nothing_raised { secondPass.execute(@non_random) }
+    for key in secondPass.fp_tree.heads.keys
+      assert_not_nil(secondPass.fp_tree.heads[key])
+    end
+
+
+  end
+
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: fpgrowth
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- thedamfr
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: ruby-graphviz
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: FP-Growth implementation
+email:
+- dam.cavailles@laposte.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .idea/.name
+- .idea/.rakeTasks
+- .idea/encodings.xml
+- .idea/fp-growth-ruby.iml
+- .idea/misc.xml
+- .idea/modules.xml
+- .idea/scopes/scope_settings.xml
+- .idea/vcs.xml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- fpgrowth-ruby.gemspec
+- lib/fpgrowth.rb
+- lib/fpgrowth/fp_tree.rb
+- lib/fpgrowth/fp_tree/builder.rb
+- lib/fpgrowth/fp_tree/builder/first_pass.rb
+- lib/fpgrowth/fp_tree/builder/second_pass.rb
+- lib/fpgrowth/fp_tree/node.rb
+- lib/fpgrowth/miner.rb
+- lib/fpgrowth/miner/conditional_tree_builder.rb
+- lib/fpgrowth/miner/pattern.rb
+- lib/fpgrowth/miner/pattern_base_extractor.rb
+- lib/fpgrowth/version.rb
+- test/montreal-sondage/mtlsat12.csv
+- test/montreal-velos-comptage/2009.csv
+- test/montreal-velos-comptage/2010.csv
+- test/montreal-velos-comptage/2011.csv
+- test/montreal-velos-comptage/2012.csv
+- test/tc_builder.rb
+- test/tc_first_pass.rb
+- test/tc_fp_tree.rb
+- test/tc_miner.rb
+- test/tc_node.rb
+- test/tc_open_data_sondage_montreal.rb
+- test/tc_open_data_velo_montreal.rb
+- test/tc_pattern.rb
+- test/tc_second_pass.rb
+homepage: ''
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: FP-Growth is mean to detect
+test_files:
+- test/montreal-sondage/mtlsat12.csv
+- test/montreal-velos-comptage/2009.csv
+- test/montreal-velos-comptage/2010.csv
+- test/montreal-velos-comptage/2011.csv
+- test/montreal-velos-comptage/2012.csv
+- test/tc_builder.rb
+- test/tc_first_pass.rb
+- test/tc_fp_tree.rb
+- test/tc_miner.rb
+- test/tc_node.rb
+- test/tc_open_data_sondage_montreal.rb
+- test/tc_open_data_velo_montreal.rb
+- test/tc_pattern.rb
+- test/tc_second_pass.rb