R?mi Coulom wrote:Elos are the logarithms of gammas, not the reverse. The gammas are on a n exponential scale, and should be multiplied. This works like the home-field advantage in Hunter's paper: it is multiplied by the strength of the player, not added to it.

Right, since Elos are the logarithms of gammas, the elos are e^gamma, which means a product of them would be e^gamma_1*e^gamma2*e^gamma3 = e^(gamma1+gamma2+gamma3). This is the model I use. I don't use Huang et al's model. But as I was saying, this is a model decision, not something inherent in the algorithm.

As for home field advantage, in Hunter's paper it's multiplied since it's not exponentiated. If it were exponentiated, you'd have e^advantage*e^gamma = e^(advantage+gamma).

I think you and I are saying the same thing and it's just Huang who is different.

As a side note, there is a full Bayesian chess ratings generalized linear model in Bayesian Data Analysis by Gelman, Carlin, Stern, and Rubin, in 16.7, page 432.

In this model, which is probably very similar to yours,

Pr(i defeats j | gamma) = e^gamma_i / (e^gamma_i + e^gamma_j + e^(delta + 0.5*(gamma_i+gamma_j+alpha))

where alpha is the color advantage and delta determines the likelihood of a draw.

In the model I have in mind, the gamma of a team is the product of the gamma of its member. MM allows to find the maximum-likelihood gamma for every individual player. It is not a problem at all if a particular team plays very few matches.

Yes, but again I'd have to store each game and who played in it, forever. I can not do this at production time. I can only store each player's rating and maybe their rating's variance. But this is a bit off-topic for here since you don't have these problems. If you're interested in working on this some more, let me know and we can do the paper together. Especially if there's a way to do a memory-less MM---which I doubt.

It adds a quadratic term to the log likelihood. So the maximization phase of MM has to solve a second-order polynomial. This means you'll have to compute a square root at each iteration, instead of a simple division.

OK, I can see that. It's interesting you simulate draws. One of my early models does something similar. In my application, we have maps that the teams play on and each map has an advantage score for each side on the map. That score is determined from the wins and losses per team on that map. We've found to stabilize the results, it's effective to assume that both teams have won an equal number of times. Somewhere around 10-50.

Again, with expectation propagation you have a very fast, memory-less, and naturally time-varying algorithm. The nice thing with TrueSkill is the variance is estimated explicitly instead of calculated afterwards.

The fundamental flaw of this approach is that it is purely forward in time. Models that keep the history of games are better. Some have been used in practice on large-scale game servers (the KGS game server, as well as IGS, use such a method, as far as I know).

Yes, keeping the history will always be better, but for situations like Microsofts dealing with millions of matches, and even my ten thousands of matches, it's not practical.

Thanks.