trueskill 0.1.0

data/lib/saulabs/trueskill/factors/greater_than.rb

@@ -0,0 +1,45 @@
+module Saulabs
+  module TrueSkill
+    module Factors
+      
+      class GreaterThan < Base
+        
+        def initialize(epsilon, variable)
+          super()
+          @epsilon = epsilon
+          bind(variable) 
+        end
+        
+        def log_normalization
+          msg = @variables[0] / @messages[0]
+          -Gauss::Distribution.log_product_normalization(msg, @messages[0]) + 
+           Math.log(Gauss::Distribution.cdf((msg.mean - @epsilon) / msg.deviation))
+        end
+        
+        def update_message_at(index)
+          raise "illegal message index: #{index}" if index < 0 || index > 0
+          message = @messages[index]
+          variable = @bindings[@messages[index]]
+          
+          msg = variable / message
+          c = msg.precision
+          d = msg.precision_mean
+          sqrt_c = Math.sqrt(c)
+          d_sqrt_c = sqrt_c == 0 ? 0.0 : d / sqrt_c 
+          e_sqrt_c = @epsilon * sqrt_c
+          denom = 1.0 - Gauss::TruncatedCorrection.w_exceeds_margin(d_sqrt_c, e_sqrt_c)
+          new_precision = c / denom
+          new_precision_mean = (d + sqrt_c * Gauss::TruncatedCorrection.v_exceeds_margin(d_sqrt_c, e_sqrt_c)) / denom
+          new_marginal = Gauss::Distribution.with_precision(new_precision_mean, new_precision)
+          new_message = message * new_marginal / variable
+          diff = new_marginal - variable
+          message.replace(new_message)
+          variable.replace(new_marginal)
+          return diff
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/saulabs/trueskill/factors/likelihood.rb

@@ -0,0 +1,45 @@
+module Saulabs
+  module TrueSkill
+    module Factors
+      
+      class Likelihood < Base
+        
+        def initialize(beta_squared, variable1, variable2)
+          super()
+          @precision = 1.0 / beta_squared
+          bind(variable1)
+          bind(variable2)
+        end
+        
+        def update_message_at(index)
+          raise "illegal message index: #{index}" if index < 0 || index > 1
+          case index
+          when 0 then update_helper(@messages[0], @messages[1], @variables[0], @variables[1])
+          when 1 then update_helper(@messages[1], @messages[0], @variables[1], @variables[0])
+          end
+        end
+        
+        def log_normalization
+          Gauss::Distribution.log_ratio_normalization(@variables[0], @messages[0])
+        end
+      
+      private
+        
+        def update_helper(message1, message2, variable1, variable2)
+          a = @precision / (@precision + variable2.precision - message2.precision)
+          new_message = Gauss::Distribution.with_precision(
+                          a * (variable2.precision_mean - message2.precision_mean),
+                          a * (variable2.precision - message2.precision)
+                        )
+          new_marginal = (variable1 / message1) * new_message
+          diff = new_marginal - variable1
+          message1.replace(new_message)
+          variable1.replace(new_marginal)
+          return diff
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/saulabs/trueskill/factors/prior.rb

@@ -0,0 +1,35 @@
+module Saulabs
+  module TrueSkill
+    module Factors
+      
+      class Prior < Base
+        
+        def initialize(mean, variance, variable)
+          super()
+          @message = Gauss::Distribution.with_variance(mean, variance)
+          bind(variable)
+        end
+        
+        def update_message_at(index)
+          raise "illegal message index: #{index}" if index < 0 || index > 0
+          message = @messages[index]
+          variable = @variables[index]
+          new_marginal = Gauss::Distribution.with_precision(
+                           variable.precision_mean + @message.precision_mean - message.precision_mean,
+                           variable.precision + @message.precision - message.precision
+                         )
+          diff = variable - new_marginal
+          variable.replace(new_marginal)
+          message.replace(@message)
+          return diff
+        end
+        
+        def log_normalization
+          0.0
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/saulabs/trueskill/factors/weighted_sum.rb

