whole_history_rating 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Pete Schwamb
+
+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.md

@@ -0,0 +1,19 @@
+
+# Whole History Rating
+
+A system for ranking game players by skill, based on Rémi Coulom's Whole History Rating algorithm.
+
+Developed for use on [GoShrine](http://goshrine.com), but the code is not go specific.  It can support any two player game, as long as the outcome is a simple win/loss.  An addition to the algorithm is support for handicaps. 
+
+Installation
+------------
+
+* gem install whole-history-rating
+
+Enjoy!
+
+-Pete
+
+
+
+

data/lib/whole_history_rating.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+
+module WholeHistoryRating
+
+  VERSION = "0.1.0"
+
+  STDOUT.sync = true
+
+  ROOT = File.expand_path(File.dirname(__FILE__))
+
+  %w[ base
+      player
+      game
+      player_day
+  ].each do |lib|
+    require File.join(ROOT, 'whole_history_rating', lib)
+  end
+
+end

data/lib/whole_history_rating/base.rb

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+require 'date'
+
+module WholeHistoryRating
+
+  class Base
+  
+    class UnstableRatingException < RuntimeError; end
+  
+    attr_accessor :players, :games
+    
+    def initialize(config = {})
+      @config = config
+      @config[:w2] ||= 300.0  # elo^2
+      @games = []
+      @players = {}
+      @start_date = nil
+    end
+  
+    def print_ordered_ratings
+      players = @players.values.select {|p| p.days.count > 0}
+      players.sort_by { |p| p.days.last.gamma }.each_with_index do |p,idx|
+        if p.days.count > 0
+          puts "#{p.name} => #{p.days.map(&:elo)}"
+        end
+      end
+    end
+  
+    def log_likelihood
+      score = 0.0
+      @players.values.each do |p|
+        unless p.days.empty?
+          score += p.log_likelihood
+        end
+      end
+      score
+    end
+  
+    def player_by_name(name)
+      players[name] || players[name] = Player.new(name, @config)
+    end
+    
+    def create_game(options)
+      if options['finished_at'].nil?
+        puts "Skipping (not finished) #{options.inspect}"
+        return nil
+      end
+      
+      game_date = Date.parse(options['finished_at'])
+    
+      @start_date ||= game_date
+    
+      # Avoid self-played games (no info)
+      if options['w_name'] == options['b_name']
+        puts "Skipping (black name == white name ?) #{options.inspect}"
+        return nil
+      end
+    
+      day_num = (game_date - @start_date).to_i
+    
+      #puts "day num = #{day_num}"
+    
+      white_player = player_by_name(options['w_name'])
+      white_player.id = options['w_id']
+      black_player = player_by_name(options['b_name'])
+      black_player.id = options['b_id']
+      game = Game.new(day_num, white_player, black_player, options['winner'], options['handicap'], options['extras'])
+      game.date = game_date
+      game
+    end
+  
+    def add_game(game)
+      game.white_player.add_game(game)
+      game.black_player.add_game(game)
+      if game.bpd.nil?
+        puts "Bad game: #{options.inspect} -> #{game.inspect}"
+      end
+      @games << game
+      game
+    end
+  
+    def run_one_iteration
+      players.each do |name,player|
+        player.run_one_newton_iteration
+      end
+    end
+  end
+end

data/lib/whole_history_rating/game.rb

@@ -0,0 +1,67 @@
+module WholeHistoryRating
+  class Game
+    attr_accessor :day, :date, :white_player, :black_player, :handicap, :winner, :wpd, :bpd, :extras
+  
+    def initialize(day, white_player, black_player, winner, handicap, extras)
+      @day = day
+      @white_player = white_player
+      @black_player = black_player
+      @winner = winner
+      @extras = extras
+      @handicap = handicap || 0
+      @handicap_proc = handicap if handicap.is_a?(Proc)
+    end
+  
+    def opponents_adjusted_gamma(player)
+      black_advantage = @handicap_proc ? @handicap_proc.call(self) : @handicap   
+      #puts "black_advantage = #{black_advantage}"
+      
+      if player == white_player
+        opponent_elo = bpd.elo + black_advantage
+      elsif player == black_player
+        opponent_elo = wpd.elo - black_advantage
+      else
+        raise "No opponent for #{player.inspect}, since they're not in this game: #{self.inspect}."
+      end
+      rval = 10**(opponent_elo/400.0)
+      if rval == 0 || rval.infinite? || rval.nan?
+        raise WHR::UnstableRatingException, "bad adjusted gamma: #{inspect}"
+      end
+      rval
+    end
+    
+    def opponent(player)
+      if player == white_player
+        black_player
+      elsif player == black_player
+        white_player
+      end
+    end
+  
+    def prediction_score
+      if white_win_probability == 0.5
+        0.5
+      else
+        ((winner == "W" && white_win_probability > 0.5) || (winner == "B" && white_win_probability < 0.5)) ? 1.0 : 0.0
+      end
+    end
+  
+    def inspect
+      "#{self}: W:#{white_player.name}(r=#{wpd ? wpd.r : '?'}) B:#{black_player.name}(r=#{bpd ? bpd.r : '?'}) winner = #{winner}, komi = #{@komi}, handicap = #{@handicap}"
+    end
+  
+    #def likelihood
+    #  winner == "W" ? white_win_probability : 1-white_win_probability
+    #end
+  
+    # This is the Bradley-Terry Model
+    def white_win_probability
+      wpd.gamma/(wpd.gamma + opponents_adjusted_gamma(white_player))
+    end
+  
+    def black_win_probability
+      bpd.gamma/(bpd.gamma + opponents_adjusted_gamma(black_player))
+    end
+  
+  end
+end

data/lib/whole_history_rating/player.rb

@@ -0,0 +1,254 @@
+require 'matrix'
+
+module WholeHistoryRating
+  class Player
+    attr_accessor :name, :anchor_gamma, :days, :w2, :debug, :id
+  
+    def initialize(name, config)
+      @name = name
+      @debug = config[:debug]
+      @w2 = (Math.sqrt(config[:w2])*Math.log(10)/400)**2  # Convert from elo^2 to r^2
+      @days = []
+    end
+  
+    def inspect
+      "#{self}:(#{name})"
+    end
+  
+    def log_likelihood
+      sum = 0.0
+      sigma2 = compute_sigma2
+      n = days.count
+      0.upto(n-1) do |i|
+        prior = 0
+        if i < (n-1)
+          rd = days[i].r - days[i+1].r
+          prior += (1/(Math.sqrt(2*Math::PI*sigma2[i]))) * Math.exp(-(rd**2)/2*sigma2[i]) 
+        end
+        if i > 0
+          rd = days[i].r - days[i-1].r
+          prior += (1/(Math.sqrt(2*Math::PI*sigma2[i-1]))) * Math.exp(-(rd**2)/2*sigma2[i-1]) 
+        end
+        if prior == 0
+          sum += days[i].log_likelihood
+        else
+          if (days[i].log_likelihood.infinite? || Math.log(prior).infinite?) 
+            puts "Infinity at #{inspect}: #{days[i].log_likelihood} + #{Math.log(prior)}: prior = #{prior}, days = #{days.inspect}"
+            exit
+          end
+          sum += days[i].log_likelihood + Math.log(prior)
+        end
+      end
+      sum
+    end
+  
+    def hessian(days, sigma2)
+      n = days.count
+      Matrix.build(n) do |row,col|
+        if row == col
+          prior = 0
+          prior += -1.0/sigma2[row] if row < (n-1)
+          prior += -1.0/sigma2[row-1] if row > 0
+          days[row].log_likelihood_second_derivative + prior - 0.001
+        elsif row == col-1
+          1.0/sigma2[row]
+        elsif row == col+1
+          1.0/sigma2[col]
+        else
+          0
+        end
+      end
+    end
+  
+    def gradient(r, days, sigma2)
+      g = []
+      n = days.count
+      days.each_with_index do |day,idx|
+        prior = 0
+        prior += -(r[idx]-r[idx+1])/sigma2[idx] if idx < (n-1)
+        prior += -(r[idx]-r[idx-1])/sigma2[idx-1] if idx > 0
+        if @debug
+          puts "g[#{idx}] = #{day.log_likelihood_derivative} + #{prior}"
+        end
+        g << day.log_likelihood_derivative + prior
+      end
+      g
+    end
+  
+    def run_one_newton_iteration
+      days.each do |day|
+        day.clear_game_terms_cache
+      end
+    
+      if days.count == 1
+        days[0].update_by_1d_newtons_method
+      elsif days.count > 1
+        update_by_ndim_newton
+      end
+    end
+  
+    def compute_sigma2
+      sigma2 = []
+      days.each_cons(2) do |d1,d2|
+        sigma2 << (d2.day - d1.day).abs * @w2
+      end
+      sigma2
+    end
+  
+    def update_by_ndim_newton
+      # r
+      r = days.map(&:r)
+    
+      if @debug
+        puts "Updating #{inspect}"
+        days.each do |day|
+          puts "day[#{day.day}] r = #{day.r}"
+          puts "day[#{day.day}] win terms = #{day.won_game_terms}"
+          puts "day[#{day.day}] win games = #{day.won_games}"
+          puts "day[#{day.day}] lose terms = #{day.lost_game_terms}"
+          puts "day[#{day.day}] lost games = #{day.lost_games}"
+          puts "day[#{day.day}] log(p) = #{day.log_likelihood}"
+          puts "day[#{day.day}] dlp = #{day.log_likelihood_derivative}"
+          puts "day[#{day.day}] dlp2 = #{day.log_likelihood_second_derivative}"
+        end
+      end
+    
+      # sigma squared (used in the prior)
+      sigma2 = compute_sigma2
+    
+      h = hessian(days, sigma2)
+      g = gradient(r, days, sigma2)
+    
+      a = []
+      d = [h[0,0]]
+      b = [h[0,1]]
+    
+      n = r.size    
+      (1..(n-1)).each do |i|
+        a[i] = h[i,i-1] / d[i-1]
+        d[i] = h[i,i] - a[i] * b[i-1]
+        b[i] = h[i,i+1]
+      end
+    
+    
+      y = [g[0]]
+      (1..(n-1)).each do |i|
+        y[i] = g[i] - a[i] * y[i-1]
+      end
+    
+      x = []
+      x[n-1] = y[n-1] / d[n-1]
+      (n-2).downto(0) do |i|
+        x[i] = (y[i] - b[i] * x[i+1]) / d[i]
+      end    
+    
+      new_r = r.zip(x).map {|ri,xi| ri-xi}
+    
+      new_r.each do |r|
+        if r > 650
+          raise WHR::UnstableRatingException, "Unstable r (#{new_r}) on player #{inspect}"
+        end
+      end
+    
+      if @debug
+        puts "Hessian = #{h}"
+        puts "gradient = #{g}"
+        puts "a = #{a}"
+        puts "d = #{d}"
+        puts "b = #{b}"
+        puts "y = #{y}"
+        puts "x = #{x}"
+        puts "#{inspect} (#{r}) => (#{new_r})"
+      end
+    
+      days.each_with_index do |day,idx|
+        day.r = day.r - x[idx]
+      end
+    end
+  
+    def covariance
+      r = days.map(&:r)
+    
+      sigma2 = compute_sigma2
+      h = hessian(days, sigma2)
+      g = gradient(r, days, sigma2)
+    
+      n = days.count
+    
+      a = []
+      d = [h[0,0]]
+      b = [h[0,1]]
+    
+      n = r.size    
+      (1..(n-1)).each do |i|
+        a[i] = h[i,i-1] / d[i-1]
+        d[i] = h[i,i] - a[i] * b[i-1]
+        b[i] = h[i,i+1]
+      end
+    
+      dp = []
+      dp[n-1] = h[n-1,n-1]    
+      bp = []
+      bp[n-1] = h[n-1,n-2]
+      ap = []
+      (n-2).downto(0) do |i|
+        ap[i] = h[i,i+1] / dp[i+1]
+        dp[i] = h[i,i] - ap[i]*bp[i+1]
+        bp[i] = h[i,i-1]
+      end
+    
+      v = []
+      0.upto(n-2) do |i|
+        v[i] = dp[i+1]/(b[i]*bp[i+1] - d[i]*dp[i+1])
+      end
+      v[n-1] = -1/d[n-1]
+    
+      #puts "a = #{a}"
+      #puts "b = #{b}"
+      #puts "bp = #{bp}"
+      #puts "d = #{d}"
+      #puts "dp = #{dp}"
+      #puts "v = #{v}" 
+    
+      Matrix.build(n) do |row,col|
+        if row == col
+          v[row]
+        elsif row == col-1
+          -1*a[col]*v[col]
+        else
+          0
+        end
+      end
+    end
+    
+    def update_uncertainty
+      if days.count > 0
+        c = covariance
+        u = (0..(days.count-1)).collect{|i| c[i,i]}
+        days.zip(u) {|d,u| d.uncertainty = u}
+      else
+        5
+      end
+    end
+  
+    def add_game(game)
+      if days.last.nil? || days.last.day != game.day
+        new_pday = PlayerDay.new(self, game.day)
+        new_pday.date = game.date
+        if days.empty?
+          new_pday.is_first_day = true
+          new_pday.gamma = 1
+        else
+          new_pday.gamma = days.last.gamma
+        end
+        days << new_pday
+      end
+      if (game.white_player == self)
+        game.wpd = days.last
+      else 
+        game.bpd = days.last
+      end
+      days.last.add_game(game)
+    end
+  end
+end

data/lib/whole_history_rating/player_day.rb

@@ -0,0 +1,119 @@
+
+module WholeHistoryRating
+  class PlayerDay
+    attr_accessor :won_games, :lost_games, :name, :kyudan, :day, :date, :player, :r, :is_first_day, :uncertainty
+    def initialize(player, day)
+      @day = day
+      @player = player
+      @is_first_day = false
+      @won_games = []
+      @lost_games = []
+    end
+  
+    def gamma=(gamma)
+      @r = Math.log(gamma)
+    end
+  
+    def gamma
+      Math.exp(@r)
+    end
+  
+    def elo=(elo)
+      @r = elo * (Math.log(10)/400.0)
+    end
+  
+    def elo
+      (@r * 400.0)/(Math.log(10))
+    end
+  
+    def clear_game_terms_cache
+      @won_game_terms = nil
+      @lost_game_terms = nil
+    end
+  
+    def won_game_terms
+      if @won_game_terms.nil?
+        @won_game_terms = @won_games.map do |g|
+          other_gamma = g.opponents_adjusted_gamma(player)
+          if other_gamma == 0 || other_gamma.nan? || other_gamma.infinite?
+            puts "other_gamma (#{g.opponent(player).inspect}) = #{other_gamma}"
+          end
+          [1.0,0.0,1.0,other_gamma]
+        end
+        if is_first_day
+          @won_game_terms << [1.0,0.0,1.0,1.0]  # win against virtual player ranked with gamma = 1.0
+        end
+      end
+      @won_game_terms
+    end
+  
+    def lost_game_terms
+      if @lost_game_terms.nil?
+        @lost_game_terms = @lost_games.map do |g|
+          other_gamma = g.opponents_adjusted_gamma(player)
+          if other_gamma == 0 || other_gamma.nan? || other_gamma.infinite?
+            puts "other_gamma (#{g.opponent(player).inspect}) = #{other_gamma}"
+          end
+          [0.0,other_gamma,1.0,other_gamma]
+        end
+        if is_first_day
+          @lost_game_terms << [0.0,1.0,1.0,1.0]  # loss against virtual player ranked with gamma = 1.0
+        end
+      end
+      @lost_game_terms
+    end    
+  
+    def log_likelihood_second_derivative
+      sum = 0.0
+      (won_game_terms + lost_game_terms).each do |a,b,c,d|
+        sum += (c*d) / ((c*gamma + d)**2.0)
+      end 
+      if gamma.nan? || sum.nan?
+        puts "won_game_terms = #{won_game_terms}"
+        puts "lost_game_terms = #{lost_game_terms}"
+      end
+      -1 * gamma * sum
+    end
+
+    def log_likelihood_derivative    
+      tally = 0.0
+      (won_game_terms + lost_game_terms).each do |a,b,c,d|
+        tally += c/(c*gamma + d)
+      end 
+      won_game_terms.count - gamma * tally
+    end
+  
+    def log_likelihood
+      tally = 0.0
+      won_game_terms.each do |a,b,c,d|
+        tally += Math.log(a*gamma)
+        tally -= Math.log(c*gamma + d)
+      end
+      lost_game_terms.each do |a,b,c,d|
+        tally += Math.log(b)
+        tally -= Math.log(c*gamma + d)
+      end
+      tally
+    end
+  
+    def add_game(game)
+      if (game.winner == "W" && game.white_player == @player) ||
+         (game.winner == "B" && game.black_player == @player)
+        @won_games << game
+      else
+        @lost_games << game
+      end
+    end
+
+    def update_by_1d_newtons_method
+      dlogp = log_likelihood_derivative
+      d2logp = log_likelihood_second_derivative
+      dr = (log_likelihood_derivative / log_likelihood_second_derivative)
+      new_r = @r - dr
+      #new_r = [0, @r - dr].max
+      #puts "(#{player.name}) #{new_r} = #{@r} - (#{log_likelihood_derivative}/#{log_likelihood_second_derivative})"
+      @r = new_r
+    end
+  
+  end
+end

data/whole_history_rating.gemspec

@@ -0,0 +1,31 @@
+DIR = File.dirname(__FILE__)
+LIB = File.join(DIR, *%w[lib whole_history_rating.rb])
+VERSION = open(LIB) { |lib|
+  lib.each { |line|
+    if v = line[/^\s*VERSION\s*=\s*(['"])(\d+\.\d+\.\d+)\1/, 2]
+      break v
+    end
+  }
+}
+
+SPEC = Gem::Specification.new do |s|
+  s.name = "whole_history_rating"
+  s.version = VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ["Pete Schwamb"]
+  s.email = ["pete@schwamb.net"]
+  s.homepage = "http://github.com/goshrine/whole_history_rating"
+  s.summary = "A pure ruby implementation of Remi Coulom's Whole-History Rating algorithm."
+  s.description = <<-END_DESCRIPTION.gsub(/\s+/, " ").strip
+  This gem provides a library and executables that take as input as set of games and output a set of skill rankings for the players of those games.  The algorithm is a version of Remi Coulom's Whole-History Rating modified to support handicaps, and implemented in Ruby. 
+  END_DESCRIPTION
+
+  #s.add_dependency('json', '>= 1.5.0')
+
+  #s.add_development_dependency "rspec"
+
+  #s.executables = ['whr_rate']
+
+  s.files = `git ls-files`.split("\n")
+  s.require_paths = %w[lib]
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: whole_history_rating
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Pete Schwamb
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-17 00:00:00.000000000Z
+dependencies: []
+description: This gem provides a library and executables that take as input as set
+  of games and output a set of skill rankings for the players of those games. The
+  algorithm is a version of Remi Coulom's Whole-History Rating modified to support
+  handicaps, and implemented in Ruby.
+email:
+- pete@schwamb.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/whole_history_rating.rb
+- lib/whole_history_rating/base.rb
+- lib/whole_history_rating/game.rb
+- lib/whole_history_rating/player.rb
+- lib/whole_history_rating/player_day.rb
+- whole_history_rating.gemspec
+homepage: http://github.com/goshrine/whole_history_rating
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: A pure ruby implementation of Remi Coulom's Whole-History Rating algorithm.
+test_files: []