Remove individual sigmas.

diff --git a/bayeswf.cpp b/bayeswf.cpp
index 487774ea394cb993c7b5c4499cd64f3fb6c30d55..6214d281fd24ff83571cf0e272203af5c328456b 100644 (file)
--- a/bayeswf.cpp
+++ b/bayeswf.cpp
@@ -16,7 +16,7 @@ using namespace std;
 #define DUMP_RAW 0
 
 float mu[MAX_PLAYERS];
-float sigma[MAX_PLAYERS];
+float global_sigma = 70.0f;
 float prior_sigma = 70.0f;
 
 #define EPSILON 1e-3
@@ -40,7 +40,7 @@ struct match {
 map<int, vector<match> > matches_for_player;
 vector<match> all_matches;
 
-void dump_scores(const vector<string> &players, const float *mu, const float *sigma, int num_players)
+void dump_scores(const vector<string> &players, const float *mu, int num_players)
 {
 #if 0
        for (int i = 0; i < num_players; ++i) {
@@ -65,7 +65,7 @@ void dump_scores(const vector<string> &players, const float *mu, const float *si
  *                                sum_i[ (w_i/sigma_c_i)^2 mu1 ] = sum_i [ (w_i/sigma_c_i)^2 ( mu2_i + x_i ) ]
  *                                mu1 = sum_i [ (w_i/sigma_c_i)^2 ( mu2_i + x_i ) ] / sum_i[ (w_i/sigma_c_i)^2 ]
  */
-void update_mu(float *mu, float *sigma, int player_num, const vector<match> &matches)
+void update_mu(float *mu, int player_num, const vector<match> &matches)
 {
        if (matches.empty()) {
                return;
@@ -82,9 +82,7 @@ void update_mu(float *mu, float *sigma, int player_num, const vector<match> &mat
 
        // All matches.
        for (unsigned i = 0; i < matches.size(); ++i) {
-               float sigma1 = sigma[player_num];
-               float sigma2 = sigma[matches[i].other_player];
-               float inv_sigma_c2 = matches[i].weight / (sigma1 * sigma1 + sigma2 * sigma2);
+               float inv_sigma_c2 = matches[i].weight / (global_sigma * global_sigma);
                float x = matches[i].margin; // / 70.0f;
        
                nom += (mu[matches[i].other_player] + x) * inv_sigma_c2;
@@ -93,16 +91,14 @@ void update_mu(float *mu, float *sigma, int player_num, const vector<match> &mat
        mu[player_num] = nom / denom;
 }
 
-void dump_raw(const float *mu, const float *sigma, int num_players)
+void dump_raw(const float *mu, int num_players)
 {
        for (unsigned i = 0; i < all_matches.size(); ++i) {
                const match& m = all_matches[i];
 
                float mu1 = mu[m.player];
                float mu2 = mu[m.other_player];
-               float sigma1 = sigma[m.player];
-               float sigma2 = sigma[m.other_player];
-               float sigma = sqrt(sigma1 * sigma1 + sigma2 * sigma2);
+               float sigma = global_sigma;
                float mu = mu1 - mu2;
                float x = m.margin;
                float w = m.weight;
@@ -111,38 +107,6 @@ void dump_raw(const float *mu, const float *sigma, int num_players)
        }
 }
 
-/*
- * diff(logL, sigma1) = sigma1 (-sigma1² - sigma2² + (x - mu)²) / sigma_c²
- * maximizer for sigma1 is given by: sum_i[ (1/sigma_c_i)² sigma1 ((x - mu)² - (sigma1² + sigma2²) ] = 0
- *                                   sum_i[ (x - mu)² - sigma1² - sigma2² ] = 0                                  |: sigma1 != 0, sigma2 != 0
- *                                   sum_i[ (x - mu)² - sigma2² ] = sum[ sigma1² ]
- *                                   sigma1 = sqrt( sum_i[ (x - mu)² - sigma2² ] / N )
- */
-void update_sigma(float *mu, float *sigma, int player_num, const vector<match> &matches)
-{
-       if (matches.size() < 2) {
-               return;
-       }
-
-       float sum = 0.0f;
-       for (unsigned i = 0; i < matches.size(); ++i) {
-               float mu1 = mu[player_num];
-               float mu2 = mu[matches[i].other_player];
-               float mu = mu1 - mu2;
-               float sigma2 = sigma[matches[i].other_player];
-               float x = matches[i].margin;
-
-               //fprintf(stderr, "x=%f mu=%f sigma2=%f   add %f-%f = %f\n", x, mu, sigma2, (x-mu)*(x-mu), sigma2*sigma2, (x - mu) * (x - mu) - sigma2 * sigma2);
-               sum += (x - mu) * (x - mu) - sigma2 * sigma2;
-       }
-
-       if (sum <= 0) {
-               return;
-       }
-       //fprintf(stderr, "sum=%f\n", sum);
-       sigma[player_num] = sqrt(sum / matches.size());
-}
-
 /*
  * diff(logL, sigma) = w ( (x - mu)² - sigma² ) / sigma³
  * maximizer for sigma is given by: sum_i[ (w_i/sigma)³ ((x - mu)² - sigma²) ] = 0
@@ -150,7 +114,7 @@ void update_sigma(float *mu, float *sigma, int player_num, const vector<match> &
  *                                   sum_i[ w_i (x - mu)² ] = sum[ w_i sigma² ]
  *                                   sigma = sqrt( sum_i[ w_i (x - mu)² ] / sum[w_i] )
  */
-void update_global_sigma(float *mu, float *sigma, int num_players)
+void update_global_sigma(float *mu, int num_players)
 {
        float nom = 0.0f, denom = 0.0f;
        for (unsigned i = 0; i < all_matches.size(); ++i) {
@@ -166,10 +130,7 @@ void update_global_sigma(float *mu, float *sigma, int num_players)
                denom += w;
        }
 
-       float best_sigma = sqrt(nom / denom) / sqrt(2.0f);  // Divide evenly between the two players.
-       for (int i = 0; i < num_players; ++i) {
-               sigma[i] = best_sigma;
-       }
+       global_sigma = sqrt(nom / denom);
 }
 
 /*
@@ -179,7 +140,7 @@ void update_global_sigma(float *mu, float *sigma, int num_players)
  *                                   sum_i[ w_i (x - mu)² ] = sum[ w_i sigma² ]
  *                                   sigma = sqrt( sum_i[ w_i (x - mu)² ] / sum[w_i] )
  */
-void update_prior_sigma(float *mu, float *sigma, int num_players)
+void update_prior_sigma(float *mu, int num_players)
 {
        float nom = 0.0f, denom = 0.0f;
        for (int i = 0; i < num_players; ++i) {
@@ -200,7 +161,7 @@ float compute_logl(float z)
        return -0.5 * (log(2.0f / M_PI) + z * z);
 }
 
-float compute_total_logl(float *mu, float *sigma, int num_players)
+float compute_total_logl(float *mu, int num_players)
 {
        float total_logl = 0.0f;
 
@@ -215,9 +176,7 @@ float compute_total_logl(float *mu, float *sigma, int num_players)
 
                float mu1 = mu[m.player];
                float mu2 = mu[m.other_player];
-               float sigma1 = sigma[m.player];
-               float sigma2 = sigma[m.other_player];
-               float sigma = sqrt(sigma1 * sigma1 + sigma2 * sigma2);
+               float sigma = global_sigma;
                float mu = mu1 - mu2;
                float x = m.margin;
                float w = m.weight;
@@ -247,10 +206,7 @@ void construct_hessian(const float *mu, const float *sigma, int num_players)
                int p1 = m.player;
                int p2 = m.other_player;
 
-               double sigma1 = sigma[m.player];
-               double sigma2 = sigma[m.other_player];
-
-               double sigma_sq = sigma1 * sigma1 + sigma2 * sigma2;
+               double sigma_sq = global_sigma * global_sigma;
                float w = m.weight;
 
                hessian[p1][p2] -= w / sigma_sq;
@@ -335,24 +291,21 @@ int main(int argc, char **argv)
        }
 
        float mu[MAX_PLAYERS];
-       float sigma[MAX_PLAYERS];
 
        for (int i = 0; i < num_players; ++i) {
                mu[i] = PRIOR_MU;
-               sigma[i] = 70.0f / sqrt(2.0f);
        }
 
        for (int j = 0; j < 1000; ++j) {
                float old_mu[MAX_PLAYERS];
-               float old_sigma[MAX_PLAYERS];
+               float old_global_sigma = global_sigma;
                float old_prior_sigma = prior_sigma;
                memcpy(old_mu, mu, sizeof(mu));
-               memcpy(old_sigma, sigma, sizeof(sigma));
                for (int i = 0; i < num_players; ++i) {
-                       update_mu(mu, sigma, i, matches_for_player[i]);
+                       update_mu(mu, i, matches_for_player[i]);
                }
-               update_global_sigma(mu, sigma, num_players);
-               update_prior_sigma(mu, sigma, num_players);
+               update_global_sigma(mu, num_players);
+               update_prior_sigma(mu, num_players);
                /* for (int i = 0; i < num_players; ++i) {
                        update_sigma(mu, sigma, i, matches_for_player[i]);
                        dump_scores(players, mu, sigma, num_players);
@@ -361,9 +314,9 @@ int main(int argc, char **argv)
                float sumdiff = 0.0f;
                for (int i = 0; i < num_players; ++i) {
                        sumdiff += (mu[i] - old_mu[i]) * (mu[i] - old_mu[i]);
-                       sumdiff += (sigma[i] - old_sigma[i]) * (sigma[i] - old_sigma[i]);
                }
                sumdiff += (prior_sigma - old_prior_sigma) * (prior_sigma - old_prior_sigma);
+               sumdiff += (global_sigma - old_global_sigma) * (global_sigma - old_global_sigma);
                if (sumdiff < EPSILON) {
                        //fprintf(stderr, "Converged after %d iterations. Stopping.\n", j);
                        printf("%d -1\n", j + 1);
@@ -372,14 +325,14 @@ int main(int argc, char **argv)
        }
 
 #if DUMP_RAW
-       dump_raw(mu, sigma, num_players);
+       dump_raw(mu, num_players);
 #else
-       dump_scores(players, mu, sigma, num_players);
+       dump_scores(players, mu, num_players);
        //fprintf(stderr, "Optimal sigma: %f (two-player: %f)\n", sigma[0], sigma[0] * sqrt(2.0f));
-       printf("%f -2\n", sigma[0]);
+       printf("%f -2\n", global_sigma / sqrt(2.0f));
        printf("%f -3\n", prior_sigma);
 
-       float total_logl = compute_total_logl(mu, sigma, num_players);
+       float total_logl = compute_total_logl(mu, num_players);
        printf("%f -4\n", total_logl);
 
 //     construct_hessian(mu, sigma, num_players);