trueskill-ranked 0.9b

data/lib/TrueSkill.rb

@@ -0,0 +1,33 @@
+# -*- encoding : utf-8 -*-
+require 'pp'
+
+%w(
+  general
+  guassian
+).each do |name|
+  require File.expand_path(File.join(File.dirname(__FILE__), "TrueSkill", "Mathematics", "#{name}.rb"))
+end
+
+%w(
+  Factor
+  LikelihoodFactor
+  PriorFactor
+  SumFactor
+  TruncateFactor
+  Variable
+).each do |name|
+  require File.expand_path(File.join(File.dirname(__FILE__), "TrueSkill", "FactorGraph", "#{name}.rb"))
+end
+
+
+
+
+%w(
+  Array
+  core_ext
+  general
+  Rating
+  TrueSkill
+).each do |name|
+  require File.expand_path(File.join(File.dirname(__FILE__), "TrueSkill", "#{name}.rb"))
+end

data/lib/TrueSkill/FactorGraph/Factor.rb

@@ -0,0 +1,17 @@
+
+
+class Factor
+  attr_accessor :vars
+  @vars=nil
+  def initialize(vars)
+    @vars=vars
+    @vars.each do |var|
+      var[self]=Gaussian.new
+    end
+      
+  end
+
+  def var
+    @vars[0]
+  end
+end

data/lib/TrueSkill/FactorGraph/LikelihoodFactor.rb

@@ -0,0 +1,27 @@
+
+class LikelihoodFactor < Factor
+  @mean=nil
+  @value=nil
+  @variance=nil
+  def initialize(mean_var,value_var,variance)
+    super([mean_var,value_var])
+    @mean=mean_var
+    @value=value_var
+    @variance=variance
+  end
+  
+  def down
+    val=@mean
+    msg=val/@mean[self]
+    pi=1.0/@variance
+    a=pi/(pi+val.pi)
+    return @value.update_message(self,a*msg.pi,a*msg.tau)
+  end 
+  
+  def up
+    val=@value
+    msg=val/@value[self]
+    a=1.0/(1.0+@variance*msg.pi)
+    return @mean.update_message(self,a*msg.pi,a*msg.tau)
+  end
+end

data/lib/TrueSkill/FactorGraph/PriorFactor.rb

@@ -0,0 +1,17 @@
+
+require_relative 'Factor'
+class PriorFactor < Factor
+  @val=nil
+  @dynamic=0
+  def initialize(var,val,dynamic=0)
+    super([var])
+    @val=val
+    @dynamic=dynamic
+  end
+  
+  def down
+    sigma=Math.sqrt(@val.sigma**2 + @dynamic ** 2)
+    value=Gaussian.new @val.mu,sigma
+    var.update_value self,0,0,value
+  end 
+end

data/lib/TrueSkill/FactorGraph/SumFactor.rb

@@ -0,0 +1,65 @@
+
+class SumFactor < Factor
+  @sum=nil
+  @terms=nil
+  @coeffs=nil
+  def initialize(sum_var,term_vars,coeffs)
+    super([sum_var]+term_vars)
+    @sum=sum_var
+    @terms=term_vars
+    @coeffs=coeffs
+  end
+  
+  def down
+   vals=@terms
+   msgs=[]
+   vals.each do |var|
+    msgs << var[self]
+   end
+   update(@sum,vals,msgs,@coeffs)
+  end 
+  
+  def up(index=0)
+    coeff=@coeffs[index]
+    x=0
+    coeffs=[]
+    @coeffs.each do |c|
+      if x!=index
+        coeffs << -c/coeff
+      end
+      x+=1
+    end
+    coeffs.insert(index,1.0/coeff)
+    vals=@terms.dup
+    vals[index]=@sum
+    msgs=[]
+    vals.each do |var|
+      msgs << var[self]
+    end
+    return update(@terms[index],vals,msgs,coeffs)
+  end
+  
+  def update(var,vals,msgs,coeffs)
+    size=coeffs.length-1
+    divs=[]
+    (0..size).each do |x|
+      vl=vals[x]
+      ms=msgs[x]
+      divs << vl/ms
+    end
+    pisum=[]
+    (0..size).each do |x|
+      pisum << coeffs[x]**2/divs[x].pi
+    end
+    pi=1.0/pisum.inject{|sum,x| sum + x }
+    
+    tausum=[]
+    (0..size).each do |x|
+      tausum << coeffs[x]*divs[x].mu
+    end
+    tau=pi*tausum.inject{|sum,x| sum + x }
+    return var.update_message(self,pi,tau)
+  end
+  
+end
+

