tyler-collaborative_filter 0.5.0

data/lib/collaborative_filter/output.rb

@@ -0,0 +1,13 @@
+class CollaborativeFilter
+  class Output
+    def self.store(options, recommendations)
+      @@adapters[options[:type]].new(options[:options], recommendations)
+    end
+
+    def self.register(name, class_name)
+      @@adapters ||= {}
+      @@adapters[name] = class_name
+    end
+  end
+end
+

data/lib/collaborative_filter/output/mysql_adapter.rb

@@ -0,0 +1,42 @@
+class CollaborativeFilter
+  class Output
+    class SqlAdapter
+      CollaborativeFilter::Output.register :sql, self
+
+      def initialize(options, recommendations)
+        setup_mapping options[:mapping] || {}
+        recommendations.each do |user_id, recs|
+          next if recs.empty?
+          ActiveRecord::Base.connection.execute \
+            "INSERT INTO #{options[:table_name]} (#{@mapping_values.join(',')}) VALUES #{records_to_sql(user_id, recs)}"
+        end
+      end
+
+      def setup_mapping(config_mapping)
+        @mapping = { :user_id => :user_id, 
+          :user_type => nil,
+          :item_id => :item_id,
+          :item_type => :item_type,
+          :score => :score }
+        @mapping.merge!(config_mapping)
+        @mapping.each { |k,v| @mapping.delete(k) unless v }
+        ma = @mapping.to_a
+        @mapping_keys = ma.map(&:first)
+        @mapping_values = ma.map(&:last)
+      end
+
+      def records_to_sql(user_id, recs)
+        recs.map { |item_id, score|
+          data = {}
+          data[:user_id] = user_id
+          data[:user_id], data[:user_type] = data[:user_id] if data[:user_id].is_a?(Array)
+          data[:item_id] = item_id
+          data[:item_id], data[:item_type] = data[:item_id] if data[:item_id].is_a?(Array)
+          data[:score] = score
+
+         '(' + @mapping_keys.map { |key| "'#{data[key]}'" }.join(',') + ')'
+        }.join(',')
+      end
+    end
+  end
+end

data/lib/collaborative_filter/output/yaml_adapter.rb

@@ -0,0 +1,13 @@
+class CollaborativeFilter
+  class Output
+    class YamlAdapter
+      CollaborativeFilter::Output.register :yaml, self
+
+      def initialize(options, recommendations)
+        require 'yaml'
+        filename = options[:filename] || 'recommendations.yml'
+        File.open(filename,'w') { |f| f << recommendations.to_yaml }
+      end
+    end
+  end
+end

data/lib/correlators/simple_svd.rb

@@ -0,0 +1,55 @@
+# A correlator helps us find users who are similar to each other.  There are
+# a crapton of ways to accomplish this.  In this case we're using a 
+# singular-value-decomposition algorithm.  In essence, we decompose the matrix
+# of user-item nodes (where nodes are rating, purchases, etc) into two matrices
+# U and V, and their singular values S.  We take the first two columns of
+# V-transpose and plot them in 2-dimensional space as if the corresponding
+# entries in the columns were X and Y coordinates.  This will clump the users
+# into groups.  A simple, and moderately accurate, way to find those groups
+# is to find the cosine similarities of the different users.
+#
+# So the correlator takes a sparse matrix, a users array, an items array, and
+# options.  It outputs a hash that looks like...
+#
+# { user_id => [[cos_sim, sim_user_1], [cos_sim, sim_user_2], ...] }
+class CollaborativeFilter
+  class SimpleSvd
+    def run(matrix,users,items,options)
+      qty = 0
+
+      u,v,s = matrix.svd
+
+      # we use the transpose of the V matrix
+      xs,ys = [v.transpose.col(0).to_a, v.transpose.col(1).to_a]
+
+      # precompute some of the terms from the cos. sim function. thanks pete!
+      precomputes = []
+      xs.each_index { |i| precomputes << Math.sqrt((xs[i] * xs[i]) + (ys[i] * ys[i])) }
+
+      similar_users = {}
+      # compute the similarities between each user and each other user currently this is O(n^2)... 
+      # there is one major improvement that could be made to it... which is to cache the results
+      xs.each_index do |user_idx|
+        x1, y1 = xs[user_idx], ys[user_idx]
+        sims = []
+        xs.each_index do |target_idx|
+          next if user_idx == target_idx
+          x2, y2 = xs[target_idx], ys[target_idx]
+
+          # compute the cosine similarity between user and target
+          sim = ((x1 * x2) + (y1 * y2)) / (precomputes[user_idx] * precomputes[target_idx])
+
+          sims << [target_idx, sim] if sim >= options[:cosine_similarity] 
+        end
+
+        x = sims.sort_by(&:last).reverse[0, (options[:max_similar_users] || sims.size)]
+        qty += x.size
+        similar_users[user_idx] = x
+      end
+
+      CollaborativeFilter.log "    Average sims per user: #{qty.to_f / similar_users.size}"
+      similar_users
+    end
+  end
+end
+

data/lib/recommenders/simplest_recommender.rb

@@ -0,0 +1,92 @@
+class CollaborativeFilter
+  # Given any number of similarity hashes of a particular form recommend Items
+  # for Users. Weights according to cosine similarity of the recommendation and
+  # the cosine similarity threshold. 
+  #
+  # Example:
+  #   Threshold is set to 0.9.  This particular recommendation is 0.95.
+  #   1.0 - 0.9 = 0.1
+  #   0.95 - 0.9 = 0.5
+  #   0.5 / 0.1 = 0.5 = 50%
+  #   So the 0.95 rec would be worth 50%.
+  #
+  # The purpose of this of course, is for the case when you are similar to multiple
+  # users who have rated a certain item differently.  If you are highly correlated to
+  # Bob, and slightly correlated to Joe... and Bob rated X as 5 stars, and Joe rated 
+  # X as 2 stars... Bob's rating should carry more weight in determining your
+  # recommendation.
+  #
+  # Sim hashes look like: { (user_identifier) => [[(closeness),(user_identifier)], ...] }
+  #
+  # Input:
+  #   Array of DataSet objects, with #similarities populated
+  #
+  # Output:
+  #   Array in the form:
+  #     [ [ (user id), [ [ (item id), (score) ], ... ] ], ... ]
+  class SimplestRecommender
+    def run(datasets, options)
+      options[:threshold] ||= 4.2
+
+      datasets.inject({}) { |ratings,(name,ds)| 
+        mult = 1.0 - ds.options[:cosine_similarity]
+        ds.similarities.each do |user_idx,sim_list|
+          ratings[ds.users[user_idx]] ||= {}
+          blacklist = generate_blacklist(user_idx,ds)
+          sim_list.each do |sim_idx,similarity|
+            # grab the list of the similar users' item ratings
+            ds.m.col(sim_idx).to_a.each_with_index do |score,item_idx|
+              next if score == 0 || blacklist.include?(item_idx)
+
+              # need to use the item_id instead of idx so the content booster can find
+              # its own index of it.
+              item_id = ds.items[item_idx]
+
+              ratings[ds.users[user_idx]][item_id] ||= []
+              ratings[ds.users[user_idx]][item_id] << [score, (similarity - ds.options[:cosine_similarity]) * mult]
+            end
+          end
+        end
+        ratings
+      }.map { |c,rlists|
+        averaged_ratings = rlists.map { |i,rs| 
+          score_sum, sim_sum = rs.inject([0,0]) { |sums,(score,similarity)| [sums.first + score, sums.last + similarity] }
+          [i, score_sum / sim_sum] 
+        }.select { |k,v| 
+          v >= options[:threshold]
+        }.sort { |(k1,v1),(k2,v2)| v2 <=> v1 }[0,options[:max_per_user]]
+        [c, averaged_ratings]
+      }
+    end
+
+    def generate_blacklist(user_idx,ds)
+      blacklist = []
+      ratings = ds.m.col(user_idx).to_a
+      ds.items.each_index { |idx| blacklist << idx if ratings[idx] != 0 }
+      blacklist
+    end
+
+    # We don't want to recommend things that people have already rated, purchased, or subscribed to.
+    # Not used at the moment
+    def generate_blacklists(ds)
+      blacklists = []
+      ds.users.each_with_index do |user_id, user_idx|
+        blacklist = []
+        ds.m.col(user_idx).to_a.each_with_index { |r,i| blacklist << ds.items[i] if r == 0 }
+
+        #user = Customer.find(user_id)
+
+        #user.subscription_list && 
+        #  user.subscription_list.subscriptions.each { |sub| blacklist << [sub.subscribable_id, sub.subscribable_type] }
+
+        #user.orders.map(&:line_items).flatten.each do |li|
+        #  blacklist << [li.product_id, li.product_type]
+        #  blacklist << [li.product.title_id, 'Title'] if li.product.respond_to?(:title)
+        #end
+        blacklists << blacklist
+      end
+      blacklists
+    end
+  end
+end
+

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: tyler-collaborative_filter
+version: !ruby/object:Gem::Version 
+  version: 0.5.0
+platform: ruby
+authors: 
+- Tyler McMullen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-09 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: A Collaborative Filtering framework in Ruby.
+email: tbmcmullen@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.textile
+- LICENSE
+- Rakefile
+- lib/boosters/simple_booster.rb
+- lib/collaborative_filter/config.rb
+- lib/collaborative_filter/content_booster.rb
+- lib/collaborative_filter/data_set.rb
+- lib/collaborative_filter/output
+- lib/collaborative_filter/output/mysql_adapter.rb
+- lib/collaborative_filter/output/yaml_adapter.rb
+- lib/collaborative_filter/output.rb
+- lib/collaborative_filter.rb
+- lib/correlators/simple_svd.rb
+- lib/recommenders/simplest_recommender.rb
+has_rdoc: false
+homepage: http://github.com/tyler/collaborative_filter
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A Collaborative Filtering framework in Ruby.
+test_files: []
+