conductor 0.6.5 → 0.7.0

data/VERSION

@@ -1 +1 @@
-0.6.5
+0.7.0

data/lib/conductor.rb

@@ -15,7 +15,8 @@ class Conductor
   DBG = false
 
   cattr_writer :cache
-
+  cattr_writer :days_till_weighting
+  
   def self.cache
     @@cache || Rails.cache
   end
@@ -28,16 +29,29 @@ class Conductor
     def identity
       return (@conductor_identity || ActiveSupport::SecureRandom.hex(16))
     end
+    
+    def minimum_launch_days
+      return (@@days_till_weighting || MINIMUM_LAUNCH_DAYS)
+    end
+    
+    def attribute_for_weighting=(value)
+      raise "Conductor.attribute_for_weighting must be either :views, :conversions or :conversion_value (default)" unless [:views, :conversions, :conversion_value].include?(value) 
+      @attribute_for_weighting = value
+    end
+    
+    def attribute_for_weighting
+      return (@attribute_for_weighting || :conversion_value)
+    end
 
     def log(msg)
       puts msg if DBG
     end
-    
+
     def sanitize(str)
       str.gsub(/\s/,'_').downcase
     end
   end
-  
+
 end
 
 
@@ -45,4 +59,17 @@ class Array
   def sum_it(attribute)
     self.map {|x| x.send(attribute) }.compact.sum
   end
+
+  def weighted_mean_of_attribute(attribute)
+    self.map {|x| x.send(attribute) }.compact.weighted_mean
+  end
+
+  def weighted_mean
+    w_sum = sum(self)
+    return 0.00 if w_sum == 0.00
+    
+    w_prod = 0
+    self.each_index {|i| w_prod += (i+1) * self[i].to_f}
+    w_prod.to_f / w_sum.to_f
+  end
 end

data/lib/conductor/weights.rb

@@ -6,7 +6,7 @@ class Conductor
       # group do not match all the alternatives previously computed for the group, new weights are
       # generated.  The cache is used to speed up this check
       def find_or_create(group_name, alternatives)
-        weights_for_group = Conductor.cache.read("Conductor::Experiment::#{group_name}::Alternatives")
+        weights_for_group = Conductor.cache.read("Conductor::Experiment::#{Conductor.attribute_for_weighting}::#{group_name}::Alternatives")
 
         alternatives_array = weights_for_group.map(&:alternative).sort if weights_for_group
         if alternatives_array.eql?(alternatives.sort)
@@ -18,8 +18,8 @@ class Conductor
 
           # get the new weights
           weights_for_group = Conductor::Experiment::Weight.find(:all, :conditions => "group_name = '#{group_name}'")
-          Conductor.cache.delete("Conductor::Experiment::#{group_name}::Alternatives")
-          Conductor.cache.write("Conductor::Experiment::#{group_name}::Alternatives", weights_for_group)
+          Conductor.cache.delete("Conductor::Experiment::#{Conductor.attribute_for_weighting}::#{group_name}::Alternatives")
+          Conductor.cache.write("Conductor::Experiment::#{Conductor.attribute_for_weighting}::#{group_name}::Alternatives", weights_for_group)
           return weights_for_group
         end
       end
@@ -33,7 +33,7 @@ class Conductor
 
         unless group_rows.empty?
           Conductor::Experiment::Weight.delete_all(:group_name => group_name) # => remove all old data for group
-          total = group_rows.sum_it(:conversion_value)
+          total = group_rows.sum_it(Conductor.attribute_for_weighting)
           data = total ? compute_weights_for_group(group_name, group_rows, total) : assign_equal_weights(group_rows)
           update_weights_in_db(group_name, data)
         end
@@ -46,46 +46,50 @@ class Conductor
         def compute_weights_for_group(group_name, group_rows, total)
           data = []
           recently_launched = []
-          max_weight = 0
+          
+          # calculate weights for each alternative
+          weighted_moving_avg, total, max_weight = compute_weighted_moving_stats(group_rows)
 
           group_rows.group_by(&:alternative).each do |alternative_name, alternatives|
-            first_found_date = alternatives.map(&:activity_date).sort.first
-            days_ago = Date.today - first_found_date
+            days_ago = compute_days_ago(alternatives)
 
-            if days_ago >= MINIMUM_LAUNCH_DAYS
-              data << compute_weight_for_alternative(alternative_name, alternatives, max_weight, total)
+            if days_ago >= Conductor.minimum_launch_days
+              data << {:name => alternative_name, :weight => (weighted_moving_avg[alternative_name] / total)}
             else
-              Conductor.log("adding #{alternative_name} to recently launched array")
               recently_launched << {:name => alternative_name, :days_ago => days_ago}
             end
           end
 
-          data += weight_recently_launched(max_weight, recently_launched)
+          weight_recently_launched(data, max_weight, recently_launched)
           return data
         end
 