data/lib/TrueSkill/FactorGraph/TruncateFactor.rb

@@ -0,0 +1,28 @@
+class TruncateFactor < Factor
+  @v_func=nil
+  @w_func=nil
+  @draw_margin=nil
+  
+  def initialize(var,v_func,w_func,draw_margin)
+    super([var])
+    @v_func=v_func
+    @w_func=w_func
+    @draw_margin=draw_margin
+  end
+  
+  
+  def up()
+    val=var
+    msg=var[self]
+    div=val/msg
+    sqrt_pi=Math.sqrt(div.pi)
+    
+    v=@v_func.call(div.tau/sqrt_pi,@draw_margin*sqrt_pi)
+    w=@w_func.call(div.tau/sqrt_pi,@draw_margin*sqrt_pi)
+    
+    denom=(1.0-w)
+    pi=div.pi/denom
+    tau=(div.tau+sqrt_pi*v)/denom
+    return var.update_value(self,pi,tau)
+  end  
+end

data/lib/TrueSkill/FactorGraph/Variable.rb

@@ -0,0 +1,47 @@
+
+class Variable < Gaussian
+
+  
+  @delta=nil
+  def initialize()
+    super()
+    @messages={}
+  end
+  
+  def set(val)
+    @delta=delta(val)
+    @pi=val.pi
+    @tau=val.tau
+  end
+  def delta(other)
+    return [(@tau-other.tau).abs,Math.sqrt((@pi-other.pi).abs)].max
+  end
+  
+  def update_message(factor,pi=0,tau=0,message=nil)
+    if  message.nil?
+      message=Gaussian.new(nil,nil,pi,tau)
+    end
+    old_message=self[factor]
+    self[factor]=message
+    return set(self/old_message*message)
+  end
+  
+  def update_value(factor,pi=0,tau=0,value=nil)
+    if  value.nil?
+      value=Gaussian.new(nil,nil,pi,tau)
+    end
+    old_message=self[factor]
+    self[factor]=value*old_message/self
+    return set(value)
+  end
+  
+  def [](y)
+    @messages[y]
+  end
+  
+  def []=(y,value)
+    @messages[y]=value
+  end
+  
+end
+

data/lib/TrueSkill/Mathematics/general.rb

@@ -0,0 +1,24 @@
+
+ 
+ def ierfcc(p)
+  return -100 if p >= 2.0
+  return 100 if p <= 0.0
+  pp = p < 1.0 ? p : 2 - p
+  t = Math.sqrt(-2*Math.log(pp/2.0)) # Initial guess
+  x = -0.70711*((2.30753 + t*0.27061)/(1.0 + t*(0.99229 + t*0.04481)) - t)
+  [0,1].each do |j|
+    err = Math.erfc(x) - pp
+    x += err/(1.12837916709551257*Math.exp(-(x*x)) - x*err) 
+  end
+  p < 1.0 ? x : -x
+ end
+ 
+ def cdf(x,mu=0,sigma=1)
+  return 0.5*Math.erfc(-(x-mu)/(sigma*Math.sqrt(2)))
+ end
+ def pdf(x,mu=0,sigma=1)
+  return (1/Math.sqrt(2*Math::PI)*sigma.abs)*Math.exp(-(((x-mu)/sigma.abs)**2/2))
+ end
+ def ppf(x,mu=0,sigma=1)
+  return mu-sigma*Math.sqrt(2)*ierfcc(2*x)
+ end

data/lib/TrueSkill/Mathematics/guassian.rb

@@ -0,0 +1,38 @@
+class Gaussian
+  attr_accessor :pi,:tau,:mu,:sigma
+  @pi=nil
+  @tau=nil
+  def initialize(mu=nil,sigma=nil,pi=0,tau=0)
+    if not mu.nil?
+      if sigma.nil? or sigma==0.0
+        raise "a variance(sigma^2) should be greater than 0"
+      end
+      pi=sigma**-2
+      tau=pi*mu
+    end
+    @pi=pi
+    @tau=tau
+  end
+  
+  def mu
+    @tau/@pi
+  end
+  
+  def sigma
+    if @pi.nil? or @pi==0
+      return 1.0/0
+    end
+    return Math.sqrt(1/@pi)
+  end
+  def *(y)
+    pi=@pi+y.pi
+    tau=@tau+y.tau
+    return Gaussian.new(nil,nil,pi,tau)
+  end
+  def /(y)
+    pi=@pi-y.pi
+    tau=@tau-y.tau
+    return Gaussian.new(nil,nil,pi,tau)
+  end
+end
+

