similus 0.1.1

data/init.rb

@@ -0,0 +1,2 @@
+$:.unshift "#{File.dirname(__FILE__)}/lib"
+require 'similus'

data/lib/similus.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'redis'
+
+require File.join(File.dirname(__FILE__), 'similus', 'core.rb')
+require File.join(File.dirname(__FILE__), 'similus', 'config.rb')
+require File.join(File.dirname(__FILE__), 'similus', 'redis.rb')

data/lib/similus/config.rb

@@ -0,0 +1,24 @@
+module Similus
+  def self.config
+    @config ||= Config.new
+    block_given? ? yield(@config) : @config
+  end
+  
+  class Config
+    attr_accessor :backend
+    attr_accessor :redis_server
+    attr_accessor :redis_db
+    attr_accessor :logfile
+
+    def initialize #:nodoc:
+      self.backend      = :redis
+      self.redis_server = "localhost:6379"
+      self.redis_db     = 9
+      self.logfile      = STDOUT
+    end
+
+    def logger
+      @logger ||= Logger.new(logfile)
+    end
+  end
+end

data/lib/similus/core.rb

@@ -0,0 +1,220 @@
+require 'digest/sha1'
+
+module Similus
+  class << self 
+    def add_activity(a, action, b)
+      # Find or create objects
+      a = add_object(a)
+      b = add_object(b)
+
+      # Find or create action
+      action = add_action({:name => action})
+
+      # Create activities (both sides)
+      create_activities(a, action, b)
+      create_activities(b, action, a)
+    end
+
+    def similar_to(src, options={}, objects=nil)
+      sopt = {:source => :all, :load_objects => true}.update(options)
+      src = add_object(src)
+
+      objects ||= load_activity(src, options)
+
+      similar_objects = objects.inject(empty_hash) do |result, id|
+        redis.smembers("activity:#{id}").each { |similar| result[similar] += 1 }
+        result
+      end
+
+      similar_objects.delete(src[:obj_id])      # delete object itself form list
+      similar_objects.reject! { |k,v| v == 1 }   # remove similars just by one
+
+      if sopt[:load_objects] 
+        load_objects(similar_objects.sort { |x,y| y[1] <=> x[1] })
+      else
+        similar_objects
+      end
+    end
+
+    def recommended_for(src, options={}, &block)
+      default_options = { :load_objects => true, :max_similar => 10,
+                          :limit => 10, :offset => 0, :method => :similarity,
+                          :source => :all, :target => :all }
+
+      ropt = default_options.update(options)
+      sopt = options.merge(:load_objects => false)
+      maxs = ropt.delete(:max_similar)
+
+      # Find objects for user
+      src_act = load_activity(src, sopt)
+
+      # Get similar objects, sort and get first N elements
+      src_sim = similar_to(src, sopt, src_act).sort {|x,y| y[1] <=> x[1]}[0..maxs]
+
+      # Get recommended score of similar objects's activity
+      result = src_sim.inject(empty_hash) do |res, sim|
+        dst_act = redis.smembers("activity:#{sim[0]}")
+        rscore(ropt[:method], res, dst_act, src_act, sim[1], sim[0], &block)
+      end
+
+      # Remove already seen, sort and apply limit/offset
+      result.reject! { |key,value| src_act.include?(key) }
+      result = result.sort { |x,y| y[1] <=> x[1] }[ropt[:offset],ropt[:limit]]
+
+      # Load original objects
+      ropt[:load_objects] ? load_objects(result) : result
+    end
+
+    private
+
+    def add_class(obj)
+      obj = object_to_hash(obj)
+      obj[:class_id] = cached_value("class:#{obj[:class]}") do
+        safe_create("class", obj[:class])
+      end
+      obj
+    end
+
+    def add_object(obj)
+      obj = object_to_hash(obj)
+      # Find or create class
+      add_class(obj) unless obj[:class_id] 
+
+      # Find or create object
+      obj[:obj_id] = cached_value("object:#{obj[:class]}:#{obj[:id]}") do
+        safe_create('object', "#{obj[:class]}:#{obj[:id]}") do |id|
+          redis.hmset("object:#{id}", :id, obj[:id], :class_id, obj[:class_id])
+          redis.sadd("class:#{obj[:class_id]}:objects", id)
+        end
+      end
+      obj
+    end
+
+    def add_action(action)
+      action[:action_id] = cached_value("action:#{action[:name]}") do
+        safe_create("action", action[:name])
+      end
+      action
+    end
+
+    def create_activities(src, action, dst)
+      keys = [ activity_key(src[:obj_id]),
+               activity_key(src[:obj_id], action[:action_id]),
+               activity_key(src[:obj_id], action[:action_id], dst[:class_id]),
+               activity_key(src[:obj_id], nil, dst[:class_id])]
+
+      keys.each do |key|
+        redis.sadd "#{key}",   dst[:obj_id]                 # Set
+        redis.zadd "#{key}:s", Time.now.to_i, dst[:obj_id]  # Sorted List
+      end
+    end
+
+    def activity_key(obj_id, action_id=nil, class_id=nil)
+      str = "activity:#{obj_id}"
+      str << ":a:#{action_id}" if action_id
+      str << ":c:#{class_id}" if class_id
+      str
+    end
+
+    def load_activity(src, options)
+      aopt = { :source => :all,
+               :max_activity_objects => 20,
+             }.update(options)
+
+      last = aopt.delete(:max_activity_objects)
+
+      # Assign object and class ids
+      src = add_object(src)
+
+      # Retrieve last activity for obj
+      act_key = activity_key(src[:obj_id])
+      last ? redis.zrevrange("#{act_key}:s", 0, last-1) : redis.smembers(act_key)
+    end
+
+    # data_with_score is hash {key => score} or array [[key,score]]
+    def load_objects(data_with_score)
+      data_with_score = data_with_score.to_a if data_with_score.is_a?(Hash)
+      data_with_score.map do |item|
+        obj = redis.hgetall "object:#{item[0]}"
+        { :score             => item[1],
+          :id                => obj["id"],
+          :class             => redis.get("class:#{obj["class_id"]}")
+        }
+      end
+    end
+
+    def object_to_hash(obj)
+      case obj.class.to_s
+      when "Array"
+        {:class => obj[0], :id => obj[1]}
+      when "Hash"
+        obj
+      else
+        if obj.respond_to?(:id)
+          {:class => obj.class.to_s, :id => obj.id}
+        end
+      end
+    end
+
+    def empty_hash(default=0.0)
+      hash = Hash.new
+      hash.default = default
+      hash
+    end
+
+    def rscore(method, res, dst_act, src_act, src_sim_score, src_oid, &block)
+      if block_given?
+        params = [res, dst_act, src_act, src_sim_score, src_oid]
+        block.call(*(params[0..block.arity]))
+      else
+        case method
+        when :similarity
+          dst_act.each do |dst_oid|
+            res[dst_oid] += src_sim_score
+          end
+        when :jaccard
+          puts "Doing jaccard"
+          jf = jaccard_factor(src_act, dst_act)
+          dst_act.each do |dst_oid|
+            res[dst_oid] += 1000.0 * jf
+          end
+        when :jaccard_similarity
+          jf = jaccard_factor(src_act, dst_act)
+          dst_act.each do |dst_oid|
+            res[dst_oid] += src_sim_score * jf
+          end
+        end
+      end
+      res
+    end
+
+    def jaccard_factor(src,dst)
+      (src & dst).size.to_f / (src | dst).size.to_f
+    end
+
+    # Class level cache for objects
+    def cache
+      @cache ||= {}
+    end
+
+    def cached_value(key)
+      cache[key] ||= yield
+    end
+
+    def safe_create(base, value)
+      hash = Digest::SHA1.hexdigest(value.to_s)
+      hkey = "#{base}:#{hash}:id"
+      id   = redis.get(hkey)
+
+      unless id
+        id = redis.incr("next.#{base}.id").to_s(36) # use base 36 for ids to save space
+        unless redis.setnx(hkey, id)
+          id = redis.get(hkey)  # hash key created in between - revert to original value
+        else
+          block_given? ? yield(id) : redis.setnx("#{base}:#{id}", value)
+        end
+      end
+      id
+    end
+  end # class << self 
+end