@@ -0,0 +1,80 @@
+require 'pp'
+
+module Saulabs
+  module TrueSkill
+    module Factors
+      
+      class WeightedSum < Base
+        
+        attr_reader :weights, :weights_squared, :index_order
+        
+        def initialize(variable, ratings, weights)
+          super()
+          @weights = [weights]
+          @weights_squared = [@weights.first.map { |w| w**2 }]
+          @index_order = [(0..weights.size+1).to_a]
+          (1..weights.size).each do |idx|
+            dest_idx = 0
+            @weights[idx] = []
+            @weights_squared[idx] = []
+            @index_order << [idx]
+            (0..ratings.size-1).each do |src_idx|
+              next if src_idx == idx-1
+              weight = weights[idx-1] == 0 ? 0.0 : -weights[src_idx] / weights[idx-1]
+              @weights[idx][dest_idx] = weight
+              @weights_squared[idx][dest_idx] = weight**2
+              @index_order.last[dest_idx+1] = src_idx+1
+              dest_idx += 1
+            end
+            final_weight = weights[idx-1] == 0 ? 0.0 : 1.0 / weights[idx-1]
+            @weights[idx][dest_idx] = final_weight
+            @weights_squared[idx][dest_idx] = final_weight**2
+            @index_order.last[weights.size] = 0
+          end
+          bind(variable)
+          ratings.each { |v| bind(v) }
+        end
+        
+        def update_message_at(index)
+          raise "illegal message index: #{index}" if index < 0 || index >= @messages.count
+          indices = @index_order[index]
+          updated_messages = []
+          updated_variables = []
+          @messages.each_index do |i|
+            updated_messages << @messages[indices[i]]
+            updated_variables << @variables[indices[i]]
+          end
+          update_helper(@weights[index], @weights_squared[index], updated_messages, updated_variables)
+        end
+        
+        def log_normalization
+          res = 0
+          (1..@variables.size-1).each do |i|
+            res += Gauss::Distribution.log_ratio_normalization(@variables[i], @messages[i])
+          end
+          res
+        end
+        
+      private
+        
+        def update_helper(weights, weights_squared, messages, variables)
+          marginal0 = variables[0].clone
+          ips, wms = 0.0, 0.0
+          weights_squared.each_index do |i|
+            ips += weights_squared[i] / (variables[i+1].precision - messages[i+1].precision)
+            diff = variables[i+1] / messages[i+1]
+            wms += weights[i] * (variables[i+1].precision_mean - messages[i+1].precision_mean) / (variables[i+1].precision - messages[i+1].precision)
+          end
+          new_message = Gauss::Distribution.with_precision(1.0/ips*wms, 1.0/ips)
+          old_marginal = marginal0 / messages[0]
+          new_marginal = old_marginal * new_message
+          messages[0].replace(new_message)
+          variables[0].replace(new_marginal)
+          return new_marginal - marginal0
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/saulabs/trueskill/factors/within.rb

@@ -0,0 +1,45 @@
+module Saulabs
+  module TrueSkill
+    module Factors
+      
+      class Within < Base
+        
+        def initialize(epsilon, variable)
+          super()
+          @epsilon = epsilon
+          bind(variable) 
+        end
+        
+        def log_normalization
+          msg = @variables[0] / @messages[0]
+          mean = msg.mean
+          dev = msg.deviation
+          z = Gauss::Distribution.cdf((@epsilon - mean) / dev) - Gauss::Distribution.cdf((-@epsilon - mean) / dev)
+          -Gauss::Distribution.log_product_normalization(msg, @messages[0]) + Math.log(z)
+         end
+        
+        def update_message_at(index)
+          message = @messages[index]
+          variable = @variables[index]
+          msg = variable / message
+          c = msg.precision
+          d = msg.precision_mean
+          sqrt_c = Math.sqrt(c)
+          d_sqrt_c = sqrt_c == 0 ? 0.0 : d / sqrt_c
+          e_sqrt_c = @epsilon * sqrt_c
+          denom = 1.0 - Gauss::TruncatedCorrection.w_within_margin(d_sqrt_c, e_sqrt_c)
+          new_precision = c / denom
+          new_precision_mean = (d + sqrt_c * Gauss::TruncatedCorrection.v_within_margin(d_sqrt_c, e_sqrt_c)) / denom
+          new_marginal = Gauss::Distribution.with_precision(new_precision_mean, new_precision)
+          new_message = message * new_marginal / variable
+          diff = new_marginal - variable
+          message.replace(new_message)
+          variable.replace(new_marginal)
+          return diff
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/saulabs/trueskill/layers/base.rb

@@ -0,0 +1,32 @@
+module Saulabs
+  module TrueSkill
+    module Layers
+      
+      class Base
+      
+        attr_accessor :graph, :factors, :output, :input
+      
+        def initialize(graph)
+          @graph = graph
+          @factors = []
+          @output = []
+          @input = []
+        end
+        
+        def build
+          raise "Abstract method Layers::Base#build called"
+        end
+        
+        def prior_schedule
+          nil
+        end
+        
+        def posterior_schedule
+          nil
+        end
+      
+      end
+    
+    end
+  end
+end

data/lib/saulabs/trueskill/layers/iterated_team_performances.rb