data/lib/TrueSkill/Rating.rb

@@ -0,0 +1,23 @@
+
+  class Rating < Gaussian
+  attr_accessor :exposure
+    def initialize(mu=nil,sigma=nil)
+      if mu.kind_of?(Array)
+        mu,sigma=mu
+      end
+      if mu.nil?
+        mu=g().mu
+      end
+      if sigma.nil?
+        sigma=g().sigma
+      end
+      super(mu,sigma)
+    end
+
+    def exposure
+      return mu-3*sigma
+    end
+    def to_s
+      return "[mu="+mu.to_s+",sigma="+sigma.to_s+"]"
+    end
+  end

data/lib/TrueSkill/TrueSkill.rb

@@ -0,0 +1,235 @@
+
+class TrueSkillObject
+
+  attr_accessor :mu,:sigma,:beta,:tau,:draw_probability
+
+  @mu=nil
+  @sigma=nil
+  @beta=nil
+  @tau=nil
+  @draw_probability=nil
+  
+  def initialize(mu=MU, sigma=SIGMA, beta=BETA, tau=TAU,draw_probability=DRAW_PROBABILITY)
+    @mu=mu
+    @sigma=sigma
+    @beta=beta
+    @tau=tau
+    @draw_probability=draw_probability
+  end
+  
+  
+  def Rating(mu=nil,sigma=nil)
+    if mu.nil?
+      mu=@mu
+    end
+    if sigma.nil?
+      sigma=@sigma
+    end
+    return Rating.new mu,sigma
+  end
+  
+  def make_as_global
+    return setup(nil,nil,nil,nil,nil,self)
+  end
+  def validate_rating_groups(rating_groups)
+    rating_groups.each do |group|
+      if group.is_a? Rating
+        group=[group,]
+      end
+      if group.length==0
+        raise "each group must contain multiple ratings"
+      end
+    end
+    if rating_groups.length<2
+      raise "need multiple rating groups"
+    end
+    return rating_groups
+  end
+  def build_factor_graph(rating_groups,ranks)
+    ratings=rating_groups.flatten
+    size=ratings.length
+    group_size=rating_groups.length
+    rating_vars=[]
+    size.times { rating_vars << Variable.new}
+    
+    perf_vars=[]
+    size.times { perf_vars << Variable.new}
+    
+    teamperf_vars=[]
+    group_size.times { teamperf_vars << Variable.new}
+    
+    teamdiff_vars=[]
+    (group_size-1).times { teamdiff_vars << Variable.new}
+    
+    team_sizes=_team_sizes(rating_groups)
+    get_perf_vars_by_team=lambda do |team|
+      if team > 0
+        start=team_sizes[team-1]
+      else
+        start=0
+      end
+      endv=team_sizes[team]
+      return perf_vars[start,endv]
+    end
+    
+    build_rating_layer=lambda do
+      Enumerator.new do |yielder|
+      
+        rating_vars.zip(ratings).each do |rating_var,rating|
+          yielder.yield(PriorFactor.new(rating_var,rating,@tau))
+        end
+      end
+    end
+    build_perf_layer=lambda do
+      Enumerator.new do |yielder|
+      
+        rating_vars.zip(perf_vars).each do |rating_var,perf_var|
+          yielder.yield(LikelihoodFactor.new(rating_var,perf_var,@beta**2))
+        end
+      end
+    end
+    build_teamperf_layer=lambda do
+     Enumerator.new do |yielder|
+       teamperf_vars.each_with_index do |teamperf_var,team|
+          child_perf_vars = get_perf_vars_by_team.call(team)
+          yielder.yield(SumFactor.new(teamperf_var,child_perf_vars,[1]*child_perf_vars.length))
+       end
+     end
+   end
+   build_teamdiff_layer=lambda do
+    Enumerator.new do |yielder|
+      teamdiff_vars.each_with_index do |teamdiff_var,team|
+        yielder.yield(SumFactor.new(teamdiff_var,teamperf_vars[team,team=2],[+1,-1]))
+      end
+    end
+   end
+   build_trunc_layer=lambda do
+    Enumerator.new do |yielder|
+      teamdiff_vars.each_with_index do |teamdiff_var,x|
+        size=0
+        rating_groups[x,x+2].each do |group|
+          size+=group.length
+        end
+        draw_margin=calc_draw_margin(@draw_probability,@beta,size)
+        
+        if ranks[x]==ranks[x+1]
+          v_func,w_func=$v_drawFunc,$w_drawFunc
+        else
+          v_func,w_func=$vFunc,$wFunc
+        end
+        yielder.yield(TruncateFactor.new(teamdiff_var,v_func,w_func,draw_margin))
+      end
+    end
+   end
+   
+   return Array(build_rating_layer.call),Array(build_perf_layer.call),Array(build_teamperf_layer.call),Array(build_teamdiff_layer.call),Array(build_trunc_layer.call)
+  end
+  
+  def run_schedule(rating_layer, perf_layer, teamperf_layer,teamdiff_layer, trunc_layer, min_delta=DELTA)
+    [rating_layer,perf_layer,teamperf_layer].flatten.each do |f|
+      f.down
+    end
+    teamdiff_len=teamdiff_layer.length
+    (10).times do |x|
+      if teamdiff_len==1
+        teamdiff_layer[0].down
+        delta=trunc_layer[0].up
+      else
+        delta=0
+        (teamdiff_len-1).times do |x2|
+          teamdiff_layer[x2].down
+          delta=[delta,trunc_layer[x].up].max
+          teamdiff_layer[x].up(1)
+        end
+        (teamdiff_len-1).step(0,-1) do |x2|
+          teamdiff_layer[x2].down
+          delta=[delta,trunc_layer[x].up].max
+          teamdiff_layer[x].up(0)
+        end
+      end
+      if delta<=min_delta
+        break
+      end
+    end
+    teamdiff_layer.first.up(0)
+    teamdiff_layer.last.up(1)
+    teamperf_layer.each do |f|
+      (f.vars.length-1).times do |x|
+        f.up(x)
+      end
+    end
+    perf_layer.each do |f|
+      f.up
+    end
+  end
+  def transform_ratings(rating_groups, ranks=nil, min_delta=DELTA)
+    rating_groups=validate_rating_groups(rating_groups)
+    group_size=rating_groups.length
+    if ranks.nil?
+      ranks=Array(0..group_size-1)
+    end
+    sorting=ranks.zip(rating_groups).each_with_index.to_a.map {|x| x.reverse}.sort { |x,y| x[1][0] <=> y[1][0]}
+    sorted_groups=[]
+    sorting.each do |x,g|
+      sorted_groups << g[1]
+    end
+    sorted_ranks=ranks.sort()
+    unsorting_hint=[]
+    sorting.each do |x,g|
+      unsorting_hint << x
+    end
+    layers=build_factor_graph(sorted_groups,sorted_ranks)
+    run_schedule(layers[0],layers[1],layers[2],layers[3],layers[4])
+    rating_layer,team_sizes=layers[0],_team_sizes(sorted_groups)
+    transformed_groups=[]
+    ([0]+team_sizes.take(team_sizes.size - 1)).zip(team_sizes).each do |start,ending|
+      group=[]
+      rating_layer[start,ending].each do |f|
+        group << Rating.new(f.var.mu,f.var.sigma)
+      end
+      transformed_groups << Array(group)
+    end
+    unsorting=unsorting_hint.zip(transformed_groups).sort { |x,y| x[0]<=>y[0]}
+    output=[]
+    unsorting.each do |x,g|
+      output << g
+    end
+    return output
+  end
+  #def match_quality(rating_groups)
+    #rating_groups=validate_rating_groups(rating_groups)
+    #ratings=rating_groups.flatten
+    #length=ratings.length
+    #mean_rows=[]
+    #ratings.each {|r| mean_rows << [r.mu] }
+    #mean_matrix=Matrix[*mean_rows]
+    #variance_rows=[]
+    #ratings.each {|r| variance_rows << r.sigma**2 }
+    #variance_matrix=Matrix.diagonal *variance_rows 
+    #rotated_a_matrix=lambda do
+    #    mat=[]
+    #    t=0
+    #    rating_groups.clip.zip(rating_groups.drop(1)).each_with_index do |y,r|
+    #      rline=[]
+    #      cur=y[0]
+    #      nex=y[1]
+    #      z=0
+    #      (t..t+cur.length).each do |x|
+    #        rline << 1
+    #        t+=1
+    #        z=x
+    #      end
+    #      z+=1
+    #      (z..z+nex.length).each do |x|
+    #        rline << -1
+    #      end
+    #      mat << rline
+    #    end
+    #    mat
+    #end
+    #rotated_a_matrix=Matrix[rotated_a_matrix.call]
+    #a_matrix = rotated_a_matrix.transpose()
+    #_ata = (@beta ** 2) * rotated_a_matrix * a_matrix
+    #pp _ata
+  #end
+end