-        def compute_weight_for_alternative(alternative_name, alternatives, max_weight, total)
-          Conductor.log("compute_weight_for_alternative for #{alternative_name}")
-
-          aggregates = {:name => alternative_name}
-
-          weight = alternatives.sum_it(:conversion_value) / total
-          max_weight = weight if weight > max_weight
-          aggregates.merge!({:weight => weight})
-
-          return aggregates
+        def compute_weighted_moving_stats(group_rows)
+          weighted_moving_avg = {}
+          group_rows.group_by(&:alternative).each do |alternative_name, alternatives|
+            weighted_moving_avg.merge!({"#{alternative_name}" => alternatives.sort_by(&:activity_date).weighted_mean_of_attribute(Conductor.attribute_for_weighting)}) 
+          end
+          
+          # calculate total and max_weight for weighted moving averages
+          total = weighted_moving_avg.values.sum
+          max_weight = weighted_moving_avg.values.max
+          
+          return weighted_moving_avg, total, max_weight
+        end
+        
+        def compute_days_ago(alternatives)
+          first_found_date = alternatives.map(&:activity_date).min
+          (Date.today - first_found_date.to_date).to_f
         end
 
-        def weight_recently_launched(max_weight, recently_launched)
+        def weight_recently_launched(data, max_weight, recently_launched)
           # loop through recently_launched to create weights for table
           # the handicap sets a newly launched item to the max weight * MAX_WEIGHTING_FACTOR and then
           # slowly lowers its power until the launch period is over
-          data = []
-          max_weight = 0 ? 1 : max_weight # => if a max weight could not be computed, set it to 1
-          Conductor.log("max weight: #{max_weight}")
+          max_weight = 1 if data.empty?
           recently_launched.each do |alternative|
-            handicap = (alternative[:days_ago].to_f / MINIMUM_LAUNCH_DAYS)
-            launch_window = (MINIMUM_LAUNCH_DAYS - alternative[:days_ago]) if MINIMUM_LAUNCH_DAYS > alternative[:days_ago]
+            handicap = (alternative[:days_ago].to_f / Conductor.minimum_launch_days)
+            launch_window = (Conductor.minimum_launch_days - alternative[:days_ago]) if Conductor.minimum_launch_days > alternative[:days_ago]
             Conductor.log("Handicap for #{alternative[:name]} is #{handicap} (#{alternative[:days_ago]} days ago)")
             data << {:name => alternative[:name], :weight => max_weight * MAX_WEIGHTING_FACTOR * (1 - handicap), :launch_window => launch_window}
           end

data/test/test_conductor.rb

@@ -22,6 +22,15 @@ class TestConductor < Test::Unit::TestCase
       x = Conductor.cache.read('testing')
       assert_equal x, 'value'
     end
+    
+    should "allow for the minimum_launch_days to be configurable" do
+      Conductor.days_till_weighting = 3
+      assert_equal(3, Conductor.minimum_launch_days)
+    end
+    
+    should "raise an error if an improper attribute is specified for @@attribute_for_weighting" do
+      assert_raise(RuntimeError, LoadError) { Conductor.attribute_for_weighting = :random}
+    end
 
     should "almost equally select each option if no weights exist" do
       a = 0
@@ -169,11 +178,11 @@ class TestConductor < Test::Unit::TestCase
 
       # hit after rollup to populare weight table
       Conductor.identity = ActiveSupport::SecureRandom.hex(16)
+      Conductor.days_till_weighting = 7
       selected = Conductor::Experiment.pick('a_group', ["a", "b", "c"])
 
-      # this makes the following assumptions:
-      # MINIMUM_LAUNCH_DAYS = 7
       # each weight will be equal to 0.18
+      assert_equal 7, Conductor.minimum_launch_days
       assert_equal 0.54, Conductor::Experiment::Weight.all.sum_it(:weight).to_f
     end
   end
@@ -225,6 +234,30 @@ class TestConductor < Test::Unit::TestCase
       assert_not_nil Conductor::Experiment::History.find(:all, :conditions => 'launch_window > 0')
     end
   end
+  
+  context "conductor" do
+    setup do
+      seed_raw_data(500, 30)
+
+      # rollup
+      Conductor::RollUp.process
+    end
+    
+    should "allow for the number of conversions to be used for weighting instead of conversion_value" do
+      Conductor.identity = ActiveSupport::SecureRandom.hex(16)
+      Conductor::Experiment.pick('a_group', ["a", "b", "c"])
+      weights_cv = Conductor::Experiment::Weight.all.map(&:weight).sort
+
+      Conductor.identity = ActiveSupport::SecureRandom.hex(16)
+      Conductor.attribute_for_weighting = :conversions
+      Conductor::Experiment.pick('a_group', ["a", "b", "c"])
+      weights_c = Conductor::Experiment::Weight.all.map(&:weight).sort
+      
+      # since one is using conversion_value and the other is using conversions, they two weight arrays should be different
+      assert_equal :conversions, Conductor.attribute_for_weighting
+      assert_not_equal weights_cv, weights_c
+    end
+  end  
 
 
   private

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 6
-  - 5
-  version: 0.6.5
+  - 7
+  - 0
+  version: 0.7.0
 platform: ruby
 authors: 
 - Noctivity
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-01 00:00:00 -04:00
+date: 2010-10-03 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency