fpgrowth 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fpgrowth-growth-ruby.gemspec
+gemspec
+
+gem 'json'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 thedamfr
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,88 @@
+# Fp-Growth-Ruby
+
+Ruby implementation of FP-Growth
+
+## What's FP-Growth
+
+FP-Growth is an algorithm used for mining frequent pattern in an item set. Such pattern are then used to build association rules.
+Literature example is { Potatoes, Onions } => { Burger } or { Beer, Chips } => { Dippers }.
+
+FP-Growth is known as a solution for Mining without Candidate generation (http://dl.acm.org/citation.cfm?id=335372).
+Main alternative to FP-Growth is A Priori which is a pretty much a naive solution. A Priori consist in generating candidate then scanning the database looking for them.
+
+FP-Growth solution is about reducing the database in one simple Tree Structure : The FP-Tree. The FP-Tree make easy to extract frequent pattern from it.
+Then FP-Growth algorithm is about Extracting pattern from the tree, starting by the smallest, at the leafs of the tree and then making them grow until every pattern has been found.
+
+## When use FP-Growth ?
+
+FP-Growth is about working on a very large number of transactions. The FpTree building is a single pass linear operation.
+Most of the time, FP-Growth operation is a 0(h²) operation, where h is the height of the Tree. By design, the height is the maximal length of the pattern.
+
+Worst case is a DataSet with long transactions and where each item is significantly frequent. Such a tree is very big and reduction factor is very low. Performances would be... not what you expect ^^
+
+## So why use FP-Growth in Ruby ?
+
+Imagine a web app allowing you to connect to other users. Such a website want to help the user to engage with other. It will scan relationship of users and make suggestions like : "People who connect with following persons often connect with thoses persons".
+
+Imagine a commercial website showing some products to the users. It will scan users actions and make suggestions like : "People who like this products often like this other one !"
+
+Those applications are now easy thanks to fpgrowth-ruby !
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'fpgrowth-ruby'
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install fp-growth-ruby
+
+## 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)
+
+```
+
+By default, threshold for an item to be considered as "frequent" is 1% of the transactions.
+You can edit the threshold when building the tree. We recommend using a threshold around 1%.
+The larger is the number of transactions, the smaller should be the threshold. If tree is too large, you should use a higher threshold.
+
+```ruby
+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)
+
+```
+
+
+
+## Development : Next steps
+
+As we said, worst case is a is a DataSet with long transactions and where each item is significantly frequent. Solution would be to higher the threshold level, which would result in data-loss, maybe critical data would be lost...
+
+A better solution, described is following articles : [http://dl.acm.org/citation.cfm?id=1133907 , http://link.springer.com/chapter/10.1007/978-3-540-24775-3_19]
+Main concept is pruning the tree, once built in order to remove the less significant patterns. This is necessary to allow developer to prune his tree, losing least frequent pattern, in order to quickly obtain the most frequent ones.
+
+This is next step in our Roadmap.
+
+This is also a necessary step for allowing a Top-Down FP-Growth implementation as described in : http://link.springer.com/chapter/10.1007/3-540-47887-6_34
+
+This last implementation is more scalable and more efficient than the current one.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/tc_*.rb']
+end
+
+desc "Run tests"
+task :default => :test

data/fpgrowth-ruby.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fpgrowth/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "fpgrowth"
+  spec.version       = FpGrowth::VERSION
+  spec.authors       = ["thedamfr"]
+  spec.email         = ["dam.cavailles@laposte.net"]
+  spec.description   = %q{FP-Growth implementation}
+  spec.summary       = %q{FP-Growth is mean to detect}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "ruby-graphviz"
+end

data/lib/fpgrowth.rb

@@ -0,0 +1,8 @@
+require "fpgrowth/version.rb"
+
+module FpGrowth
+  # Your code goes here...
+end
+
+require 'fpgrowth/fp_tree'
+require 'fpgrowth/miner'

data/lib/fpgrowth/fp_tree.rb

@@ -0,0 +1,153 @@
+require_relative 'fp_tree/node'
+require_relative 'fp_tree/builder'
+
+require 'graphviz'
+require 'etc'
+
+module FpGrowth
+  module FpTree
+
+    def self.build(transactions, threshold=1)
+      Builder.build(transactions, threshold)
+    end
+
+    class FpTree
+      attr_reader :root, :heads, :supports, :threshold
+
+      def self.build(transactions, threshold=1)
+        Builder.build(transactions, threshold)
+      end
+
+      def initialize(supports={}, threshold=1)
+        @root = Node.new()
+        @heads = Hash.new nil
+        @supports = supports
+        #initialiser les clés
+        for k in @supports.keys
+          @heads[k]=nil
+        end
+        @threshold=threshold
+      end
+
+      def item_order_lookup
+        unless @lookup
+          @lookup = {}
+          @supports.keys.each_with_index do |item, index|
+            @lookup[item] = index
+          end
+        end
+        return @lookup
+
+      end
+
+      def find_lateral_leaf_for_item(item)
+        cursor = heads[item]
+        while cursor != nil and cursor.lateral != nil do
+          cursor = cursor.lateral
+        end
+        return cursor
+      end
+
+      def graphviz(fancy_name=nil)
+        g = GraphViz.new(:G, :type => :digraph)
+        nodonode = {}
+        nodonode[self.root]=g.add_nodes(self.root.to_s, :label => "nil")
+
+        for row in self.heads.values
+          node=row
+          while node != nil
+            nodonode[node]= g.add_nodes(node.to_s, :label => node.item.to_s + " : " + node.support.to_s)
+            node = node.lateral
+          end
+        end
+
+        for child in self.root.children
+          g.add_edges(nodonode[self.root], nodonode[child])
+        end
+
+        for row in self.heads.values
+          node=row
+          while node != nil
+            for child in node.children
+              g.add_edges(nodonode[node], nodonode[child])
+            end
+            node = node.lateral
+          end
+        end
+
+
+        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
+            node = node.lateral
+          end
+        end
+
+        g.output(:png => "./graphs/#{fancy_name}-#{Etc.getlogin}-#{items_count}-items-#{Time.now.to_s.gsub(" ", "-")}.png")
+
+      end
+
+      def sort_children_by_support(nodes)
+        lookup = item_order_lookup
+
+        nodes.sort_by! do |node|
+          lookup.fetch(node.item, lookup.size + 1)
+        end
+      end
+
+      def append_node(cursor_tree, node)
+        cursor_tree.children << node
+        node.parent = cursor_tree
+        sort_children_by_support(cursor_tree.children)
+        left = find_lateral_leaf_for_item(node.item)
+        if left == nil then
+          @heads[node.item] = node
+        else
+          left.lateral = node
+        end
+      end
+
+      def items_count
+        sum=0
+        for val in supports.values
+          sum+=val
+        end
+        return sum
+
+      end
+
+      def single_path?
+        is = true
+        cursor = @root
+        while is and cursor != nil
+          is = false if cursor.children.size > 1
+          cursor = cursor.children.first
+        end
+
+        return is
+      end
+
+      def combinations
+        raise "Tree contains multiple paths" unless single_path?
+        array = []
+        item = @root.children.first
+        while item != nil
+          array << item
+          item = item.children.first
+        end
+        yss = 1.upto(array.size).flat_map do |n|
+          array.combination(n).to_a
+        end
+      end
+
+      def empty?
+        return @heads.empty?
+      end
+
+    end
+  end
+end
+
+require_relative 'fp_tree/builder'

data/lib/fpgrowth/fp_tree/builder.rb

@@ -0,0 +1,19 @@
+require_relative 'builder/first_pass'
+require_relative 'builder/second_pass'
+
+
+module FpGrowth
+  module FpTree
+    module Builder
+
+      def self.build(transactions, threshold=1)
+        first_pass = FirstPass.new(threshold)
+        supports = first_pass.execute(transactions)
+        second_pass = SecondPass.new(supports, threshold)
+        tree = second_pass.execute(transactions)
+        return tree
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+require "fpgrowth/models/transaction"
+
+module FpGrowth
+  module FpTree
+    module Builder
+      class FirstPass
+
+        attr_accessor :supports
+
+        def initialize(threshold=1)
+
+          @supports = Hash.new 0
+          @threshold = threshold
+
+        end
+
+
+        # Scan data and find support for each item
+        # @param transactions FpGrowth::Transaction
+        #
+        #
+        def scan(transactions=@transactions)
+          @supports= Hash.new(0)
+          for transaction in transactions
+            for item in transaction
+              @supports[item] += 1
+            end
+
+          end
+          return @supports
+        end
+
+        # discard unfrequent items
+        # @param supports Hash
+        #
+        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
+          end
+          transactions.delete([])
+          supports.delete_if { |key, value| value < minimum }
+
+          return supports
+        end
+
+        # Ordonner les items en fonction de le support
+        # Cet ordre est utilisé pour la construction du Tree lors de la seconde passe
+        #
+        def sort(supports=@supports)
+          Hash[(supports.sort_by { |_key, value| value }.reverse)]
+        end
+
+        # Actually make the first pass
+        #
+        def execute(transactions, threshold=@threshold)
+          @transactions = transactions
+          @threshold = threshold
+          scan
+          pruning
+          sort
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+require 'fpgrowth/fp_tree'
+module FpGrowth
+  module FpTree
+    module Builder
+      class SecondPass
+
+        attr_accessor :fp_tree
+
+        def initialize(supports, threshold=1)
+          @supports = supports
+          @fp_tree = FpTree.new(supports, threshold)
+        end
+
+        def execute(transactions)
+          @fp_tree = FpTree.new(@supports)
+          for transaction in transactions
+            transaction = sort_by_support(transaction)
+            #Look for leaf
+            traverse(@fp_tree.root, transaction)
+
+          end
+          return @fp_tree
+        end
+
+        def sort_by_support(transaction)
+          lookup = @fp_tree.item_order_lookup
+
+          transaction.sort_by! do |item|
+            lookup.fetch(item, lookup.size + 1)
+          end
+        end
+
+
+
+        def traverse(cursor_tree, transaction)
+          if transaction and transaction.size > 0
+            found = false
+            if cursor_tree.item == transaction.first
+              continue_pattern(cursor_tree, transaction)
+              found = true
+            end
+            i = 0
+            while found == false and i < cursor_tree.children.size
+              if cursor_tree.children[i].item == transaction[0] then
+                continue_pattern(cursor_tree.children[i], transaction)
+                found = true
+              end
+              i+=1
+            end
+            fork_pattern(cursor_tree, transaction) unless found
+          end
+        end
+
+        def fork_pattern(cursor_tree, transaction)
+          node = Node.new(transaction.first, 1)
+          @fp_tree.append_node(cursor_tree, node)
+          cursor_tree = node
+          traverse(cursor_tree, transaction[1..transaction.size])
+        end
+
+
+        def continue_pattern(cursor_tree, transaction)
+          cursor_tree.support+=1
+          traverse(cursor_tree, transaction[1..transaction.size])
+        end
+
+      end
+    end
+  end
+end