data/lib/TrueSkill/general.rb

@@ -0,0 +1,71 @@
+
+  MU=25.0
+  SIGMA=MU/3
+  BETA=SIGMA/2
+  TAU=SIGMA/100
+  DRAW_PROBABILITY=0.10
+  DELTA=0.001
+
+
+  $vFunc=Proc.new  do |diff,draw_margin|
+    x=diff-draw_margin
+    pdf(x)/cdf(x)
+  end
+  
+  $wFunc=Proc.new do |diff,draw_margin|
+    x=diff-draw_margin
+    v=$vFunc.call(diff,draw_margin)
+    v*(v+x)
+  end
+  
+  $v_drawFunc=Proc.new do |diff,draw_margin|
+    abs_diff=diff.abs
+    a=draw_margin-abs_diff
+    b=-draw_margin-abs_diff
+    denom=cdf(a)-cdf(b)
+    numer=pdf(b)-pdf(a)
+    numer/denom*((diff<0)?-1:1)
+  end
+  $w_drawFunc=Proc.new do |diff,draw_margin|
+    abs_diff=diff.abs
+    a=draw_margin-abs_diff
+    b=-draw_margin-abs_diff
+    denom=cdf(a)-cdf(b)
+    v=$v_drawFunc.call(abs_diff,draw_margin)
+    (v**2)+(a*pdf(a)-b*pdf(b))/denom
+  end
+  
+  def calc_draw_probability(draw_margin,beta,size)
+    return 2*cdf(draw_margin*(Math.sqrt(size)*beta))-1
+  end
+  
+  def calc_draw_margin(draw_probability, beta, size)
+    return ppf((draw_probability+1)/2.0)*Math.sqrt(size)*beta
+  end
+  
+  def _team_sizes(rating_groups)
+    team_sizes=[0]
+    rating_groups.each do |group|
+      team_sizes << group.length+team_sizes.last
+    end
+    team_sizes.delete_at(0)
+    return team_sizes
+  end
+$global=[]
+
+  def g()
+    if $global.length==0
+      setup()
+    end
+    return $global[0]
+  end
+  def setup(mu=MU, sigma=SIGMA, beta=BETA, tau=TAU,draw_probability=DRAW_PROBABILITY, env=nil)
+    $global.pop
+    if env.nil?
+      $global << TrueSkillObject.new(mu, sigma, beta, tau, draw_probability)
+    else
+      $global << env
+    end
+    return g()
+  end
+

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: trueskill-ranked
+version: !ruby/object:Gem::Version
+  version: 0.9b
+  prerelease: 3
+platform: ruby
+authors:
+- Katrina Swales
+- Heungsub Lee
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-13 00:00:00.000000000 Z
+dependencies: []
+description: A improved TrueSkill with correct ranking order
+email: kat.swales@nekokittygames.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/TrueSkill.rb
+- lib/TrueSkill/Array.rb
+- lib/TrueSkill/core_ext.rb
+- lib/TrueSkill/Rating.rb
+- lib/TrueSkill/general.rb
+- lib/TrueSkill/TrueSkill.rb
+- lib/TrueSkill/FactorGraph/Factor.rb
+- lib/TrueSkill/FactorGraph/LikelihoodFactor.rb
+- lib/TrueSkill/FactorGraph/PriorFactor.rb
+- lib/TrueSkill/FactorGraph/SumFactor.rb
+- lib/TrueSkill/FactorGraph/TruncateFactor.rb
+- lib/TrueSkill/FactorGraph/Variable.rb
+- lib/TrueSkill/Mathematics/general.rb
+- lib/TrueSkill/Mathematics/guassian.rb
+homepage: http://rubygems.org/gems/trueskill-ranked
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Ranked TrueSkill
+test_files: []