conductor 0.7.2 → 0.8.1

data/VERSION

@@ -1 +1 @@
-0.7.2
+0.8.1

data/lib/conductor.rb

@@ -32,6 +32,19 @@ class Conductor
       return (@conductor_identity || ActiveSupport::SecureRandom.hex(16))
     end
     
+    # The number of days to include when calculating weights
+    # The inclusion period MUST be higher than then equalization period
+    # The default is 14 days
+    def inclusion_period=(value)
+      raise "Conductor.inclusion_period must be a positive number > 0" unless value.is_a?(Numeric) && value > 0
+      raise "Conductor.inclusion_period must be greater than the equalization period" if value < equalization_period
+      @inclusion_period = value
+    end
+    
+    def inclusion_period
+      return (@inclusion_period || 14)
+    end
+    
     # The equalization period is the initial amount of time, in days, that conductor 
     # should apply the max_weighting_factor towards a new alternative to ensure 
     # that it receives a far shot of performing.

data/lib/conductor/experiment/daily.rb

@@ -13,7 +13,41 @@
 
 class Conductor::Experiment::Daily < ActiveRecord::Base
   set_table_name "conductor_daily_experiments"
+
   named_scope :since, lambda { |a_date| { :conditions =>  ['activity_date >= ?',a_date] }}
   named_scope :for_group, lambda { |group_name| { :conditions =>  ['group_name = ?',group_name] }}
