swaits/glicko2
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

merge into: swaits/glicko2:main
swaits/glicko2:main swaits/glicko2:1.1
swaits/glicko2:RELEASE-1.1.0
..
pull from: swaits/glicko2:1.1
swaits/glicko2:main swaits/glicko2:1.1
swaits/glicko2:RELEASE-1.1.0
1 Commits
main .. 1.1
Author SHA1 Message Date
swaits e639ee28c7 create 1.1 branch 2005-05-12 18:25:57 +00:00
6 changed files with 57 additions and 395 deletions
Expand all files Collapse all files

No files matched your search

LICENSE
-19
View File
@@ -1,19 +0,0 @@
Copyright 2013 Stephen Waits <steve@waits.net>
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.
README.md
-2
View File
@@ -1,2 +0,0 @@
An implementation of the Glicko2 algorithm in several languages (ruby,
python, c++).
go/glicko2.go
-258
View File
@@ -1,258 +0,0 @@
//
//
// Copyright (c) 2013 Stephen Waits
//
// This software is provided 'as-is', without any express or implied warranty. In
// no event will the authors be held liable for any damages arising from the use
// of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you must not claim
// that you wrote the original software. If you use this software in a
// product, an acknowledgment in the product documentation would be
// appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such, and must not be
// misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
//
//
// Glicko-2 Rating calculator package.
//
// This package implements the Glicko-2 rating system algorithm written by
// Professor Mark E. Glickman. All rating inputs and outputs are Glicko ratings,
// but internally everything is converted to and considered Glicko-2 ratings.
//
// Glicko-2 is an improvement on the original Glicko, which was, in turn, an
// improvement on the ELO system.
//
// The Glicko-2 system is specified on http://www.glicko.com/
//
package glicko2
import (
"fmt"
"math"
)
// system constant, determines delta volatility over time; should be [0.3,1.2]
const kDVOL float64 = 0.3
// Glicko2 state reprensentation (Glicko2 uses different scales from Glicko)
type Glicko2 struct {
rating float64
deviation float64
volatility float64
wins [](*Glicko2)
losses [](*Glicko2)
draws [](*Glicko2)
}
// Initializer with rating, rating deviation, and volatility specified.
func NewGlicko2(rating float64, deviation float64, volatility float64) *Glicko2 {
return newGlicko2(rating, deviation, volatility)
}
// Initializer with default rating, rating deviation, and volatility.
func NewDefaultGlicko2() *Glicko2 {
return newGlicko2(1500.0, 350.0, 0.06)
}
// helper for initialization
func newGlicko2(rating float64, deviation float64, volatility float64) *Glicko2 {
g := new(Glicko2)
g.SetRating(rating)
g.SetDeviation(deviation)
g.SetVolatility(volatility)
return g
}
// get the probability of beating opponent
func (g *Glicko2) ProbWin(opponent *Glicko2) float64 {
return 1.0 / (1.0 + math.Pow(10.0, ((opponent.Rating()-g.Rating())/(400.0*math.Sqrt(1.0+0.0000100723986*((g.Deviation()*g.Deviation())+(opponent.Deviation()*opponent.Deviation())))))))
}
// Get the current rating. This rating is a Glicko rating, not a Glicko2 rating.
// For details, please see http://www.glicko.com/
func (g *Glicko2) Rating() float64 {
return ((g.rating * 173.7178) + 1500.0)
}
// Set Glicko rating. Internally this is converted to a Glicko2 rating.
// For details, please see http://www.glicko.com/
func (g *Glicko2) SetRating(rating float64) {
g.rating = (rating - 1500.0) / 173.7178
}
// Get the current rating deviation. This is a Glicko rating deviation, not a
// Glicko-2 RD. For details, please see http://www.glicko.com/
func (g *Glicko2) Deviation() float64 {
return (g.deviation * 173.7178)
}
// Set Glicko rating deviation. Internally this is converted to a Glicko-2 RD.
// For details, please see http://www.glicko.com/
func (g *Glicko2) SetDeviation(deviation float64) {
g.deviation = deviation / 173.7178
}
// Get the current rating volatility.
func (g *Glicko2) Volatility() float64 {
return g.volatility
}
// Set rating volatility.
func (g *Glicko2) SetVolatility(volatility float64) {
g.volatility = volatility
}
// helper to make a copy of a Glicko2 struct
func (g *Glicko2) duplicate() *Glicko2 {
c := *g
return &c
}
// Clear all results previously added via add_result(), add_win(), add_loss(),
// and/or add_draw(). This method is called automatically whenever update()
// is called.
func (g *Glicko2) ClearResults() {
g.wins = nil
g.losses = nil
g.draws = nil
}
// Add a win result to this rating. Note that no calculation is performed until
// Update() is called.
func (g *Glicko2) AddWin(loser *Glicko2) {
g.wins = append(g.wins, loser.duplicate())
}
// Add a loss result to this rating. Note that no calculation is performed until
// Update() is called.
func (g *Glicko2) AddLoss(winner *Glicko2) {
g.losses = append(g.losses, winner.duplicate())
}
// Add a draw result to this rating. Note that no calculation is performed until
// Update() is called.
func (g *Glicko2) AddDraw(drawer *Glicko2) {
g.draws = append(g.draws, drawer.duplicate())
}
// Print a Glicko2 struct
func (g *Glicko2) Print() {
fmt.Printf(" rating: %v\n", g.Rating())
fmt.Printf(" deviation: %v\n", g.Deviation())
fmt.Printf("volatility: %v\n", g.Volatility())
for _, win := range g.wins {
fmt.Printf(" *beat\n")
fmt.Printf(" rating: %v\n", win.Rating())
fmt.Printf(" deviation: %v\n", win.Deviation())
fmt.Printf(" volatility: %v\n", win.Volatility())
}
}
// util func 'g'
func calcG(deviation float64) float64 {
return 1.0 / (math.Sqrt(1.0 + 3.0*(deviation*deviation)/(math.Pi*math.Pi)))
}
// util func 'E'
func calcE(rating float64, rating_opponent float64, deviation_opponent float64) float64 {
return 1.0 / (1.0 + math.Exp(-calcG(deviation_opponent)*(rating-rating_opponent)))
}
// Update rating based on current results list, and clear results.
func (g *Glicko2) Update() {
// merge wins, losses, draws slices for convenience
results := append(append(g.wins, g.losses...), g.draws...)
// Note that if a player does not compete during the rating period, then
// only Step 6 applies.
if len(results) == 0 {
g.deviation = math.Sqrt((g.deviation * g.deviation) + (g.volatility * g.volatility))
return
}
// Step 1. Determine a rating and RD for each player at the onset of the
// rating period. The system constant which constrains the change in
// volatility over time, needs to be set prior to application of the system.
// Reasonable choices are between 0.3 and 1.2, though the system should be
// tested to decide which value results in greatest predictive accuracy
// ... (ratings already stored in instance)
// Step 2. For each player, convert the ratings and RD's onto the Glicko-2
// scale.
// ... (ratings already stored in G2 format)
// Step 3. Compute the quantity v. This is the estimated variance of the
// team's/player's rating based only on game outcomes.
variance := 0.0
for _, r := range results {
g_i := calcG(r.deviation)
e_i := calcE(g.rating, r.rating, r.deviation)
variance += (g_i * g_i) * e_i * (1.0 - e_i)
}
variance = 1.0 / variance
// Step 4. Compute the quantity 'delta', the estimated improvement in rating
// by comparing the pre-period rating to the performance rating based only
// on game outcomes.
delta := 0.0
for _, r := range g.wins {
delta += calcG(r.deviation) * (1.0 - calcE(g.rating, r.rating, r.deviation))
}
for _, r := range g.losses {
delta += calcG(r.deviation) * (0.0 - calcE(g.rating, r.rating, r.deviation))
}
for _, r := range g.draws {
delta += calcG(r.deviation) * (0.5 - calcE(g.rating, r.rating, r.deviation))
}
delta *= variance
// Step 5. Determine the new value of the volatility.
new_volatility := 0.0
a := math.Log((g.volatility * g.volatility))
x := 0.0
x_new := a
for math.Abs(x-x_new) > 0.0000001 {
x = x_new
d := (g.deviation * g.deviation) + variance + math.Exp(x)
h1 := -(x-a)/(kDVOL*kDVOL) - 0.5*math.Exp(x)/d + 0.5*math.Exp(x)*(delta/d)*(delta/d)
h2 := -1.0/(kDVOL*kDVOL) - 0.5*math.Exp(x)*((g.deviation*g.deviation)+variance)/(d*d) + 0.5*(delta*delta)*math.Exp(x)*((g.deviation*g.deviation)+variance-math.Exp(x))/(d*d*d)
x_new = x - h1/h2
}
new_volatility = math.Exp(x_new / 2.0)
// Step 6. Update the rating deviation to the new pre-rating period value.
pre_deviation := math.Sqrt((g.deviation * g.deviation) + (new_volatility * new_volatility))
// Step 7. Update the rating and RD to the new values.
new_deviation := 1.0 / (math.Sqrt(1.0/(pre_deviation*pre_deviation) + 1.0/variance))
new_rating := 0.0
for _, r := range g.wins {
new_rating += calcG(r.deviation) * (1.0 - calcE(g.rating, r.rating, r.deviation))
}
for _, r := range g.losses {
new_rating += calcG(r.deviation) * (0.0 - calcE(g.rating, r.rating, r.deviation))
}
for _, r := range g.draws {
new_rating += calcG(r.deviation) * (0.5 - calcE(g.rating, r.rating, r.deviation))
}
new_rating = new_rating * (new_deviation * new_deviation)
new_rating += g.rating
// Step 8. Convert ratings and RD's back to original scale.
g.deviation = new_deviation
g.volatility = new_volatility
g.rating = new_rating
// wipe our result lists
g.ClearResults()
}
go/glicko2_test.go
-47
View File
@@ -1,47 +0,0 @@
package glicko2
import (
"testing"
"math"
)
func inRange(want float64, have float64, delta float64) bool {
return math.Abs(want-have) <= delta
}
func TestGlicko2(t *testing.T) {
a := NewGlicko2(1500.0, 200.0, 0.06)
b := NewGlicko2(1400.0, 30.0, 0.06)
c := NewGlicko2(1550.0, 100.0, 0.06)
d := NewGlicko2(1700.0, 300.0, 0.06)
a.AddWin(b)
a.AddLoss(c)
a.AddLoss(d)
if a.Rating() != 1500.0 {
t.Error()
}
if a.Deviation() != 200.0 {
t.Error()
}
a.Update()
if !inRange(a.Rating(),1464.05,0.01) {
t.Error()
}
if !inRange(a.Deviation(),151.516,0.01) {
t.Error()
}
a.Update()
if !inRange(a.Rating(),1464.05,0.01) {
t.Error()
}
if !inRange(a.Deviation(),151.875,0.01) {
t.Error()
}
}
rb/glicko2.rb
+54 -66
View File
@@ -1,8 +1,8 @@
#!/usr/bin/env ruby -w #!/usr/bin/env ruby
# #
# #
# Copyright (c) 2013 Stephen Waits # Copyright (c) 2004 Stephen Waits
# #
# This software is provided 'as-is', without any express or implied warranty. In # This software is provided 'as-is', without any express or implied warranty. In
# no event will the authors be held liable for any damages arising from the use # no event will the authors be held liable for any damages arising from the use
@@ -41,7 +41,7 @@ class Glicko2
protected protected
# Glicko2 reprensentation (Glicko2 uses different scales from Glicko) # Glicko2 reprensentation (Glicko2 uses different scales from Glicko)
attr_reader :g2rating, :g2deviation, :g2volatility attr_accessor :g2rating, :g2deviation, :g2volatility
# a nested Class to hold a single result # a nested Class to hold a single result
Result = Struct.new(:opponent, :result) Result = Struct.new(:opponent, :result)
@@ -52,13 +52,11 @@ class Glicko2
LOSS = 0.0 LOSS = 0.0
DRAW = 0.5 DRAW = 0.5
# system constant, determines delta volatility over time; should be [0.3,1.2]
DVOL = 0.3
# Constructor with rating, rating deviation, and volatility optionally # Constructor with rating, rating deviation, and volatility optionally
# specified. If nothing specified, nitializes to a rating of 1500, a # specified. If nothing specified, nitializes to a rating of 1500, a
# rating deviation of 350, and a volatility of 0.06. # rating deviation of 350, and a volatility of 0.06.
def initialize(rating = 1500.0, deviation = 350.0, volatility = 0.06) def initialize(rating = 1500.0, deviation = 350.0, volatility = 0.06)
@dvolatility = 0.3
self.rating = rating self.rating = rating
self.deviation = deviation self.deviation = deviation
self.volatility = volatility self.volatility = volatility
@@ -69,12 +67,7 @@ class Glicko2
# Comparison operator # Comparison operator
def <=>(other) def <=>(other)
p_win(other) <=> 0.5 self.rating <=> other.rating
end
# get the probability of beating opponent
def p_win(opponent)
1.0 / (1.0 + 10.0**(((opponent.rating - self.rating) / (400.0 * Math.sqrt(1.0 + 0.0000100723986 * (self.deviation**2.0 + opponent.deviation**2.0))))))
end end
# Get the current rating. This rating is a Glicko rating, not a Glicko2 rating. # Get the current rating. This rating is a Glicko rating, not a Glicko2 rating.
@@ -115,14 +108,14 @@ class Glicko2
# and/or add_draw(). This method is called automatically whenever update() # and/or add_draw(). This method is called automatically whenever update()
# is called. # is called.
def clear_results def clear_results
@opponents = Array.new @opponents = []
@results = Array.new @results = []
end end
# Add a result to this rating. Note that no calculation is performed until # Add a result to this rating. Note that no calculation is performed until
# update() is called. # update() is called.
def add_result(opponent,result) def add_result(opponent,result)
@results << Result.new(opponent.clone, result) @results.push( Result.new(opponent.clone, result) )
end end
# Add a win result to this rating. Note that no calculation is performed until # Add a win result to this rating. Note that no calculation is performed until
@@ -143,86 +136,81 @@ class Glicko2
add_result(opponent,Glicko2::DRAW) add_result(opponent,Glicko2::DRAW)
end end
# util func 'g' # Update rating based on current results list, and clear results.
def update
# util func
def Glicko2.g(deviation) def Glicko2.g(deviation)
1.0 / (Math.sqrt(1.0 + 3.0 * deviation ** 2.0 / (Math::PI ** 2.0))) 1.0 / (Math.sqrt(1.0 + 3.0 * deviation ** 2.0 / (Math::PI ** 2.0)))
end end
# util func 'E' # util func
def Glicko2.E(rating, rating_opponent, deviation_opponent) def Glicko2.E(rating, rating_opponent, deviation_opponent)
1.0 / (1.0 + Math.exp(-Glicko2.g(deviation_opponent)*(rating - rating_opponent))); 1.0 / (1.0 + Math.exp(-Glicko2.g(deviation_opponent)*(rating - rating_opponent)));
end end
# Update rating based on current results list, and clear results. # bail if no opponents set
def update
# Note that if a player does not compete during the rating period, then
# only Step 6 applies.
if @results.empty? if @results.empty?
# In this case, the player's rating and volatility parameters remain the return nil
# same, but the RD increases according to:
@g2deviation = Math.sqrt(@g2deviation**2.0 + @g2volatility**2.0)
return
end end
# Step 1. Determine a rating and RD for each player at the onset of the # compute variance
# rating period. The system constant which constrains the change in
# volatility over time, needs to be set prior to application of the system.
# Reasonable choices are between 0.3 and 1.2, though the system should be
# tested to decide which value results in greatest predictive accuracy
# ... (ratings already stored in instance)
# Step 2. For each player, convert the ratings and RD's onto the Glicko-2 #variance = 0.0
# scale. #@results.inject(0.0) do |variance,r|
# ... (ratings already stored in G2 format) # g_i = Glicko2.g(r.opponent.g2deviation)
# e_i = Glicko2.E(@g2rating,r.opponent.g2rating,r.opponent.g2deviation)
# g_i ** 2.0 * e_i * (1.0 - e_i)
#end
# Step 3. Compute the quantity v. This is the estimated variance of the variance = 0.0
# team's/player's rating based only on game outcomes. @results.each do |r|
variance = 1.0 / @results.inject(0.0) do |sum,r|
g_i = Glicko2.g(r.opponent.g2deviation) g_i = Glicko2.g(r.opponent.g2deviation)
e_i = Glicko2.E(@g2rating,r.opponent.g2rating,r.opponent.g2deviation) e_i = Glicko2.E(@g2rating,r.opponent.g2rating,r.opponent.g2deviation)
sum + g_i**2.0 * e_i * (1.0 - e_i) variance += g_i ** 2.0 * e_i * (1.0 - e_i)
end end
variance = 1.0 / variance
# Step 4. Compute the quantity 'delta', the estimated improvement in rating # compute delta
# by comparing the pre-period rating to the performance rating based only delta = 0.0
# on game outcomes. @results.each do |r|
delta = variance * @results.inject(0.0) do |sum,r| delta += Glicko2.g(r.opponent.g2deviation) * (r.result - Glicko2.E(@g2rating, r.opponent.g2rating, r.opponent.g2deviation))
g_i = Glicko2.g(r.opponent.g2deviation)
e_i = Glicko2.E(@g2rating, r.opponent.g2rating, r.opponent.g2deviation)
sum + g_i * (r.result - e_i)
end end
delta *= variance
# Step 5. Determine the new value of the volatility. # determine new volatility
new_volatility = 0.0
a = Math.log( @g2volatility**2.0 ) a = Math.log( @g2volatility**2.0 )
x0, x1 = 0.0, a x = 0.0
while ((x0 - x1).abs > 0.0000001) x_new = a
x0 = x1 while ( (x - x_new).abs > 0.0000001 )
d = @g2deviation**2.0 + variance + Math.exp(x0) x = x_new
h1 = -(x0 - a)/(DVOL**2.0) - 0.5*Math.exp(x0)/d + 0.5*Math.exp(x0)*(delta/d)*(delta/d) d = @g2deviation**2.0 + variance + Math.exp(x)
h2 = -1.0/(DVOL**2.0) - 0.5*Math.exp(x0)*(@g2deviation**2.0+variance)/(d**2.0) + 0.5*(delta**2.0)*Math.exp(x0)*((@g2deviation**2.0) + variance - Math.exp(x0))/(d**3.0) h1 = -(x - a)/(@dvolatility**2.0) - 0.5*Math.exp(x)/d + 0.5*Math.exp(x)*(delta/d)*(delta/d)
x1 = x0 - h1/h2 h2 = -1.0/(@dvolatility**2.0) - 0.5*Math.exp(x)*(@g2deviation**2.0+variance)/(d**2.0) + 0.5*(delta**2.0)*Math.exp(x)*((@g2deviation**2.0) + variance - Math.exp(x))/(d**3.0)
x_new = x - h1/h2
end end
new_volatility = Math.exp(x1 / 2.0) new_volatility = Math.exp(x_new / 2.0)
# Step 6. Update the rating deviation to the new pre-rating period value. # update the rating deviation to the new pre-rating period value
pre_deviation = Math.sqrt( @g2deviation**2.0 + new_volatility**2.0 ) pre_deviation = Math.sqrt( @g2deviation**2.0 + new_volatility**2.0 )
# Step 7. Update the rating and RD to the new values. # update the rating and deviation
new_deviation = 1.0 / (Math.sqrt( 1.0/(pre_deviation**2.0) + 1.0 / variance)) new_deviation = 1.0 / (Math.sqrt( 1.0/(pre_deviation**2.0) + 1.0 / variance))
new_rating = @g2rating + new_deviation**2.0 * @results.inject(0.0) do |sum,r| new_rating = 0.0
g_i = Glicko2.g(r.opponent.g2deviation) @results.each do |r|
e_i = Glicko2.E(@g2rating, r.opponent.g2rating, r.opponent.g2deviation) new_rating += Glicko2.g(r.opponent.g2deviation) * (r.result - Glicko2.E(@g2rating, r.opponent.g2rating, r.opponent.g2deviation))
sum + g_i * (r.result - e_i)
end end
new_rating = new_rating * new_deviation**2.0
# Step 8. Convert ratings and RD's back to original scale. new_rating += @g2rating
@g2deviation = new_deviation
@g2volatility = new_volatility
@g2rating = new_rating
# wipe our result lists # wipe our result lists
clear_results clear_results
end
# copy new values
@g2deviation = new_deviation
@g2volatility = new_volatility
@g2rating = new_rating
end
end end
rb/test_glicko2.rb
Executable → Regular
+3 -3
View File
@@ -1,6 +1,6 @@
#!/usr/bin/env ruby -w #!/usr/bin/env ruby
require_relative 'glicko2' require 'glicko2'
require 'test/unit' require 'test/unit'
class TestGlicko2 < Test::Unit::TestCase class TestGlicko2 < Test::Unit::TestCase
@@ -26,7 +26,7 @@ class TestGlicko2 < Test::Unit::TestCase
a.update() a.update()
assert_in_delta(1464.05,a.rating,0.01) assert_in_delta(1464.05,a.rating,0.01)
assert_in_delta(151.875,a.deviation,0.01) assert_in_delta(151.516,a.deviation,0.01)
end end