locked
Gaussian CDF factor? RRS feed

  • Question

  •  

    Let’s consider a simple TrueSkill problem where just two players (A and B) are playing against each other. Draws are not allowed. Suppose that player A won 60 out of 100 matches on a given day. Since all matches were played in a short period of time, we assume that player skills are constant throughout this period. The question is how to update the skill quickly and fast? The only way I see, is to construct a huge graph that would include a branch for each individual match and run the whole thing back and forth until convergence, which is essentially an implementation of TrueSkill Through Time. But this method is extremely slow and would require a recompilation in Infer.Net for each set of matches where number of matches is different from the previous set given that we are working in online updating mode. I was wondering if there is a smart way to do this in Infer.Net. Something like a CDF factor that would be attached to the players’ performance difference and which observed value would be equal to 0.6.

    P.S. Also, I naively tried to create an array of binary observations for each match but that did not work:

                NumberOfObservations = Variable.New<int>();

                Range rn = new Range(NumberOfObservations);

                Outcomes = Variable.Array<bool>(rn);

                using (Variable.ForEach(rn))

                {

                    Outcomes[rn] = PerfDiff > 0.0;

                }


    Wednesday, April 4, 2012 12:14 AM

Answers

  • You are on the right track with using an array of outcomes. You need to also have an array of performances, since a player's performance is different in each game.  Then it should work, and you should be able to change the array length without recompiling.
    Wednesday, April 4, 2012 4:40 PM
    Owner
  • Yes, it will be slower than one match as you say.  The only way to improve it that I know of is to use power EP, which allows you to treat submodels as if they were replicated many times at no increase in cost.  The support for power EP at the moment is rather minimal but it should be enough for the TrueSkill case; you can find a description in the Latent Dirichlet Allocation example.  We do plan to improve the support for power EP in the future.
    Wednesday, April 4, 2012 9:45 PM
    Owner

All replies

  • You are on the right track with using an array of outcomes. You need to also have an array of performances, since a player's performance is different in each game.  Then it should work, and you should be able to change the array length without recompiling.
    Wednesday, April 4, 2012 4:40 PM
    Owner
  • Thanks Tom. So this solves the recompiling issue, but it still will be a lot slower than running inference on one match, correct? I assume that under the hood Infer.Net will still construct something similar to the TrueSkill Through Time factor graph in which case it will be approximately 1000 times slower for 100 matches, given that it takes approximately 5-6 iterations to converge. Is there a way to improve it?    
    Wednesday, April 4, 2012 5:33 PM
  • Yes, it will be slower than one match as you say.  The only way to improve it that I know of is to use power EP, which allows you to treat submodels as if they were replicated many times at no increase in cost.  The support for power EP at the moment is rather minimal but it should be enough for the TrueSkill case; you can find a description in the Latent Dirichlet Allocation example.  We do plan to improve the support for power EP in the future.
    Wednesday, April 4, 2012 9:45 PM
    Owner
  • Thank you Tom. I will try to use power EP

    Thursday, April 5, 2012 12:00 AM