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

merge

Browse Source
This commit is contained in:
swaits committed 2013-07-30 01:54:47 -07:00
2 parents a8d34856b2 6d99d00885
commit f4b06ae191
5 files changed
+366 -356
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

cpp/glicko2.cpp
+21 -21
View File
@@ -33,33 +33,33 @@
class Glicko2_impl class Glicko2_impl
{ {
public: public:
// constructors // constructors
Glicko2_impl(); Glicko2_impl();
Glicko2_impl(const Glicko2_impl& rhs); Glicko2_impl(const Glicko2_impl& rhs);
// copy assignment // copy assignment
Glicko2_impl& operator=(const Glicko2_impl& rhs); Glicko2_impl& operator=(const Glicko2_impl& rhs);
// destructor // destructor
virtual ~Glicko2_impl(); virtual ~Glicko2_impl();
// system constants // system constants
static const double dvolatility; static const double dvolatility;
// rating data // rating data
double rating; double rating;
double deviation; double deviation;
double volatility; double volatility;
// result data (copy of each opponent and results, 0.0, 0.5, or 1.0) // result data (copy of each opponent and results, 0.0, 0.5, or 1.0)
std::vector<Glicko2> opponents; std::vector<Glicko2> opponents;
std::vector<double> results; std::vector<double> results;
// utility functions // utility functions
double g(const double& deviation); double g(const double& deviation);
double E(const double& rating, const double& rating_opponent, const double& deviation_opponent); double E(const double& rating, const double& rating_opponent, const double& deviation_opponent);
}; };
@@ -116,7 +116,7 @@ Glicko2_impl::~Glicko2_impl()
double Glicko2_impl::g(const double& deviation) double Glicko2_impl::g(const double& deviation)
{ {
#define PI_SQUARED (9.86960440108935861883) #define PI_SQUARED (9.86960440108935861883)
return 1.0 / (sqrt(1.0 + 3.0 * deviation * deviation / PI_SQUARED)); return 1.0 / (sqrt(1.0 + 3.0 * deviation * deviation / PI_SQUARED));
} }
cpp/glicko2.h
+148 -148
View File
@@ -47,195 +47,195 @@ class Glicko2_impl;
*/ */
class Glicko2 class Glicko2
{ {
public: public:
/**
* Enumeration of possible results.
*/
enum RESULT
{
/**
* A win result, internally 1.0.
*/
WIN,
/** /**
* A loss result, internally 0.0. * Enumeration of possible results.
*/ */
LOSS, enum RESULT
{
/**
* A win result, internally 1.0.
*/
WIN,
/**
* A loss result, internally 0.0.
*/
LOSS,
/**
* A draw result, internally 0.5.
*/
DRAW
};
/** /**
* A draw result, internally 0.5. * Default constructor. Initializes to a rating of 1500, a rating deviation
* of 350, and a volatility of 0.06.
*/ */
DRAW Glicko2();
};
/**
* Copy constructor.
*
* @param rhs Object to copy.
*/
Glicko2(const Glicko2& rhs);
/**
* Constructor with rating, rating deviation, and volatility specified.
*
* @param rating Initial rating.
* @param deviation Initial rating deviation.
* @param volatility Initial volatility.
*/
Glicko2(double rating, double deviation, double volatility);
/** /**
* Default constructor. Initializes to a rating of 1500, a rating deviation * Copy assignment operator.
* of 350, and a volatility of 0.06. *
*/ * @param rhs Object to copy.
Glicko2(); *
* @return Reference to self after copy assignment.
/** */
* Copy constructor. Glicko2& operator=(const Glicko2& rhs);
*
* @param rhs Object to copy.
*/
Glicko2(const Glicko2& rhs);
/**
* Constructor with rating, rating deviation, and volatility specified.
*
* @param rating Initial rating.
* @param deviation Initial rating deviation.
* @param volatility Initial volatility.
*/
Glicko2(double rating, double deviation, double volatility);
/** /**
* Copy assignment operator. * Destructor.
* */
* @param rhs Object to copy. virtual ~Glicko2();
*
* @return Reference to self after copy assignment.
*/
Glicko2& operator=(const Glicko2& rhs);
/** /**
* Destructor. * Less than comparison operator.
*/ *
virtual ~Glicko2(); * @param rhs Object to compare against.
*
* @return true if this object's rating is less than rhs's rating; false otherwise.
*/
bool operator< (const Glicko2& rhs);
/** /**
* Less than comparison operator. * Get the current rating. This rating is a Glicko rating, not a Glicko2 rating.
* * For details, please see http://www.glicko.com/
* @param rhs Object to compare against. *
* * @return
* @return true if this object's rating is less than rhs's rating; false otherwise. */
*/ double GetRating() const;
bool operator< (const Glicko2& rhs);
/**
* Get the current rating deviation. This is a Glicko rating deviation, not a
* Glicko-2 RD. For details, please see http://www.glicko.com/
*
* @return
*/
double GetDeviation() const;
/**
* Get the current rating volatility.
*
* @return
*/
double GetVolatility() const;
/** /**
* Get the current rating. This rating is a Glicko rating, not a Glicko2 rating. * Set Glicko rating. Internally this is converted to a Glicko2 rating.
* For details, please see http://www.glicko.com/ * For details, please see http://www.glicko.com/
* *
* @return * @param rating Rating.
*/ */
double GetRating() const; void SetRating(double rating);
/** /**
* Get the current rating deviation. This is a Glicko rating deviation, not a * Set Glicko rating deviation. Internally this is converted to a Glicko-2 RD.
* Glicko-2 RD. For details, please see http://www.glicko.com/ * For details, please see http://www.glicko.com/
* *
* @return * @param deviation Rating deviation.
*/ */
double GetDeviation() const; void SetDeviation(double deviation);
/** /**
* Get the current rating volatility. * Set rating volatility.
* *
* @return * @param volatility Rating volatility.
*/ */
double GetVolatility() const; void SetVolatility(double volatility);
/** /**
* Set Glicko rating. Internally this is converted to a Glicko2 rating. * Clear all results previously added via AddResult(), AddWin(), AddLoss(),
* For details, please see http://www.glicko.com/ * and/or AddDraw(). This method is called automatically whenever Update()
* * is called.
* @param rating Rating. */
*/ void ClearResults();
void SetRating(double rating);
/**
* Set Glicko rating deviation. Internally this is converted to a Glicko-2 RD.
* For details, please see http://www.glicko.com/
*
* @param deviation Rating deviation.
*/
void SetDeviation(double deviation);
/**
* Set rating volatility.
*
* @param volatility Rating volatility.
*/
void SetVolatility(double volatility);
/** /**
* Clear all results previously added via AddResult(), AddWin(), AddLoss(), * Add a result to this rating. Note that no calculation is performed until
* and/or AddDraw(). This method is called automatically whenever Update() * Update() is called.
* is called. *
*/ * @param opponent Other player in contest.
void ClearResults(); * @param result WIN, LOSS, or DRAW; from the point of view of this player.
*/
void AddResult(const Glicko2& opponent, RESULT result);
/** /**
* Add a 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
* Update() is called. * Update() is called.
* *
* @param opponent Other player in contest. * @param opponent Other (losing) player in contest.
* @param result WIN, LOSS, or DRAW; from the point of view of this player. */
*/ void AddWin(const Glicko2& opponent);
void AddResult(const Glicko2& opponent, RESULT result);
/**
* Add a loss result to this rating. Note that no calculation is performed until
* Update() is called.
*
* @param opponent Other (winning) player in contest.
*/
void AddLoss(const Glicko2& opponent);
/**
* Add a draw result to this rating. Note that no calculation is performed until
* Update() is called.
*
* @param opponent Other (drawing) player in contest.
*/
void AddDraw(const Glicko2& opponent);
/** /**
* Add a win result to this rating. Note that no calculation is performed until * Update rating based on current results list, and clear results.
* Update() is called. */
* void Update();
* @param opponent Other (losing) player in contest.
*/
void AddWin(const Glicko2& opponent);
/**
* Add a loss result to this rating. Note that no calculation is performed until
* Update() is called.
*
* @param opponent Other (winning) player in contest.
*/
void AddLoss(const Glicko2& opponent);
/**
* Add a draw result to this rating. Note that no calculation is performed until
* Update() is called.
*
* @param opponent Other (drawing) player in contest.
*/
void AddDraw(const Glicko2& opponent);
/** private:
* Update rating based on current results list, and clear results.
*/
void Update();
/**
* Private Implementation.
private: */
Glicko2_impl* pimpl;
/**
* Private Implementation.
*/
Glicko2_impl* pimpl;
}; };
py/glicko2.py
+6 -6
View File
@@ -30,14 +30,14 @@ import copy
class Glicko2: class Glicko2:
""" """
Glicko-2 Rating calculator class. Glicko-2 Rating calculator class.
This class implements the Glicko-2 rating system algorithm written by This class implements the Glicko-2 rating system algorithm written by
Professor Mark E. Glickman. All rating inputs and outputs are Glicko ratings, Professor Mark E. Glickman. All rating inputs and outputs are Glicko ratings,
but internally everything is converted to and considered Glicko-2 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 Glicko-2 is an improvement on the original Glicko, which was, in turn, an
improvement on the ELO system. improvement on the ELO system.
The Glicko-2 system is specified on http://www.glicko.com/ The Glicko-2 system is specified on http://www.glicko.com/
""" """
@@ -229,12 +229,12 @@ if __name__ == "__main__":
B = Glicko2(1400.0, 30.0, 0.06) B = Glicko2(1400.0, 30.0, 0.06)
C = Glicko2(1550.0, 100.0, 0.06) C = Glicko2(1550.0, 100.0, 0.06)
D = Glicko2(1700.0, 300.0, 0.06) D = Glicko2(1700.0, 300.0, 0.06)
A.AddWin(B) A.AddWin(B)
A.AddLoss(C) A.AddLoss(C)
A.AddResult(D,Glicko2.LOSS) A.AddResult(D,Glicko2.LOSS)
A.Update(); A.Update();
print "rating",A.GetRating(), "deviation",A.GetDeviation() print "rating",A.GetRating(), "deviation",A.GetDeviation()
rb/glicko2.rb
+168 -158
View File
@@ -40,179 +40,189 @@ class Glicko2
protected protected
# Glicko2 reprensentation (Glicko2 uses different scales from Glicko) # Glicko2 reprensentation (Glicko2 uses different scales from Glicko)
attr_accessor :g2rating, :g2deviation, :g2volatility attr_reader :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)
public public
WIN = 1.0 WIN = 1.0
LOSS = 0.0 LOSS = 0.0
DRAW = 0.5 DRAW = 0.5
# Constructor with rating, rating deviation, and volatility optionally # system constant, determines delta volatility over time; should be [0.3,1.2]
# specified. If nothing specified, nitializes to a rating of 1500, a DVOL = 0.3
# rating deviation of 350, and a volatility of 0.06.
def initialize(rating = 1500.0, deviation = 350.0, volatility = 0.06) # Constructor with rating, rating deviation, and volatility optionally
@dvolatility = 0.3 # specified. If nothing specified, nitializes to a rating of 1500, a
self.rating = rating # rating deviation of 350, and a volatility of 0.06.
self.deviation = deviation def initialize(rating = 1500.0, deviation = 350.0, volatility = 0.06)
self.volatility = volatility self.rating = rating
clear_results self.deviation = deviation
self.volatility = volatility
clear_results
end
include Comparable
# Comparison operator
def <=>(other)
p_win(other) <=> 0.5
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
# Get the current rating. This rating is a Glicko rating, not a Glicko2 rating.
# For details, please see http://www.glicko.com/
def rating
(@g2rating * 173.7178) + 1500.0
end
# Set Glicko rating. Internally this is converted to a Glicko2 rating.
# For details, please see http://www.glicko.com/
def rating=(r)
@g2rating = (r - 1500.0) / 173.7178
end
# Get the current rating deviation. This is a Glicko rating deviation, not a
# Glicko-2 RD. For details, please see http://www.glicko.com/
def deviation
@g2deviation * 173.7178
end
# Set Glicko rating deviation. Internally this is converted to a Glicko-2 RD.
# For details, please see http://www.glicko.com/
def deviation=(d)
@g2deviation = d / 173.7178
end
# Get the current rating volatility.
def volatility
@g2volatility
end
# Set rating volatility.
def volatility=(v)
@g2volatility = v
end
# 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.
def clear_results
@opponents = Array.new
@results = Array.new
end
# Add a result to this rating. Note that no calculation is performed until
# update() is called.
def add_result(opponent,result)
@results << Result.new(opponent.clone, result)
end
# Add a win result to this rating. Note that no calculation is performed until
# update() is called.
def add_win(opponent)
add_result(opponent,Glicko2::WIN)
end
# Add a loss result to this rating. Note that no calculation is performed until
# update() is called.
def add_loss(opponent)
add_result(opponent,Glicko2::LOSS)
end
# Add a draw result to this rating. Note that no calculation is performed until
# update() is called.
def add_draw(opponent)
add_result(opponent,Glicko2::DRAW)
end
# util func 'g'
def Glicko2.g(deviation)
1.0 / (Math.sqrt(1.0 + 3.0 * deviation ** 2.0 / (Math::PI ** 2.0)))
end
# util func 'E'
def Glicko2.E(rating, rating_opponent, deviation_opponent)
1.0 / (1.0 + Math.exp(-Glicko2.g(deviation_opponent)*(rating - rating_opponent)));
end
# Update rating based on current results list, and clear results.
def update
# Note that if a player does not compete during the rating period, then
# only Step 6 applies.
if @results.empty?
# In this case, the player's rating and volatility parameters remain the
# same, but the RD increases according to:
@g2deviation = Math.sqrt(@g2deviation**2.0 + @g2volatility**2.0)
return
end end
include Comparable # 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)
# Comparison operator # Step 2. For each player, convert the ratings and RD's onto the Glicko-2
def <=>(other) # scale.
self.rating <=> other.rating # ... (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 = 1.0 / @results.inject(0.0) do |sum,r|
g_i = Glicko2.g(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)
end end
# Get the current rating. This rating is a Glicko rating, not a Glicko2 rating. # Step 4. Compute the quantity 'delta', the estimated improvement in rating
# For details, please see http://www.glicko.com/ # by comparing the pre-period rating to the performance rating based only
def rating # on game outcomes.
(@g2rating * 173.7178) + 1500.0 delta = variance * @results.inject(0.0) do |sum,r|
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
# Set Glicko rating. Internally this is converted to a Glicko2 rating. # Step 5. Determine the new value of the volatility.
# For details, please see http://www.glicko.com/ a = Math.log(@g2volatility**2.0)
def rating=(r) x0, x1 = 0.0, a
@g2rating = (r - 1500.0) / 173.7178 while ((x0 - x1).abs > 0.0000001)
x0 = x1
d = @g2deviation**2.0 + variance + Math.exp(x0)
h1 = -(x0 - a)/(DVOL**2.0) - 0.5*Math.exp(x0)/d + 0.5*Math.exp(x0)*(delta/d)*(delta/d)
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)
x1 = x0 - h1/h2
end
new_volatility = Math.exp(x1 / 2.0)
# Step 6. Update the rating deviation to the new pre-rating period value.
pre_deviation = Math.sqrt(@g2deviation**2.0 + new_volatility**2.0)
# Step 7. Update the rating and RD to the new values.
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|
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
# Get the current rating deviation. This is a Glicko rating deviation, not a # Step 8. Convert ratings and RD's back to original scale.
# Glicko-2 RD. For details, please see http://www.glicko.com/ @g2deviation = new_deviation
def deviation @g2volatility = new_volatility
@g2deviation * 173.7178 @g2rating = new_rating
end
# Set Glicko rating deviation. Internally this is converted to a Glicko-2 RD. # wipe our result lists
# For details, please see http://www.glicko.com/ clear_results
def deviation=(d) end
@g2deviation = d / 173.7178
end
# Get the current rating volatility.
def volatility
@g2volatility
end
# Set rating volatility.
def volatility=(v)
@g2volatility = v
end
# 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.
def clear_results
@opponents = []
@results = []
end
# Add a result to this rating. Note that no calculation is performed until
# update() is called.
def add_result(opponent,result)
@results.push( Result.new(opponent.clone, result) )
end
# Add a win result to this rating. Note that no calculation is performed until
# update() is called.
def add_win(opponent)
add_result(opponent,Glicko2::WIN)
end
# Add a loss result to this rating. Note that no calculation is performed until
# update() is called.
def add_loss(opponent)
add_result(opponent,Glicko2::LOSS)
end
# Add a draw result to this rating. Note that no calculation is performed until
# update() is called.
def add_draw(opponent)
add_result(opponent,Glicko2::DRAW)
end
# util func
def Glicko2.g(deviation)
1.0 / (Math.sqrt(1.0 + 3.0 * deviation ** 2.0 / (Math::PI ** 2.0)))
end
# util func
def Glicko2.E(rating, rating_opponent, deviation_opponent)
1.0 / (1.0 + Math.exp(-Glicko2.g(deviation_opponent)*(rating - rating_opponent)));
end
# Update rating based on current results list, and clear results.
def update
# util func
# bail if no opponents set
if @results.empty?
@g2deviation = Math.sqrt(@g2deviation**2.0 + @g2volatility**2.0)
return
end
# compute variance
#variance = 0.0
#@results.inject(0.0) do |variance,r|
# 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
variance = 0.0
@results.each do |r|
g_i = Glicko2.g(r.opponent.g2deviation)
e_i = Glicko2.E(@g2rating,r.opponent.g2rating,r.opponent.g2deviation)
variance += g_i ** 2.0 * e_i * (1.0 - e_i)
end
variance = 1.0 / variance
# compute delta
delta = 0.0
@results.each do |r|
delta += Glicko2.g(r.opponent.g2deviation) * (r.result - Glicko2.E(@g2rating, r.opponent.g2rating, r.opponent.g2deviation))
end
delta *= variance
# determine new volatility
new_volatility = 0.0
a = Math.log( @g2volatility**2.0 )
x = 0.0
x_new = a
while ( (x - x_new).abs > 0.0000001 )
x = x_new
d = @g2deviation**2.0 + variance + Math.exp(x)
h1 = -(x - a)/(@dvolatility**2.0) - 0.5*Math.exp(x)/d + 0.5*Math.exp(x)*(delta/d)*(delta/d)
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
new_volatility = Math.exp(x_new / 2.0)
# update the rating deviation to the new pre-rating period value
pre_deviation = Math.sqrt( @g2deviation**2.0 + new_volatility**2.0 )
# update the rating and deviation
new_deviation = 1.0 / (Math.sqrt( 1.0/(pre_deviation**2.0) + 1.0 / variance))
new_rating = 0.0
@results.each do |r|
new_rating += Glicko2.g(r.opponent.g2deviation) * (r.result - Glicko2.E(@g2rating, r.opponent.g2rating, r.opponent.g2deviation))
end
new_rating = new_rating * new_deviation**2.0
new_rating += @g2rating
# wipe our result lists
clear_results
# copy new values
@g2deviation = new_deviation
@g2volatility = new_volatility
@g2rating = new_rating
end
end end
rb/test_glicko2.rb
+23 -23
View File
@@ -5,30 +5,30 @@ require 'test/unit'
class TestGlicko2 < Test::Unit::TestCase class TestGlicko2 < Test::Unit::TestCase
def test_simple def test_simple
a = Glicko2.new(1500.0, 200.0, 0.06) a = Glicko2.new(1500.0, 200.0, 0.06)
b = Glicko2.new(1400.0, 30.0, 0.06) b = Glicko2.new(1400.0, 30.0, 0.06)
c = Glicko2.new(1550.0, 100.0, 0.06) c = Glicko2.new(1550.0, 100.0, 0.06)
d = Glicko2.new(1700.0, 300.0, 0.06) d = Glicko2.new(1700.0, 300.0, 0.06)
a.add_win(b)
a.add_loss(c)
a.add_result(d,0.0)
assert_equal(1500.0, a.rating)
assert_equal(200.0, a.deviation)
a.update()
assert_in_delta(1464.05,a.rating,0.01)
assert_in_delta(151.516,a.deviation,0.01)
a.update() a.add_win(b)
a.add_loss(c)
assert_in_delta(1464.05,a.rating,0.01) a.add_result(d,0.0)
assert_in_delta(151.875,a.deviation,0.01)
assert_equal(1500.0, a.rating)
assert_equal(200.0, a.deviation)
a.update()
assert_in_delta(1464.05,a.rating,0.01)
assert_in_delta(151.516,a.deviation,0.01)
a.update()
assert_in_delta(1464.05,a.rating,0.01)
assert_in_delta(151.875,a.deviation,0.01)
end
end
end end