@@ -0,0 +1,72 @@
+module Saulabs
+  module TrueSkill
+    module Layers
+    
+      class IteratedTeamPerformances < Base
+        
+        def initialize(graph, team_perf_diff, team_diff_comp)
+          super(graph)
+          @tpd = team_perf_diff
+          @tdc = team_diff_comp
+        end
+        
+        def build
+          @tpd.input = @input
+          @tpd.build
+          @tdc.input = @tpd.output
+          @tdc.build
+        end
+        
+        def factors
+          @tpd.factors + @tdc.factors
+        end
+        
+        def prior_schedule
+          loop_schedule = if @input.size == 2
+            two_team_loop_schedule
+          elsif @input.size > 2
+            multiple_team_loop_schedule
+          else
+            raise 'Illegal input'
+          end
+          team_diffs = @tpd.factors.size;
+          Schedules::Sequence.new([loop_schedule, 
+                                   Schedules::Step.new(@tpd.factors[0], 1),
+                                   Schedules::Step.new(@tpd.factors[team_diffs-1], 2)])
+        end
+        
+        private 
+        
+        def two_team_loop_schedule
+          Schedules::Sequence.new([
+            Schedules::Step.new(@tpd.factors[0], 0), 
+            Schedules::Step.new(@tdc.factors[0], 0)
+          ])
+        end
+        
+        def multiple_team_loop_schedule
+          team_diff = @tpd.factors.size
+          forward_schedule = Schedules::Sequence.new(
+                               (0..team_diff-2).map { |i|
+                                 Schedules::Sequence.new([
+                                   Schedules::Step.new(@tpd.factors[i], 0),
+                                   Schedules::Step.new(@tdc.factors[i], 0),
+                                   Schedules::Step.new(@tpd.factors[i], 2)
+                                 ])
+                               })
+          backward_schedule = Schedules::Sequence.new(
+                                (0..team_diff-2).map { |i|
+                                  Schedules::Sequence.new([
+                                    Schedules::Step.new(@tpd.factors[team_diff-1-i], 0),
+                                    Schedules::Step.new(@tdc.factors[team_diff-1-i], 0),
+                                    Schedules::Step.new(@tpd.factors[team_diff-1-i], 1)
+                                  ])
+                                })
+          Schedules::Loop.new(Schedules::Sequence.new([forward_schedule, backward_schedule]), 0.0001)
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/saulabs/trueskill/layers/performances_to_team_performances.rb

@@ -0,0 +1,31 @@
+module Saulabs
+  module TrueSkill
+    module Layers
+    
+      class PerformancesToTeamPerformances < Base
+        
+        def build
+          @input.each do |ratings|
+            variable = Gauss::Distribution.new
+            @factors << Factors::WeightedSum.new(variable, ratings, ratings.map(&:activity))
+            @output << [variable]
+          end
+        end
+        
+        def prior_schedule
+          Schedules::Sequence.new(@factors.map { |f| Schedules::Step.new(f, 0) })
+        end
+        
+        def posterior_schedule
+          steps = []
+          @factors.each do |f|
+            (1..f.message_count-1).each { |i| steps << Schedules::Step.new(f, i) }
+          end
+          Schedules::Sequence.new(steps)
+        end
+        
+      end
+    
+    end
+  end
+end

data/lib/saulabs/trueskill/layers/prior_to_skills.rb

@@ -0,0 +1,32 @@
+module Saulabs
+  module TrueSkill
+    module Layers
+    
+      class PriorToSkills < Base
+      
+        def initialize(graph, teams)
+          super(graph)
+          @teams = teams
+        end
+        
+        def build
+          @teams.each do |team|
+            team_skills = []
+            team.each do |rating|
+              variable = TrueSkill::Rating.new(0.0, 0.0, rating.activity, rating.tau)
+              @factors << Factors::Prior.new(rating.mean, rating.variance + rating.tau_squared, variable)
+              team_skills << variable
+            end
+            @output << team_skills
+          end
+        end
+        
+        def prior_schedule
+          Schedules::Sequence.new(@factors.map { |f| Schedules::Step.new(f, 0) })
+        end
+        
+      end
+    
+    end
+  end
+end

data/lib/saulabs/trueskill/layers/skills_to_performances.rb

@@ -0,0 +1,31 @@
+module Saulabs
+  module TrueSkill
+    module Layers
+    
+      class SkillsToPerformances < Base
+        
+        def build
+          @input.each do |team|
+            team_performances = []
+            team.each do |rating|
+              variable = TrueSkill::Rating.new(0.0, 0.0, rating.activity, rating.tau)
+              @factors << Factors::Likelihood.new(@graph.beta_squared, variable, rating)
+              team_performances << variable
+            end
+            @output << team_performances
+          end
+        end
+        
+        def prior_schedule
+          Schedules::Sequence.new(@factors.map { |f| Schedules::Step.new(f, 0) })
+        end
+        
+        def posterior_schedule
+          Schedules::Sequence.new(@factors.map { |f| Schedules::Step.new(f, 1) })
+        end
+        
+      end
+    
+    end
+  end
+end