-  
+
+  def self.find_equalization_period_stats_for(group_name, alternatives=nil)
+    alternative_filter = alternatives ? alternatives.inject([]) {|res,x| res << "alternative = '#{Conductor.sanitize(x)}'"}.join(' OR ') : 'true'
+
+    sql = "SELECT alternative, min(activity_date) AS activity_date
+        FROM conductor_daily_experiments 
+        WHERE group_name = '#{group_name}'
+        AND (#{alternative_filter})
+        GROUP BY alternative
+        HAVING min(activity_date) > '#{Date.today - Conductor.equalization_period}'"
+        
+    self.find_by_sql(sql)
+  end
+
+
+  def self.find_post_equalization_period_stats_for(group_name, alternatives=nil)
+    alternative_filter = alternatives ? alternatives.inject([]) {|res,x| res << "alternative = '#{Conductor.sanitize(x)}'"}.join(' OR ') : 'true'
+
+    sql = "SELECT alternative, min(activity_date) AS activity_date, sum(views) AS views, sum(conversions) AS conversions, sum(conversion_value) AS conversion_value
+    FROM conductor_daily_experiments
+    WHERE group_name = '#{group_name}'
+    AND (#{alternative_filter})
+    AND activity_date >=  
+      (SELECT max(min_date) FROM 
+        (SELECT alternative, min(activity_date) AS min_date 
+        FROM conductor_daily_experiments 
+        WHERE activity_date >= '#{Date.today - Conductor.inclusion_period}'
+        GROUP BY alternative) AS a)
+    GROUP BY alternative 
+    HAVING min(activity_date) <= '#{Date.today - Conductor.equalization_period}'"
+    
+    self.find_by_sql(sql)
+  end
+
 end

data/lib/conductor/experiment/weight.rb

@@ -12,4 +12,7 @@
 
 class Conductor::Experiment::Weight < ActiveRecord::Base
   set_table_name "conductor_weighted_experiments"
+
+  named_scope :for_group, lambda { |group_name| { :conditions =>  ['group_name = ?',group_name] }}
+  named_scope :with_alternative, lambda { |alternative| { :conditions =>  ['alternative = ?',alternative] }}
 end

data/lib/conductor/helpers/dashboard_helper.rb

@@ -10,6 +10,11 @@ module DashboardHelper
     return Gchart.pie(:data => data, :legend => legend, :size => '600x200')
   end
   
+  def get_weight(group_name, alternative_name)
+    itm = Conductor::Experiment::Weight.for_group(group_name).with_alternative(alternative_name)
+    return itm.first.weight if itm &&  itm.first
+  end
+  
   def daily_stats(group_name, group)
     data = []
     legend = []

data/lib/conductor/views/dashboard/_group_stats.html.haml

@@ -0,0 +1,23 @@
+%a{:name => "group_stats"}
+%h2 Experiment Statistics
+- @dailies.group_by(&:group_name).each do |group_name, group|
+  .group
+    %fieldset
+      %legend= group_name
+      %table
+        %tr
+          %th Alternative
+          %th Views
+          %th Conversions
+          %th Value
+          %th Value per Conv
+          %th Weight
+        - group.group_by(&:alternative).sort.each do |alternative_name, alternative_data|
+          %tr
+            %td.name= alternative_name
+            %td.views= alternative_data.sum_it(:views)
+            %td.conversions= alternative_data.sum_it(:conversions)
+            %td.value= alternative_data.sum_it(:conversion_value)
+            %td.norm= ("%0.2f" % (alternative_data.sum_it(:conversion_value).to_f / alternative_data.sum_it(:conversions).to_f))
+            %td.weight
+              %b= get_weight(group_name, alternative_name)

data/lib/conductor/views/dashboard/_top_nav.html.haml

@@ -1,3 +1,4 @@
 .nav= link_to "Current Experiment Weights", '#current_weights'
-.nav= link_to "Experiment Statistics", '#daily_stats'
+.nav= link_to "Experiment Statistics", '#group_stats'
+.nav= link_to "Daily Statistics", '#daily_stats'
 .nav.last= link_to "Experiment Weight History", '#weight_history'

data/lib/conductor/views/dashboard/index.html.haml

@@ -22,6 +22,7 @@
 
       .top_nav= render :file => 'dashboard/_top_nav'
       #weights= render :file => 'dashboard/_current_weights'
+      #group_stats= render :file => 'dashboard/_group_stats'
       #dailies= render :file => 'dashboard/_daily_stats'
       #history= render :file => 'dashboard/_weight_history'
 

data/lib/conductor/weights.rb

@@ -24,83 +24,59 @@ class Conductor
         end
       end
 
-      # Computes the weights for a group based on the attribute for weighting and 
-      # activity for the last two weeks.
+      # Computes the weights for a group based on the attribute for weighting and
+      # activity for the inclusion period.
       #
-      # If no conversions have taken place yet for a group, all alternatives are weighted 
+      # If no conversions have taken place yet for a group, all alternatives are weighted
       # equally.
       #
       # TODO: add notification table and all notification if there are no conversions and we are out of the equalization period
       def compute(group_name, alternatives)
-        # create the conditions after sanitizing sql.
-        alternative_filter = alternatives.inject([]) {|res,x| res << "alternative = '#{Conductor.sanitize(x)}'"}.join(' OR ')
-
-        # pull daily data and recompute if daily data
-        group_rows = Conductor::Experiment::Daily.since(14.days.ago).for_group(group_name).find(:all, :conditions => alternative_filter)
-
-        unless group_rows.empty?
-          Conductor::Experiment::Weight.delete_all(:group_name => group_name) # => remove all old data for group
-          total = group_rows.sum_it(Conductor.attribute_for_weighting)
-          data = total > 0 ? compute_weights_for_group(group_name, group_rows, total) : assign_equal_weights(group_rows)
-          update_weights_in_db(group_name, data)
+        Conductor::Experiment::Weight.delete_all(:group_name => group_name)
+        
+        data = []
+        equalization_period_data = Conductor::Experiment::Daily.find_equalization_period_stats_for(group_name, alternatives)
+        post_equalization_data = Conductor::Experiment::Daily.find_post_equalization_period_stats_for(group_name, alternatives)
+
+        # handle all post_equalization_data
+        max_weight = 0
+        unless post_equalization_data.empty?
+          total = post_equalization_data.sum_it(Conductor.attribute_for_weighting)
+          data = (total > 0) ? compute_weights(post_equalization_data, total, max_weight) : assign_equal_weights(post_equalization_data)
         end
+
+        # add weights for recently launched
+        weight_recently_launched(data, max_weight, equalization_period_data) unless equalization_period_data.empty?
+        
+        # add to database
+        update_weights_in_db(group_name, data)
       end
 
       private
 
-        # loops through all the alternatives for a given group and computes the weights for
-        # each alternative
-        def compute_weights_for_group(group_name, group_rows, total)
+        def compute_weights(post_equalization_data, total, max_weight)
           data = []
-          recently_launched = []
-          
-          # 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|
-            days_ago = compute_days_ago(alternatives)
-
-            if days_ago >= Conductor.equalization_period
-              data << {:name => alternative_name, :weight => (weighted_moving_avg[alternative_name] / total)}
-            else
-              recently_launched << {:name => alternative_name, :days_ago => days_ago}
-            end
-          end
-
-          weight_recently_launched(data, max_weight, recently_launched)
-          return data
-        end
-
-        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
+          post_equalization_data.each {|x|
+            weight = (x.send(Conductor.attribute_for_weighting).to_f / total.to_f)
+            max_weight = weight if weight > max_weight
+            data << {:name => x.alternative, :weight => weight}
+          }
+          data
         end
 
-        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
+        # 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
+        def weight_recently_launched(data, max_weight, equalization_period_data)
           max_weight = 1 if data.empty?
-          recently_launched.each do |alternative|
-            handicap = (alternative[:days_ago].to_f / Conductor.equalization_period)
-            launch_window = (Conductor.equalization_period - alternative[:days_ago]) if Conductor.equalization_period > 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}
+          equalization_period_data.each do |x|
+            days_ago = (Date.today - x.activity_date)
+            handicap = (days_ago.to_f / Conductor.equalization_period)
+            launch_window = (Conductor.equalization_period - days_ago) 
+            
+            Conductor.log("Handicap for #{x.alternative} is #{handicap} (#{days_ago} days ago)")
+            data << {:name => x.alternative, :weight => max_weight * MAX_WEIGHTING_FACTOR * (1 - handicap), :launch_window => launch_window}
           end
-          data
         end
 
         def assign_equal_weights(group_rows)

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 7
-  - 2
-  version: 0.7.2
+  - 8
+  - 1
+  version: 0.8.1
 platform: ruby
 authors: 
 - Noctivity
@@ -73,6 +73,7 @@ files:
 - lib/conductor/roll_up.rb
 - lib/conductor/views/dashboard/_current_weights.html.haml
 - lib/conductor/views/dashboard/_daily_stats.html.haml
+- lib/conductor/views/dashboard/_group_stats.html.haml
 - lib/conductor/views/dashboard/_top_nav.html.haml
 - lib/conductor/views/dashboard/_weight_history.html.haml
 - lib/conductor/views/dashboard/index.html.haml