trueskill 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Lars Kuhnt
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,17 @@
+= trueskill
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Lars Kuhnt. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,46 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "trueskill"
+    gem.summary = %Q{A ruby library for the trueskill rating system}
+    gem.description = %Q{A ruby library for the trueskill rating system}
+    gem.email = "lars.kuhnt@gmail.com"
+    gem.homepage = "http://github.com/saulabs/trueskill"
+    gem.authors = ["Lars Kuhnt"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_dependency('narray', '>= 0.5.9.7')
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "trueskill #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/saulabs/gauss.rb

@@ -0,0 +1,3 @@
+Dir.glob("#{File.dirname(__FILE__)}/gauss/**/*.rb").each do |src|
+  require src
+end

data/lib/saulabs/gauss/distribution.rb

@@ -0,0 +1,125 @@
+module Saulabs
+  module Gauss
+    class Distribution
+      
+      SQRT2 = Math.sqrt(2).freeze
+      INV_SQRT_2PI = (1 / Math.sqrt(2 * Math::PI)).freeze
+      LOG_SQRT_2PI = Math.log(Math.sqrt(2 * Math::PI)).freeze
+    
+      # gaussian normal distribution values
+      attr_accessor :mean, :deviation, :variance, :precision, :precision_mean
+      
+      def initialize(mean = 0.0, deviation = 0.0)
+        mean = 0.0 unless mean.to_f.finite?
+        deviation = 0.0 unless deviation.to_f.finite?
+        @mean = mean
+        @deviation = deviation
+        @variance = deviation * deviation
+        @precision = deviation == 0.0 ? 0.0 : 1 / @variance.to_f
+        @precision_mean = @precision * mean
+      end
+    
+      class << self
+        
+        def standard
+          @@standard ||= Distribution.new(0.0, 1.0)
+          @@standard
+        end
+      
+        def with_deviation(mean, deviation)
+          Distribution.new(mean, deviation)
+        end
+        
+        def with_variance(mean, variance)
+          Distribution.new(mean, Math.sqrt(variance))
+        end
+  
+        def with_precision(mean, precision)
+          Distribution.new(mean / precision, Math.sqrt(1 / precision))
+        end
+      
+        def absolute_difference(x, y)
+          [(x.precision_mean - y.precision_mean).abs, Math.sqrt((x.precision - y.precision).abs)].max
+        end
+      
+        def log_product_normalization(x, y)
+          return 0.0 if x.precision == 0.0 || y.precision == 0.0
+          variance_sum = x.variance + y.variance
+          mean_diff = x.mean - y.mean
+          -LOG_SQRT_2PI - (Math.log(variance_sum) / 2.0) - (mean_diff**2 / (2.0 * variance_sum))
+        end
+      
+        def log_ratio_normalization(x, y)
+          return 0.0 if x.precision == 0.0 || y.precision == 0.0
+          variance_diff = y.variance - x.variance
+          return 0.0 if variance_diff == 0.0
+          mean_diff = x.mean - y.mean
+          Math.log(y.variance) + LOG_SQRT_2PI - (Math.log(variance_diff) / 2.0) + (mean_diff**2 / (2.0 * variance_diff))
+        end
+        
+        # Computes the cummulative Gaussian distribution at a specified point of interest
+        def cumulative_distribution_function(x)
+          0.5 * (1 + Math.erf(x / SQRT2))
+        end
+        alias_method :cdf, :cumulative_distribution_function
+        
+        # Computes the Gaussian density at a specified point of interest
+        def probability_density_function(x)
+          INV_SQRT_2PI * Math.exp(-0.5 * (x**2))
+        end
+        alias_method :pdf, :probability_density_function
+        
+        # The inverse of the cummulative Gaussian distribution function
+        def quantile_function(x)
+          -SQRT2 * Math.erfc(2.0 * x)
+        end
+        alias_method :inv_cdf, :quantile_function
+        
+      end
+      
+      def value_at(x)
+        exp = -(x - @mean)**2.0 / (2.0 * @variance)
+        (1.0/@deviation) * INV_SQRT_2PI * Math.exp(exp)
+      end
+      
+      # copy values from other distribution
+      def replace(other)
+        @precision = other.precision
+        @precision_mean = other.precision_mean
+        @mean = other.mean
+        @deviation = other.deviation
+        @variance = other.variance
+      end
+  
+      def *(other)
+        Distribution.with_precision(self.precision_mean + other.precision_mean, self.precision + other.precision)
+      end
+  
+      def /(other)
+        Distribution.with_precision(self.precision_mean - other.precision_mean, self.precision - other.precision)
+      end
+  
+      # absolute difference
+      def -(other)
+        Distribution.absolute_difference(self, other)
+      end
+    
+      def +(other)
+      
+      end
+    
+      def ==(other)
+        self.mean == other.mean && self.variance == other.variance
+      end
+  
+      def equals(other)
+        self == other
+      end
+      
+      def to_s
+        "[μ=#{'%.4f' % mean}, σ=#{'%.4f' % deviation}]"
+      end
+  
+    end
+  end
+end

data/lib/saulabs/gauss/truncated_correction.rb

@@ -0,0 +1,62 @@
+module Saulabs
+  module Gauss
+    class TruncatedCorrection
+  
+      class << self
+        
+        def w_within_margin(perf_diff, draw_margin)
+          abs_diff = perf_diff.abs
+          denom = Distribution.cdf(draw_margin - abs_diff) - Distribution.cdf(-draw_margin - abs_diff)
+          return 1.0 if denom < 2.2e-162
+          vt = v_within_margin(abs_diff, draw_margin)
+          return vt**2 + (
+                          (draw_margin - abs_diff) * 
+                          Gauss::Distribution.standard.value_at(draw_margin - abs_diff) -
+                          (-draw_margin - abs_diff) *
+                          Gauss::Distribution.standard.value_at(-draw_margin - abs_diff) 
+                         ) / denom
+        end
+        
+        def v_within_margin(perf_diff, draw_margin)
+          abs_diff = perf_diff.abs
+          denom = Distribution.cdf(draw_margin - abs_diff) - Distribution.cdf(-draw_margin - abs_diff)
+          if denom < 2.2e-162
+            return perf_diff < 0 ? -perf_diff - draw_margin : -perf_diff + draw_margin
+          end
+          num = Gauss::Distribution.standard.value_at(-draw_margin - abs_diff) -
+                Gauss::Distribution.standard.value_at(draw_margin - abs_diff)
+          perf_diff < 0 ? -num/denom : num/denom
+        end
+        
+        def w_exceeds_margin(perf_diff, draw_margin)
+          denom = Distribution.cdf(perf_diff - draw_margin)
+          if denom < 2.2e-162
+            return perf_diff < 0.0 ? 1.0 : 0.0
+          else
+            v = v_exceeds_margin(perf_diff, draw_margin)
+            return v * (v + perf_diff - draw_margin)
+          end
+        end
+  
+        def v_exceeds_margin(perf_diff, draw_margin)
+          denom = Distribution.cdf(perf_diff - draw_margin)
+          denom < 2.2e-162 ? -perf_diff + draw_margin : Gauss::Distribution.standard.value_at(perf_diff - draw_margin)/denom 
+        end
+  
+        def exceeds_margin(perf_diff, draw_margin)
+          abs_diff = perf_diff.abs
+          denom = Distribution.cdf(draw_margin - abs_diff) - Distribution.cdf(-draw_margin - abs_diff)
+          if denom < 2.2e-162
+            return 1.0
+          else
+            v = v_exceeds_margin(abs_diff, draw_margin)
+            return v**2 + 
+                   ((draw_margin - abs_diff) * Gauss::Distribution.standard.value_at(draw_margin - abs_diff) -
+                   (-draw_margin - abs_diff) * Gauss::Distribution.standard.value_at(-draw_margin - abs_diff)) / denom
+          end
+        end
+  
+      end
+    end
+  end
+end

data/lib/saulabs/trueskill.rb

@@ -0,0 +1,7 @@
+require 'pp'
+
+require "#{File.dirname(__FILE__)}/gauss.rb"
+
+Dir.glob("#{File.dirname(__FILE__)}/trueskill/**/*.rb").each do |src|
+  require src
+end

data/lib/saulabs/trueskill/factor_graph.rb

@@ -0,0 +1,75 @@
+module Saulabs
+  module TrueSkill
+    
+    class FactorGraph
+      
+      attr_reader :teams, :beta, :beta_squared, :draw_probability, :epsilon, :layers
+      
+      # teams: 2 dimensional array of ratings
+      def initialize(teams, ranks, options = {})
+        @teams = teams
+        @ranks = ranks
+        @beta = options[:beta] || 25/6.0
+        @draw_probability = options[:draw_probability] || 0.1
+        @beta_squared = @beta**2
+        @epsilon = -Math.sqrt(2.0 * @beta_squared) * Gauss::Distribution.inv_cdf((1.0 - @draw_probability) / 2.0)
+        
+        @prior_layer = Layers::PriorToSkills.new(self, @teams)
+        @layers = [
+          @prior_layer,
+          Layers::SkillsToPerformances.new(self),
+          Layers::PerformancesToTeamPerformances.new(self),
+          Layers::IteratedTeamPerformances.new(self,
+            Layers::TeamPerformanceDifferences.new(self),
+            Layers::TeamDifferenceComparision.new(self, ranks)
+          )
+        ]
+      end
+      
+      def draw_margin
+        Gauss::Distribution.inv_cdf(0.5*(@draw_probability + 1)) * Math.sqrt(1 + 1) * @beta
+      end
+      
+      def evaluate
+        build_layers
+        run_schedule
+        [ranking_probability, updated_skills]
+      end
+      
+    private
+      
+      def ranking_probability
+        # factor_list = []
+        # sum_log_z, sum_log_s = 0.0
+        # @layers.each do |layer|
+        #   layer.factors.each do |factor|
+        #     factor.reset_marginals
+        #     factor.messages.each_index { |i| sum_log_z += factor.send_message_at(i) }
+        #     sum_log_s += factor.log_normalization
+        #   end
+        # end
+        # Math.exp(sum_log_z + sum_log_s)
+      end
+      
+      def updated_skills
+        @prior_layer.output
+      end
+      
+      def build_layers
+        output = nil
+        @layers.each do |layer|
+          layer.input = output
+          layer.build
+          output = layer.output
+        end
+      end
+      
+      def run_schedule
+        schedules = @layers.map(&:prior_schedule) + @layers.reverse.map(&:posterior_schedule)
+        Schedules::Sequence.new(schedules.compact).visit
+      end
+      
+    end
+    
+  end
+end

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

@@ -0,0 +1,50 @@
+module Saulabs
+  module TrueSkill
+    module Factors
+      
+      class Base
+        
+        def initialize
+          @messages = []
+          @bindings = {}
+          @variables = []
+          @priors = []
+        end
+        
+        def update_message_at(index)
+          raise "Abstract method Factors::Base#update_message_at(index) called"
+        end
+        
+        def message_count
+          @messages.size
+        end
+        
+        def log_normalization
+          raise "Abstract method Factors::Base#log_normalization called"
+        end
+        
+        def reset_marginals
+          @bindings.values.each { |var| var.replace(Gauss::Distribution.new) }
+        end
+        
+        def send_message_at(idx)
+          message = @messages[idx]
+          variable = @variables[idx]
+          log_z = Gauss::Distribution.log_product_normalization(message, variable)
+          variable.replace(message * variable)
+          return log_z
+        end
+        
+        def bind(variable)
+          message = Gauss::Distribution.new
+          @messages << message
+          @bindings[message] = variable
+          @variables << variable
+          return message
+        end
+        
+      end
+      
+    end
+  end
+end