data/lib/similus/redis.rb

@@ -0,0 +1,16 @@
+module Similus
+  def self.redis
+    @redis ||= begin
+      host, port = config.redis_server.split(':')
+      ::Redis.new(:host => host, :port => port, :db => config.redis_db)
+    rescue Exception => e
+      config.logger.error "Error connecting redis server: #{e.message}"
+      nil
+    end
+  end
+  
+  def self.clear_database!
+    @cache = {}
+    redis.flushdb
+  end
+end

data/similus.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{similus}
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Horaci Cuevas"]
+  s.cert_chain = ["/Users/horaci.cuevas/gem-public_cert.pem"]
+  s.date = %q{2010-10-07}
+  s.description = %q{A ruby library to find similar objects and make recommendations based on activity of objects}
+  s.email = %q{horaci @@ gmail.com}
+  s.extra_rdoc_files = ["LICENSES", "README.rdoc", "lib/similus.rb", "lib/similus/config.rb", "lib/similus/core.rb", "lib/similus/redis.rb"]
+  s.files = ["LICENSES", "README.rdoc", "Rakefile", "benchmarks/benchmark1.rb", "benchmarks/benchmark2.rb", "benchmarks/custom_benchmark.rb", "benchmarks/redis.conf", "init.rb", "lib/similus.rb", "lib/similus/config.rb", "lib/similus/core.rb", "lib/similus/redis.rb", "test/add_activity_spec.rb", "test/recommended_spec.rb", "test/similar_spec.rb", "Manifest", "similus.gemspec"]
+  s.homepage = %q{http://github.com/horaci/similus}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Similus", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{similus}
+  s.rubygems_version = %q{1.3.7}
+  s.signing_key = %q{/Users/horaci.cuevas/gem-private_key.pem}
+  s.summary = %q{A ruby library to find similar objects and make recommendations based on activity of objects}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/test/add_activity_spec.rb

@@ -0,0 +1,37 @@
+$: << File.join(File.dirname(__FILE__), "/../lib")
+
+require 'similus'
+
+describe "Similus" do
+  describe "Add activity" do
+    before(:all) do
+      # Clear redis
+      Similus.clear_database!
+
+      # Activity
+      Similus.add_activity(["User", 1], :view, ["Movie", "Star Wars 1"])
+    end
+
+    def redis_object(type,object)
+      object_hash = Digest::SHA1.hexdigest(object)
+      Similus.redis.get("#{type}:#{object_hash}:id")
+    end
+
+    it "should create classes in redis" do
+      redis_object("class", "User").should_not be_nil
+      redis_object("class", "Movie").should_not be_nil
+      redis_object("class", "Other").should be_nil
+    end
+
+    it "should create objects in redis" do
+      redis_object("object", "User:1").should_not be_nil
+      redis_object("object", "Movie:Star Wars 1").should_not be_nil
+      redis_object("object", "User:2").should be_nil
+    end
+
+    it "should create actions in redis" do
+      redis_object("action", "view").should_not be_nil
+      redis_object("action", "like").should be_nil
+    end
+  end
+end

data/test/recommended_spec.rb

@@ -0,0 +1,104 @@
+$: << File.join(File.dirname(__FILE__), "/../lib")
+require 'similus'
+
+describe "Similus" do
+  before(:all) do
+    # Clear redis
+    Similus.clear_database!
+
+    Similus.add_activity(["User", 1], :view, ["Movie", "Star Wars 1"])
+    Similus.add_activity(["User", 1], :view, ["Movie", "Star Wars 2"])
+    Similus.add_activity(["User", 1], :view, ["Movie", "Star Wars 3"])
+    Similus.add_activity(["User", 1], :view, ["Movie", "Star Wars 4"])
+
+    Similus.add_activity(["User", 2], :view, ["Movie", "Star Wars 3"])
+    Similus.add_activity(["User", 2], :view, ["Movie", "Star Wars 4"])
+    Similus.add_activity(["User", 2], :view, ["Movie", "Star Wars 5"])
+
+    Similus.add_activity(["User", 3], :view, ["Movie", "Star Wars 1"])
+    Similus.add_activity(["User", 3], :view, ["Movie", "Star Wars 3"])
+    Similus.add_activity(["User", 3], :view, ["Movie", "Star Wars 5"])
+
+    Similus.add_activity(["User", 4], :view, ["Movie", "Star Wars 2"])
+    Similus.add_activity(["User", 4], :view, ["Movie", "Star Wars 3"])
+
+    Similus.add_activity(["User", 5], :view, ["Movie", "Star Wars 1"])
+    Similus.add_activity(["User", 5], :view, ["Movie", "Star Wars 2"])
+    Similus.add_activity(["User", 5], :view, ["Movie", "Star Wars 3"])
+    Similus.add_activity(["User", 5], :view, ["Movie", "Blade Runner"])
+
+    Similus.add_activity(["User", 6], :view, ["Movie", "Star Wars 1"])
+    Similus.add_activity(["User", 6], :view, ["Movie", "Star Wars 5"])
+    Similus.add_activity(["User", 6], :view, ["Movie", "Blade Runner"])
+
+    Similus.add_activity(["User", 7], :view, ["Movie", "Casablanca"])
+  end
+
+  describe "#recommended_for" do
+    describe "User 1" do
+      before(:all) do
+        @recommended_for_user_1 = Similus.recommended_for(["User", 1])
+      end
+
+      it "should recommend SW5 and then Blade Runner" do
+        @recommended_for_user_1[0][:id].should == "Star Wars 5"
+        @recommended_for_user_1[0][:score].should == 4.0
+        @recommended_for_user_1[1][:id].should == "Blade Runner"
+        @recommended_for_user_1[1][:score].should == 3.0
+      end
+
+      it "should not recommend Casablanca" do
+        @recommended_for_user_1.detect { |x| x[:id] == "Casablanca" }.should be_nil
+      end
+    end
+
+    describe "other users" do
+      before(:all) do
+        @recommended_for_user_2 = Similus.recommended_for(["User", 2])
+        @recommended_for_user_3 = Similus.recommended_for(["User", 3])
+        @recommended_for_user_4 = Similus.recommended_for(["User", 4])
+        @recommended_for_user_5 = Similus.recommended_for(["User", 5])
+        @recommended_for_user_6 = Similus.recommended_for(["User", 6])
+        @recommended_for_user_7 = Similus.recommended_for(["User", 7])
+      end
+
+      it "should recommend only SW1 and then SW2 to user2 but not blade runner" do
+        @recommended_for_user_2[0][:id].should == "Star Wars 1"
+        @recommended_for_user_2[0][:score].should == 4.0
+        @recommended_for_user_2[1][:id].should == "Star Wars 2"
+        @recommended_for_user_2[1][:score].should == 2.0
+        @recommended_for_user_2.detect { |x| x[:id] == "Blade Runner" }.should be_nil
+      end
+
+      it "should recommend only BR and SW4 and SW2 to user3" do
+        @recommended_for_user_3.detect { |x| x[:id] == "Blade Runner" }.should_not be_nil
+        @recommended_for_user_3.detect { |x| x[:id] == "Star Wars 4" }.should_not be_nil
+        @recommended_for_user_3.detect { |x| x[:id] == "Star Wars 2" }.should_not be_nil
+      end
+
+      it "should recommend first SW1 and then SW4 and BR to user4" do
+        @recommended_for_user_4.first[:id].should == "Star Wars 1"
+        @recommended_for_user_4.detect { |x| x[:id] == "Blade Runner" }.should_not be_nil
+        @recommended_for_user_4.detect { |x| x[:id] == "Star Wars 4" }.should_not be_nil
+      end
+
+      it "should recommend first SW5 and then SW4 to user5" do
+        @recommended_for_user_5[0][:id].should == "Star Wars 5"
+        @recommended_for_user_5[0][:score].should == 4.0
+        @recommended_for_user_5[1][:id].should == "Star Wars 4"
+        @recommended_for_user_5[1][:score].should == 3.0
+      end
+
+      it "should recommend first SW3 and then SW2 to user6" do
+        @recommended_for_user_6[0][:id].should == "Star Wars 3"
+        @recommended_for_user_6[0][:score].should == 4.0
+        @recommended_for_user_6[1][:id].should == "Star Wars 2"
+        @recommended_for_user_6[1][:score].should == 2.0
+      end
+
+      it "should recommend nothing to user7" do
+        @recommended_for_user_7.should be_empty
+      end
+    end
+  end
+end