I calculated rating for every player in months 101-105 and after having the rating I have a simple formula to calculate the expected result only based on the rating and the color.
The tricks that I used were mainly in calculating the rating but I will start explaining the simple part.
The first part was calculating the bonus for white
I had the following formula for this part:
bonus=maximum((white_rating+black_rating-3100)/40.0,50)
Diff=white_rating+bonus-black_rating
Expected_result=0.5+Diff/850
When I changed it to be not more than 0.970588 and not less than 0.1(practically it had a very small effect
because the result was always bigger than 0.1 and there was only one case when I needed to reduce it to 0.970588)
Now we go to the hard part that is how to calculate the rating for every player.
For this purpose I admit that I used the future to predict the past(but I have also prediction based on a different model in the top 10 when I did not use the future to predict the past).
I used a function that I called repeat_strength_estimate
The function get the following parameters:
1)k that is the last month that is not missing.
For the prediction of months 101-105 k=100 but for testing my parameters I used k=90,91,92,...99
2)max_months(practically get the value 81 and I admit that it is not a good name)
The meaning of max_months=81 is practically that I do not use the first 20 months to predict month 101 and that I do not use the first 21 months to predict month 102 and generally
I do not use the first m-81 months to predict month number m.
3)big_dif=310
big_dif was used to calculate performance rating and for some reason I found that small values give better results
in my tests so I used this small value
My formula for performance rating was
performance_rating=avg_rating+((result-opponents)/opponents)*big_dif;
the value of the division can be at most 1 and at least -1 because result is practically weighted half points and is something between 0 and twice the weight of the opponent.
opponents in this formula mean the number of weight opponents(when the weight is based on the distance in month from the month to predict)
This formula means that even if a player lost all the games against the opponents then he still got performance rating that is only 310 elo weaker than the average of the opponents because the result of the division is always between -1 for losing all games and 1 for winning all games.
I guess that it was good because not all games are included so person who played against strong opponents probably performed practically better than his real score and it is not good for the real world when games are not missing.
4)num_avg=5.9 similiar to chess metrics(I added 5.9 faked opponents with average rating)
5)num_weak=2.2(added 2.2 faked weak opponents)
6)value_weak=2210(rating of the weak opponents like chess metrics
7)unrated=2285(I think that practically had no effect because players always have games in the last 80 months)
8)minimal_game_finished=15(I reduce rating to players with less than 15 weighted games similiar to chess metrics)
9)reduction_per_game=12(the number that I reduce for less of experience for player without many weight games)
10)adding=39(the number that I add to rating of players after every iteration)
repeat_strength_estimate basically did 10 iterations for evaluating the strength of every player in every month.
The evaluation of the strengh was based on 2 steps when step 1 was the function that calculate strength that is similiar to chess metrics but there are important differences and step 2 was deciding that place 50 has rating 2625 in the rating list that is exactly the same as chess metrics.
calc_strength_chess_metric is the missing function to understand the algorithm and it basically got 11 parameters(all the 10 parameters that repeat_strength_estimate got and another parameter that is the month that we calculate estimate for it).
Note that the estimate for month 50 of player 1 when months 101-105 are missing is important because if player 2 played with player 1 at month 50
then it is going to influence the rating of player 2 at month 101-105 that is used to calculate the expected result.
I use the word estimate and not rating because rating by definition assume that we do not have future results.
I had basically 2 steps in
calc_strength_chess_metric
The first step was a loop that calculated the estimate for strength for every player in the relevant month.
The second step is a step that I used only when I needed to predict the strength in the missing months and it is practically unfair trick but not something that is forbidden in the competition because I used the information about games and not about the results in the supposed missing months to calculate changes in the rating estimate in these months.
I did not finish to explain my algorithm and I plan also to send code later but now I need only to explain the 2 steps of calc_strength_chess_metric to explain my algorithm and I will do it later in another post(this part of the program is only slightly more than 100 lines of code in C).
Thank you for sharing those very detailed steps. Your descriptions really made it easier for me to follow you. The amount of coding that went into that chess rating was crazy!
", "votes": 0, "replies": [] }, { "id": 1250, "author_name": "Uri Blass", "author_url": "", "post_date": "2010-11-20T04:38:53", "content": "The first thing that I am going to explain is the first step in my calc_strength_chess_metric function.
it was a loop when I calculated the strength for every player so how did I calculate the strength?
I used a special function that got 12 parameters(the same 11 parameters that calc_strength_chess_mertics got and the id of the player to calculate the strength of it that had the name i)
This function simply did a loop on all months from 1-100 at distance of at most 80 months from the month to calculate strength for it
except the missing 5 months.
For every possible month number k that player i played in it
I had a weight that is calculated as
1-|month-k|/81 when month is the month that I need to calculate strength for it and k is the month of playing of player i.
Every game in this month is calculated as 1-|month-k|/81 games
and I also calculated weight result by multiply the result by that number(result before multiplying is 2 for win of i and 1 for draw and 0 for loss)
For every game I calculated
weighted result and weighted opponent rating and weighted number of opponents that is 1-|month-k|/81 for every game.
I reduced 0.03*weight from the weighted result if a player played with the white pieces and added the same number if the player played with the black pieces.
The opponent rating is simply the strength of the player(this strength is 2000 in the first iteration when we have no data about it).
After calculating opponents opp_rating and result I simply use chess metrics formula
after doing all of it I also add for the missing months activity bonus based on the number of games in the end of this function(1.2*numgames when numgames is the number of games in the missing month for example to calculate strength at month 103 assuming months 101-105 are missing
I add 1.2*number of games in months 101-103
This explain the first step but there is also a second step for updating the rating based on opponents in the missing months
and I use the function add_opp to update them.
The idea of add_opp is that I compare rating of opponents in the missing 5 months and rating of opponents in the last 12 months that we have and increase rating if I find that the opponents in the future are stronger.
People who are interested in the exact formula may read the function add_opp that I attach in this post(I attach all the code when I commented out part of the code that was about the cross data and is not relevant to the prediction and pushed it to the end).
Note that I did not do much optimization of parameters and I suspect that different parameters could give me the first place.
Note that in order to run the program succesfully you need to have the files of the test data and the training data at the same file as the exe file that is based on the code that I attach.
double
\r\n\r\n add_opp(int i,int missing,int month)\r\n {
int k;\r\n
\r\nint num_oppon=0;\r\n
\r\nint num_oppon_past=0;\r\n
\r\ndouble opp_rating_past=0;\r\n
\r\nint num;\r\n
\r\ndouble opp_rating=0;\r\n
\r\ndouble past_rating=0;\r\n
\r\nfor (k=missing-12;k<=missing;k++)\r\n {
if (k>=0)\r\n {
if (num_opp[i][k][0]>0)\r\n
\r\nfor (num=1;num<=num_opp[i][k][0];num++)\r\n { opp_rating_past+=strength[num_opp[i][k][num]][k]; num_oppon_past+=1; } } }
for (k=missing+1;k<=missing+5;k++)\r\n
\r\nif (num_opp[i][k][0]>0)\r\n
\r\nfor (num=1;num<=num_opp[i][k][0];num++)\r\n { opp_rating+=strength[num_opp[i][k][num]][k]; num_oppon+=1; }
if (num_oppon>0)\r\n opp_rating=opp_rating/num_oppon;
else
\r\nopp_rating=strength[i][month];
\r\n\r\nif (num_oppon_past>0)\r\n opp_rating_past=opp_rating_past/num_oppon_past;
else
\r\nopp_rating=strength[i][month];
\r\n\r\nif (opp_rating>opp_rating_past+60)\r\n
\r\nreturn 12;\r\n
\r\nif (opp_rating
return -12;\r\n
\r\nreturn (opp_rating-opp_rating_past)*0.2;
\r\n}
Edit:last comment: It is possible that I could get the first place only by doing more iterations(considering the small distance to the first place) and it may be interesting to check it.
Unfortunately
I did not think about doing more iterations in the last moment.
I decided to post all the code that I have for my best prediction in this competition directly
so everybody can run the code and verify the results
#include
#include
<stdlib.h>\r\n#include
<assert.h>\r\n#include
<memory.h>\r\n#include
<math.h>\r\nFILE *stream_training, *stream_test;
\r\n//stream_test step1 test data,stream_training step 2 training_data
\r\nconst
int games_training=65053;\r\nconst
int games_test=7809;\r\nconst
int total_games=73062;\r\nconst
int aboveidnumber=8632;\r\nint
isplayer2[aboveidnumber];//constant after step 1\r\nint
month_test[games_test];//constant after step 1\r\nint
month[total_games];//constant after step 1\r\nint
whiteplayer[total_games];//constant after step 1\r\nint
blackplayer[total_games];//constant after step 1\r\nint
whiteplayer_test[games_test];//constant after step 1\r\nint
blackplayer_test[games_test];//constant after step 1\r\nint
isplayer[aboveidnumber];//constant after step 2\r\ndouble
result[total_games];//constant after step 2\r\nfloat
read_result[total_games];//constant after step 2\r\nint
num_opp[aboveidnumber][106][40];//third field start with number of players to play at constant after step 3\r\nint
result_player[aboveidnumber];//constant after step 3\r\nint
num_color[aboveidnumber][106][40];//constant after step 3\r\nint
num_result[aboveidnumber][106][40];//constant after step 3\r\nint
numgames[aboveidnumber][106];//constant after step 3\r\nint
connected[aboveidnumber];//constant after step 3\r\ndouble
observed_result[aboveidnumber][106];//constant after step 4\r\ndouble
observed_result_small[aboveidnumber][106][5];//constant after step 4\r\nint
experienced_players[total_games][5];//constant after step 4 is used to calculate the expected result\r\n//and get 1 only if the relevant game is by 2 players with at least 48 games to be considered for RMSE
\r\ndouble
expected_result_small[aboveidnumber][106][5];//initiailized in step 3 and is the expected result for RMSE\r\n//(calculated at step 6
\r\ndouble
strength[aboveidnumber][106];//strength is based on all the data constant after step 5 that repeats itself\r\ndouble
expect_result_game[total_games][5];//constant after step 6 and \r\n//used to calculate later the expected result and the expected_result_small tables
\r\ndouble
predicted[games_test];//used only in the final step of the program to build the submission\r\ndouble
expected_result[aboveidnumber][106];//the expected result that include unexperienced players \r\n//initinalized in step 6 but I did not use it
\r\nconst
int whitecolor=0;\r\nconst
int blackcolor=1;\r\nvoid
read_test()\r\n{
//step 1 of the program that read the test data\r\n//for every game we have month white and black and it is also saved in the full data that include the training data\r\nint i;\r\nchar c;\r\nif ((stream_test = fopen(\"test_data.csv\", \"r+b\")) == NULL) {\r\nprintf(
\"The file 'test_data.csv' was not opened\\n\");\r\nreturn;\r\n}
else\r\nprintf(
\"The file 'test_data.csv' was opened\\n\");\r\nif (stream_test) {\r\n/* start reading from stream */\r\nfor (i = 1; i < 53; i++) {\r\nfscanf(stream_test,
\"%c\", &c);\r\n}
\r\nfor (i = 0; i < aboveidnumber; i++)\r\nisplayer2[i] = 0;
\r\nfor (i = 0; i < games_test; i++) {\r\nfscanf(stream_test,
\"%d\", &month_test[i]);\r\nmonth[games_training+i]=month_test[i];
\r\nfscanf(stream_test,
\"%c\", &c);\r\nfscanf(stream_test,
\"%d\", &whiteplayer_test[i]);\r\nwhiteplayer[games_training+i]=whiteplayer_test[i];
\r\nisplayer2[whiteplayer_test[i]] = 1;
\r\nfscanf(stream_test,
\"%c\", &c);\r\nfscanf(stream_test,
\"%d\", &blackplayer_test[i]);\r\nblackplayer[games_training+i]=blackplayer_test[i];
\r\nisplayer2[blackplayer_test[i]] = 1;
\r\nfscanf(stream_test,
\"%c\", &c); /* , */\r\nfscanf(stream_test,
\"%c\", &c); /* enter */\r\n}
\r\nfclose(stream_test);
\r\n}
\r\n}
\r\nvoid
read_training_data()\r\n{
\r\n//step 2 read the training data for every game we have month white black and result \r\nint i;\r\nchar c;\r\ndouble sum_result=0;\r\n/* start reading from stream */\r\nfor (i = 1; i < 53; i++) \r\n{
\r\nfscanf(stream_training,
\"%c\", &c);\r\nprintf(
\"%c\", c);\r\n}
\r\nmemset(isplayer, 0,
sizeof(isplayer));\r\nfor (i = 0; i < games_training; i++) \r\n{
\r\nfscanf(stream_training,
\"%d\", &month[i]);\r\nfscanf(stream_training,
\"%c\", &c);\r\nfscanf(stream_training,
\"%d\", &whiteplayer[i]);\r\nisplayer[whiteplayer[i]] = 1;
\r\nfscanf(stream_training,
\"%c\", &c);\r\nfscanf(stream_training,
\"%d\", &blackplayer[i]);\r\nisplayer[blackplayer[i]] = 1;
\r\nfscanf(stream_training,
\"%c\", &c);\r\nfscanf(stream_training,
\"%f\", &read_result[i]); /* 0.5 */\r\nresult[i] = read_result[i];
\r\nsum_result=sum_result+result[i];
\r\nfscanf(stream_training,
\"%c\", &c); /* enter */\r\n}
\r\nprintf(
\"sum is %f \",sum_result);\r\n}
\r\nvoid
fill_num_opp_array()\r\n{
//step 3 building the basic arrays\r\n//the arrays are:1)num_opp[num_player][num_month][0]\r\n//means number of opponents of player with id num_player in num_month\r\n//num_opp[num_player][num_month][j] for j>0 means num_player of opponent number j at the same month\r\n//num_color[num_player][num_month][j] for the same j>0 gives the color that num_player played in game number j of \r\n//month num_month\r\n//num_result of the same parameters means the result that the player got in the relevant game when win is 2\r\n//draw is 1 and loss is 0\r\n//result_player[i] means the total half points that i got in the training games\r\nint i,j,k,num,sum;\r\nint white,black;\r\nint month1;\r\nint diff;\r\ndouble weight;\r\nfor (i=0;i<aboveidnumber;i++)\r\nfor (j=1;j<=100;j++)\r\nnum_opp[i][0][j]=0;
\r\nfor (i=0;i<aboveidnumber;i++)\r\nresult_player[i]=0;
\r\nfor (i=0;i<games_training+games_test;i++)\r\n{
\r\nmonth1=month[i];
\r\nwhite=whiteplayer[i];
\r\nblack=blackplayer[i];
\r\nif (i<games_training)\r\n{
\r\nif (result[i] == 1)\r\nresult_player[white] += 2;
\r\nelse \r\nif (result[i] == 0)\r\nresult_player[black] += 2;
\r\nelse \r\n{
\r\nresult_player[white]++;
\r\nresult_player[black]++;
\r\n}
\r\n}
\r\nnum_opp[white][month1][0]++;
\r\nnum_opp[black][month1][0]++;
\r\nnum_opp[white][month1][num_opp[white][month1][0]]=black;
\r\nnum_color[white][month1][num_opp[white][month1][0]]=whitecolor;
\r\nnum_opp[black][month1][num_opp[black][month1][0]]=white;
\r\nnum_color[black][month1][num_opp[black][month1][0]]=blackcolor;
\r\nnum_result[white][month1][num_opp[white][month1][0]]=1;
\r\nnum_result[black][month1][num_opp[black][month1][0]]=1;
\r\nif (result[i] == 1)\r\n{
\r\nnum_result[white][month1][num_opp[white][month1][0]]=2;
\r\nnum_result[black][month1][num_opp[black][month1][0]]=0;
\r\n}
\r\nelse\r\nif (result[i]==0)\r\n{
\r\nnum_result[white][month1][num_opp[white][month1][0]]=0;
\r\nnum_result[black][month1][num_opp[black][month1][0]]=2;
\r\n}
\r\n}
\r\n//initialization of arrays like numgames that is the number of games of player i after j months\r\n//expected_result that is the expected result of player i after j months \r\n//and obsereved_result that is the observed result of player i after j months\r\n//connected means that the player is connected to all the player and the default value 0 means not connected\r\nfor (i = 0; i < aboveidnumber; i++) \r\n{
\r\nfor (j = 0; j < 106; j++) \r\n{
\r\nnumgames[i][j] = 0;
\r\nexpected_result[i][j] = 0;
\r\nobserved_result[i][j] = 0;
\r\nfor (k=0;k<=4;k++)\r\n{
\r\nobserved_result_small[i][j][k]=0;
\r\nexpected_result_small[i][j][k]=0;
\r\n}
\r\n}
\r\nconnected[i] = 0;
\r\n}
\r\n//1 is connected and every player who played with 1 or played with a connected player is connected\r\nconnected[1] = 1;
\r\nfor (j = 0; j < 5; j++) \r\n{
\r\nfor (i = 0; i < games_training; i++) \r\n{
\r\nif (connected[whiteplayer[i]] == 1)\r\nconnected[blackplayer[i]] = 1;
\r\nif (connected[blackplayer[i]] == 1)\r\nconnected[whiteplayer[i]] = 1;
\r\n}
\r\n}
\r\nsum = 0;
\r\nfor (i = 0; i < aboveidnumber; i++)\r\nsum = sum + connected[i];
\r\nprintf(
\"connected=%d\\n\", sum);\r\n//updating the numagames data to be correct\r\n//we need also to update expected and observed data\r\nfor (i = 0; i < games_training+games_test; i++) \r\n{
\r\nj = month[i];
\r\nwhile (j <= 105) \r\n{
\r\nnumgames[whiteplayer[i]][j]++;
\r\nnumgames[blackplayer[i]][j]++;
\r\nj++;
\r\n}
\r\n}
\r\n//counting players in the test data\r\nsum = 0;
\r\nfor (i = 0; i < aboveidnumber; i++) \r\n{
\r\nif (isplayer2[i] == 1) \r\nsum++;
\r\n}
\r\nprintf(
\"players in test are %d \", sum);\r\n\r\n
}
\r\n\r\n
void
calc_observed()\r\n{
\r\n//step 4 calculating the observed result for every player in every month\r\n//do it only one time we already initialized the observed array to 0 do the same for\r\n//observe_small\r\nint i,white,black,order,delay,start_check;\r\ndouble observed;\r\ni=0;
\r\nwhile (i < games_training) \r\n{
\r\nwhite = whiteplayer[i];
\r\nblack = blackplayer[i];
\r\norder = month[i];
\r\nobserved = result[i];
\r\nobserved_result[white][order] += observed;
\r\nobserved_result[black][order] += (1 - observed);
\r\nfor (delay=1;delay<=5;delay++)\r\n{
//we are at month number order we have results of month number order-delay and not results of the next 5 months\r\nexperienced_players[i][delay-1]=0;
\r\nif (order>delay)\r\n{
\r\nstart_check=order-delay-48;
\r\nif (start_check<0)\r\nstart_check=0;
\r\nif ((numgames[white][order-delay]-numgames[white][start_check]>=12)&&\r\n(numgames[black][order-delay]-numgames[black][start_check]>=12))
\r\n{
//player, number month of playing,delay in predicting minus 1\r\nobserved_result_small[white][order][delay-1] += observed;
//the observed results at month number order.\r\nobserved_result_small[black][order][delay-1] += (1 - observed);
\r\nexperienced_players[i][delay-1]=1;
\r\n}
\r\n}
\r\n}
\r\ni++;
\r\n}
\r\n}
\r\nint
is_candidate_chess_strength(int month,int missing,double candidate)\r\n{
\r\nint i;\r\nint sum=0;\r\nint monthmin=month-48;\r\nint monthmax=month;\r\nif (monthmin<0)\r\n{
\r\nmonthmin=0;
\r\nmonthmax=48;
\r\n}
\r\nfor (i=0;i<aboveidnumber;i++)\r\nif ((isplayer[i]==1)&&(numgames[i][monthmax]-numgames[i][monthmin]>=10))\r\nif (strength[i][month]>=2625-candidate)\r\nsum++;
\r\nif ((sum<50)&&(candidate>=0))\r\n{
//increasing by candidate is needed and done because number 50 is not more than \r\n// 2625-candidate<2625\r\nfor (i=0;i<aboveidnumber;i++)\r\nif (isplayer[i]==1) \r\nstrength[i][month]+=candidate;
\r\nreturn 1;\r\n}
\r\nelse\r\nif ((sum>=50)&&(candidate<0))\r\n{
\r\n//reducing by -candidate is needed and done because \r\n//there are 50 players with at least 2625-candidate>2625\r\nfor (i=0;i<aboveidnumber;i++)\r\nif (isplayer[i]==1) \r\nstrength[i][month]+=candidate;
\r\n}
\r\nreturn 0;\r\n\r\n
}
\r\n\r\n
void
fixplace50_chess_strength(int month,int missing)\r\n{
\r\nint sum=0;//this function changes the rating of player number 50 to be 2625\r\ndouble candidate;\r\nif (is_candidate_chess_strength(month,missing,0)==1)\r\ncandidate=1600;
\r\nelse\r\ncandidate=-1600;
\r\nwhile ((candidate>0.001)||(candidate<-0.001))\r\n{
\r\nis_candidate_chess_strength(month,missing,candidate);
\r\ncandidate=candidate/2.0;
\r\n}
\r\n}
\r\n\r\n
double
calc_strength_chess_metric_specific(int month,int missing,int max_months,\r\ndouble big_dif,double num_avg, double num_weak,\r\ndouble value_weak,double unrated,double adding,\r\ndouble minimal_game_finished,double reduction_per_game,int i)\r\n{
//used for step 5\r\n//impotant function for the prediction because it is used to calculate rating\r\nint k;\r\nint diff;\r\nint num;\r\ndouble result,opponents,weight,opp_rating,avg_rating,performance_rating,return_rating;\r\ndouble special_weight;\r\nresult=0;
\r\nopponents=0;
\r\nopp_rating=0;
\r\n//results of month+1,month+2,month+3,month+4,month+5 are missing from the data\r\nfor (k=1;k<=100;k++)\r\n{
\r\nif ((k<=missing)||(k>=missing+6))\r\n//we consider only results of these months to calculate rating at month number month\r\nif ((k>month-max_months)&&(k<month+max_months))\r\n{
\r\n\r\nif (num_opp[i][k][0]>0)\r\n
{
\r\ndiff=month-k;
\r\nif (diff<0)\r\ndiff=k-month;
\r\nweight=1-(1.0/(max_months))*diff;
\r\nfor (num=1;num<=num_opp[i][k][0];num++)\r\n{
\r\nopponents+=weight;
\r\nresult+=(num_result[i][k][num]*weight);
\r\nopp_rating+=(strength[num_opp[i][k][num]][k]*weight);
\r\nif (num_color[i][k][num]==whitecolor)\r\nresult-=0.03*weight;
\r\nelse\r\nresult+=0.03*weight;
\r\n}
\r\n}
\r\n\r\n
}
\r\n}
\r\nif (opponents>0)\r\n{
\r\navg_rating=opp_rating/opponents;
\r\nif (opponents<minimal_game_finished)\r\nvalue_weak-=(minimal_game_finished-opponents)*reduction_per_game;
\r\nperformance_rating=avg_rating+((result-opponents)/opponents)*big_dif;
\r\nreturn_rating=(performance_rating*opponents)+(avg_rating*num_avg)+(value_weak*num_weak);
\r\nreturn_rating=return_rating/(opponents+num_avg+num_weak);
\r\nreturn_rating+=adding;
\r\n}
\r\nelse\r\nreturn_rating=unrated;
\r\nif ((month>missing)&&(month<=missing+5))\r\nreturn_rating+=((numgames[i][month]-numgames[i][missing])*1.2);
\r\nreturn return_rating;\r\n}
\r\ndouble
add_opp(int i,int missing,int month)\r\n{
\r\nint k;\r\nint num_oppon=0;\r\nint num_oppon_past=0;\r\ndouble opp_rating_past=0;\r\nint num;\r\ndouble opp_rating=0;\r\ndouble past_rating=0;\r\nfor (k=missing-12;k<=missing;k++)\r\n{
\r\nif (k>=0)\r\n{
\r\nif (num_opp[i][k][0]>0)\r\nfor (num=1;num<=num_opp[i][k][0];num++)\r\n{
\r\nopp_rating_past+=strength[num_opp[i][k][num]][k];
\r\nnum_oppon_past+=1;
\r\n}
\r\n}
\r\n}
\r\nfor (k=missing+1;k<=missing+5;k++)\r\nif (num_opp[i][k][0]>0)\r\nfor (num=1;num<=num_opp[i][k][0];num++)\r\n{
\r\nopp_rating+=strength[num_opp[i][k][num]][k];
\r\nnum_oppon+=1;
\r\n}
\r\nif (num_oppon>0)\r\nopp_rating=opp_rating/num_oppon;
\r\nelse\r\nopp_rating=strength[i][month];
\r\nif (num_oppon_past>0)\r\nopp_rating_past=opp_rating_past/num_oppon_past;
\r\nelse\r\nopp_rating=strength[i][month];
\r\nif (opp_rating>opp_rating_past+60)\r\nreturn 12;\r\nif (opp_rating<opp_rating_past-60)\r\nreturn -12;\r\nreturn (opp_rating-opp_rating_past)*0.2;\r\n}
\r\nvoid
calc_strength_chess_metric(int month,int missing,int max_months,\r\ndouble big_dif,double num_avg, double num_weak,\r\ndouble value_weak,double unrated,double adding,\r\ndouble minimal_game_finished,double reduction_per_game)\r\n{
//used for step 5\r\ndouble temp_rating[aboveidnumber];\r\nint i=0;\r\nfor (i=1;i<aboveidnumber;i++)\r\nif (isplayer[i]==1)\r\ntemp_rating[i]=calc_strength_chess_metric_specific(month,missing,max_months,big_dif,num_avg,num_weak,value_weak,
\r\nunrated,adding,minimal_game_finished,reduction_per_game,i);
\r\nfor (i=1;i<aboveidnumber;i++)\r\n{
\r\nstrength[i][month]=temp_rating[i];
\r\n}
\r\nfor (i=1;i<aboveidnumber;i++)\r\nif ((month>missing)&&(month<=missing+5))\r\nstrength[i][month]+=add_opp(i,missing,month);
\r\n}
\r\nvoid
repeat_strength_estimate(int k,int max_months,double big_dif,double num_avg,double num_weak,double value_weak,\r\ndouble unrated,double minimal_game_finished,double reduction_per_game,double adding)\r\n{
//step 5 calculating the rating estimate when months k+1,...k+5 are missing k can be 0-100\r\nint i,j;\r\nfor (i=0;i<aboveidnumber;i++)\r\nfor (j=0;j<=105;j++)\r\nstrength[i][j]=2000;
\r\n//k is the last month when result is not missing for the estimate\r\nfor (i=0;i<100;i++)//i is the number of iteration\r\n{
\r\nprintf(
\" %d \",i);\r\nfor (j=0;j<=105;j++)//j is the month that we calculate rating for it.\r\n{
\r\ncalc_strength_chess_metric(j,k,max_months,big_dif,num_avg,num_weak,value_weak,unrated,adding,
\r\nminimal_game_finished,reduction_per_game);
\r\nfixplace50_chess_strength(j,k);
\r\n}
\r\n}
\r\n}
\r\ndouble
expected_number2(double diff,double max_diff)\r\n{
\r\ndouble num=0.5+(diff/(2*max_diff));//25/850=1/34\r\nif (num>0.970588)\r\nnum=0.970588;
\r\nif (num<0.1)\r\nnum=0.1;
\r\nreturn num;\r\n}
\r\ndouble
expectedwhitechess_result(int white,int black,int month)\r\n{
\r\n//this function predicts the result of white and black in specific month\r\n//I currently use the rating but it is going to be changed\r\ndouble whiterating=strength[white][month];//first missing month is 101 \r\n//in case of predicting and something else in other cases\r\ndouble blackrating=strength[black][month];\r\ndouble bonus=(whiterating+blackrating-3100)/40.0;\r\nif (bonus>50)\r\nbonus=50;
\r\nreturn expected_number2(whiterating+bonus-blackrating,425);\r\n}
\r\n\r\n
void
calc_expected(int monthx)\r\n{
//monthx+1,...monthx+5 are missing and we calculate expected result \r\n//for every player based on this information\r\nint white,black,order,i,delay,start_check,j;\r\ndouble expected;\r\ni=0;
\r\nfor (i = 0; i < aboveidnumber; i++) \r\n{
\r\nfor (j = monthx; j < monthx+5; j++) \r\nexpected_result[i][j] = 0;
\r\n}
\r\nwhile (month[i]<=monthx)\r\ni++;
\r\n\r\nwhile ((i<games_training)&&(month[i]>monthx)&&(month[i]<=monthx+5))\r\n
{
\r\nwhite = whiteplayer[i];
\r\nblack = blackplayer[i];
\r\norder = month[i];
\r\nexpected=expect_result_game[i][order-monthx-1];
\r\nexpected_result[white][order]+=expected;
\r\nexpected_result[black][order]+=(1-expected);
\r\ndelay=order-monthx;
//1-5\r\nif (experienced_players[i][delay-1]==1)\r\n{
\r\nexpected_result_small[white][order][delay-1] += expected;
//the expected results at month number order.\r\nexpected_result_small[black][order][delay-1] += (1 - expected);
\r\n}
\r\ni++;
\r\n}
\r\n}
\r\ndouble
calc_error_result_small(int monthx,int delay)\r\n{
\r\nint i;\r\nint order=monthx+delay;\r\ndouble err;\r\ndouble RMSE=0;\r\nfor (i=1;i<aboveidnumber;i++)\r\nif (isplayer[i]==1)\r\n{
\r\nerr=observed_result_small[i][order][delay-1]-expected_result_small[i][order][delay-1];
\r\nRMSE+=err*err;
\r\n}
\r\nreturn RMSE;\r\n}
\r\nvoid
build_expected_result(int monthx)\r\n{
//step 6\r\n//we build expected result table for monthx+1,...monthx+5 based on the rating list\r\n//first step is to build the expected_result table for month+1,...month+5 \r\n//based on strength in the relevant month and maybe more parameters that I will add later\r\nint white,black,i;\r\ni=0;
\r\nwhile (i<games_training)\r\n{
\r\nif ((month[i]>=monthx+1)&&(month[i]<=monthx+5))\r\n{
\r\nwhite=whiteplayer[i];
\r\nblack=blackplayer[i];
\r\nexpect_result_game[i][month[i]-monthx-1]=expectedwhitechess_result(white,black,month[i]);
\r\n//should be improved but this is an initial version \r\n}
\r\ni++;
\r\n}
\r\ncalc_expected(monthx);
\r\n}
\r\nvoid
build_stupid_csv_prediction()\r\n{
\r\n/* submission.csv */\r\nint i;\r\nchar c;\r\nFILE *stream_prediction = fopen(
\"submission119.csv\", \"w+b\");\r\nstream_test = fopen(
\"test_data.csv\", \"r+b\");\r\nassert(stream_prediction);
\r\nassert(stream_test);
\r\nif (stream_test == NULL || stream_prediction == NULL)\r\n{
\r\nputs(
\"Usage error:\\nfiles submission.cs and test_data.csv are expected to be available in the current working directory.\\n\");\r\nexit(EXIT_FAILURE);
\r\n}
\r\nfor (i = 1; i < 53; i++) {\r\nfscanf(stream_test,
\"%c\", &c);\r\nfprintf(stream_prediction,
\"%c\", c);\r\n}
\r\nfor (i = 0; i < games_test; i++) {\r\nfprintf(stream_prediction,
\"%d\", month_test[i]);\r\nfprintf(stream_prediction,
\"%c\", ',');\r\nfprintf(stream_prediction,
\"%d\", whiteplayer_test[i]);\r\nassert(whiteplayer[games_training+i]==whiteplayer_test[i]);
\r\nfprintf(stream_prediction,
\"%c\", ',');\r\nfprintf(stream_prediction,
\"%d\", blackplayer_test[i]);\r\nassert(blackplayer[games_training+i]==blackplayer_test[i]);
\r\nfprintf(stream_prediction,
\"%c\", ',');\r\nfprintf(stream_prediction,
\"%f\", predicted[i]);\r\nfprintf(stream_prediction,
\"%c\", '\\n');\r\n}
\r\nfclose(stream_test);
\r\nfclose(stream_prediction);
\r\n}
\r\n\r\n
void
predicting_chess_metrics(double white_bonus,double max_diff)\r\n{
//425\r\nint i;\r\nint white,black;\r\nfor (i = 0; i < games_test; i++) \r\n{
\r\nwhite = whiteplayer_test[i];
\r\nblack = blackplayer_test[i];
\r\npredicted[i]=expectedwhitechess_result(white,black,month_test[i]);
\r\n}
\r\nbuild_stupid_csv_prediction();
\r\n\r\n
}
\r\nint
main(void)\r\n{
\r\nint i,j;\r\nint sum = 0;\r\ndouble sum_result=0;\r\ndouble error=0;\r\nread_test();
//step 1\r\nif ((stream_training = fopen(\"training_data.csv\", \"r+b\")) == NULL) /* C4996 */\r\nprintf(
\"The file 'training_data.csv' was not opened\\n\");\r\nelse\r\nprintf(
\"The file 'training_data.csv' was opened\\n\");\r\nif (stream_training) \r\n{
\r\nread_training_data();
//step 2 \r\nfill_num_opp_array();
//step 3\r\ncalc_observed();
//step 4\r\nfor (i=90;i<=100;i++)\r\n{
//i should be a parameter\r\n\r\n
repeat_strength_estimate(i,81,310,5.9,2.2,2210,2285,15,12,39);
//step 5\r\n//months i+1,i+2,i+3,i+4,i+5 are missing and we need to predict them\r\nbuild_expected_result(i);
//step 6 this function is going to build \r\n//expected result table based on strength estimate(months i+1,...i+5 missing)\r\nfor (j=1;j<=5;j++)\r\nif ((i+j)<=100)\r\nerror+=calc_error_result_small(i,j);
\r\nprintf(
\" error=%f \",error);\r\n\r\n
}
\r\npredicting_chess_metrics(45,425);
//bonus for white and maximal difference\r\nfclose(stream_training);
\r\n}
\r\n}
", "votes": 0, "replies": [] }, { "id": 1258, "author_name": "Uri Blass", "author_url": "", "post_date": "2010-11-20T04:38:53", "content": "only one correction of the code
The original code had
for (i=0;i<10;i++)//i is the number of iteration
I changed it to 100 iterations in the code that I posted.
100 iterations probably give better result than the result that I got but not good enough for the first place(my tests suggest small improvement in predicting of less than 0.1%) .
Thank you for sharing those very detailed steps. Your descriptions really made it easier for me to follow you. The amount of coding that went into that chess rating was crazy!
" }, { "id": 1248, "postDate": "2010-11-20T04:38:53Z", "content": "I calculated rating for every player in months 101-105 and after having the rating I have a simple formula to calculate the expected result only based on the rating and the color.
The tricks that I used were mainly in calculating the rating but I will start explaining the simple part.
The first part was calculating the bonus for white
I had the following formula for this part:
bonus=maximum((white_rating+black_rating-3100)/40.0,50)
Diff=white_rating+bonus-black_rating
Expected_result=0.5+Diff/850
When I changed it to be not more than 0.970588 and not less than 0.1(practically it had a very small effect
because the result was always bigger than 0.1 and there was only one case when I needed to reduce it to 0.970588)
Now we go to the hard part that is how to calculate the rating for every player.
For this purpose I admit that I used the future to predict the past(but I have also prediction based on a different model in the top 10 when I did not use the future to predict the past).
I used a function that I called repeat_strength_estimate
The function get the following parameters:
1)k that is the last month that is not missing.
For the prediction of months 101-105 k=100 but for testing my parameters I used k=90,91,92,...99
2)max_months(practically get the value 81 and I admit that it is not a good name)
The meaning of max_months=81 is practically that I do not use the first 20 months to predict month 101 and that I do not use the first 21 months to predict month 102 and generally
I do not use the first m-81 months to predict month number m.
3)big_dif=310
big_dif was used to calculate performance rating and for some reason I found that small values give better results
in my tests so I used this small value
My formula for performance rating was
performance_rating=avg_rating+((result-opponents)/opponents)*big_dif;
the value of the division can be at most 1 and at least -1 because result is practically weighted half points and is something between 0 and twice the weight of the opponent.
opponents in this formula mean the number of weight opponents(when the weight is based on the distance in month from the month to predict)
This formula means that even if a player lost all the games against the opponents then he still got performance rating that is only 310 elo weaker than the average of the opponents because the result of the division is always between -1 for losing all games and 1 for winning all games.
I guess that it was good because not all games are included so person who played against strong opponents probably performed practically better than his real score and it is not good for the real world when games are not missing.
4)num_avg=5.9 similiar to chess metrics(I added 5.9 faked opponents with average rating)
5)num_weak=2.2(added 2.2 faked weak opponents)
6)value_weak=2210(rating of the weak opponents like chess metrics
7)unrated=2285(I think that practically had no effect because players always have games in the last 80 months)
8)minimal_game_finished=15(I reduce rating to players with less than 15 weighted games similiar to chess metrics)
9)reduction_per_game=12(the number that I reduce for less of experience for player without many weight games)
10)adding=39(the number that I add to rating of players after every iteration)
repeat_strength_estimate basically did 10 iterations for evaluating the strength of every player in every month.
The evaluation of the strengh was based on 2 steps when step 1 was the function that calculate strength that is similiar to chess metrics but there are important differences and step 2 was deciding that place 50 has rating 2625 in the rating list that is exactly the same as chess metrics.
calc_strength_chess_metric is the missing function to understand the algorithm and it basically got 11 parameters(all the 10 parameters that repeat_strength_estimate got and another parameter that is the month that we calculate estimate for it).
Note that the estimate for month 50 of player 1 when months 101-105 are missing is important because if player 2 played with player 1 at month 50
then it is going to influence the rating of player 2 at month 101-105 that is used to calculate the expected result.
I use the word estimate and not rating because rating by definition assume that we do not have future results.
I had basically 2 steps in
calc_strength_chess_metric
The first step was a loop that calculated the estimate for strength for every player in the relevant month.
The second step is a step that I used only when I needed to predict the strength in the missing months and it is practically unfair trick but not something that is forbidden in the competition because I used the information about games and not about the results in the supposed missing months to calculate changes in the rating estimate in these months.
I did not finish to explain my algorithm and I plan also to send code later but now I need only to explain the 2 steps of calc_strength_chess_metric to explain my algorithm and I will do it later in another post(this part of the program is only slightly more than 100 lines of code in C).
The first thing that I am going to explain is the first step in my calc_strength_chess_metric function.
it was a loop when I calculated the strength for every player so how did I calculate the strength?
I used a special function that got 12 parameters(the same 11 parameters that calc_strength_chess_mertics got and the id of the player to calculate the strength of it that had the name i)
This function simply did a loop on all months from 1-100 at distance of at most 80 months from the month to calculate strength for it
except the missing 5 months.
For every possible month number k that player i played in it
I had a weight that is calculated as
1-|month-k|/81 when month is the month that I need to calculate strength for it and k is the month of playing of player i.
Every game in this month is calculated as 1-|month-k|/81 games
and I also calculated weight result by multiply the result by that number(result before multiplying is 2 for win of i and 1 for draw and 0 for loss)
For every game I calculated
weighted result and weighted opponent rating and weighted number of opponents that is 1-|month-k|/81 for every game.
I reduced 0.03*weight from the weighted result if a player played with the white pieces and added the same number if the player played with the black pieces.
The opponent rating is simply the strength of the player(this strength is 2000 in the first iteration when we have no data about it).
After calculating opponents opp_rating and result I simply use chess metrics formula
after doing all of it I also add for the missing months activity bonus based on the number of games in the end of this function(1.2*numgames when numgames is the number of games in the missing month for example to calculate strength at month 103 assuming months 101-105 are missing
I add 1.2*number of games in months 101-103
This explain the first step but there is also a second step for updating the rating based on opponents in the missing months
and I use the function add_opp to update them.
The idea of add_opp is that I compare rating of opponents in the missing 5 months and rating of opponents in the last 12 months that we have and increase rating if I find that the opponents in the future are stronger.
People who are interested in the exact formula may read the function add_opp that I attach in this post(I attach all the code when I commented out part of the code that was about the cross data and is not relevant to the prediction and pushed it to the end).
Note that I did not do much optimization of parameters and I suspect that different parameters could give me the first place.
Note that in order to run the program succesfully you need to have the files of the test data and the training data at the same file as the exe file that is based on the code that I attach.
double
\r\n\r\n add_opp(int i,int missing,int month)\r\n {
int k;\r\n
\r\nint num_oppon=0;\r\n
\r\nint num_oppon_past=0;\r\n
\r\ndouble opp_rating_past=0;\r\n
\r\nint num;\r\n
\r\ndouble opp_rating=0;\r\n
\r\ndouble past_rating=0;\r\n
\r\nfor (k=missing-12;k<=missing;k++)\r\n {
if (k>=0)\r\n {
if (num_opp[i][k][0]>0)\r\n
\r\nfor (num=1;num<=num_opp[i][k][0];num++)\r\n { opp_rating_past+=strength[num_opp[i][k][num]][k]; num_oppon_past+=1; } } }
for (k=missing+1;k<=missing+5;k++)\r\n
\r\nif (num_opp[i][k][0]>0)\r\n
\r\nfor (num=1;num<=num_opp[i][k][0];num++)\r\n { opp_rating+=strength[num_opp[i][k][num]][k]; num_oppon+=1; }
if (num_oppon>0)\r\n opp_rating=opp_rating/num_oppon;
else
\r\nopp_rating=strength[i][month];
\r\n\r\nif (num_oppon_past>0)\r\n opp_rating_past=opp_rating_past/num_oppon_past;
else
\r\nopp_rating=strength[i][month];
\r\n\r\nif (opp_rating>opp_rating_past+60)\r\n
\r\nreturn 12;\r\n
\r\nif (opp_rating
return -12;\r\n
\r\nreturn (opp_rating-opp_rating_past)*0.2;
\r\n}
Edit:last comment: It is possible that I could get the first place only by doing more iterations(considering the small distance to the first place) and it may be interesting to check it.
Unfortunately
I did not think about doing more iterations in the last moment.
I decided to post all the code that I have for my best prediction in this competition directly
so everybody can run the code and verify the results
#include
#include
<stdlib.h>\r\n#include
<assert.h>\r\n#include
<memory.h>\r\n#include
<math.h>\r\nFILE *stream_training, *stream_test;
\r\n//stream_test step1 test data,stream_training step 2 training_data
\r\nconst
int games_training=65053;\r\nconst
int games_test=7809;\r\nconst
int total_games=73062;\r\nconst
int aboveidnumber=8632;\r\nint
isplayer2[aboveidnumber];//constant after step 1\r\nint
month_test[games_test];//constant after step 1\r\nint
month[total_games];//constant after step 1\r\nint
whiteplayer[total_games];//constant after step 1\r\nint
blackplayer[total_games];//constant after step 1\r\nint
whiteplayer_test[games_test];//constant after step 1\r\nint
blackplayer_test[games_test];//constant after step 1\r\nint
isplayer[aboveidnumber];//constant after step 2\r\ndouble
result[total_games];//constant after step 2\r\nfloat
read_result[total_games];//constant after step 2\r\nint
num_opp[aboveidnumber][106][40];//third field start with number of players to play at constant after step 3\r\nint
result_player[aboveidnumber];//constant after step 3\r\nint
num_color[aboveidnumber][106][40];//constant after step 3\r\nint
num_result[aboveidnumber][106][40];//constant after step 3\r\nint
numgames[aboveidnumber][106];//constant after step 3\r\nint
connected[aboveidnumber];//constant after step 3\r\ndouble
observed_result[aboveidnumber][106];//constant after step 4\r\ndouble
observed_result_small[aboveidnumber][106][5];//constant after step 4\r\nint
experienced_players[total_games][5];//constant after step 4 is used to calculate the expected result\r\n//and get 1 only if the relevant game is by 2 players with at least 48 games to be considered for RMSE
\r\ndouble
expected_result_small[aboveidnumber][106][5];//initiailized in step 3 and is the expected result for RMSE\r\n//(calculated at step 6
\r\ndouble
strength[aboveidnumber][106];//strength is based on all the data constant after step 5 that repeats itself\r\ndouble
expect_result_game[total_games][5];//constant after step 6 and \r\n//used to calculate later the expected result and the expected_result_small tables
\r\ndouble
predicted[games_test];//used only in the final step of the program to build the submission\r\ndouble
expected_result[aboveidnumber][106];//the expected result that include unexperienced players \r\n//initinalized in step 6 but I did not use it
\r\nconst
int whitecolor=0;\r\nconst
int blackcolor=1;\r\nvoid
read_test()\r\n{
//step 1 of the program that read the test data\r\n//for every game we have month white and black and it is also saved in the full data that include the training data\r\nint i;\r\nchar c;\r\nif ((stream_test = fopen(\"test_data.csv\", \"r+b\")) == NULL) {\r\nprintf(
\"The file 'test_data.csv' was not opened\\n\");\r\nreturn;\r\n}
else\r\nprintf(
\"The file 'test_data.csv' was opened\\n\");\r\nif (stream_test) {\r\n/* start reading from stream */\r\nfor (i = 1; i < 53; i++) {\r\nfscanf(stream_test,
\"%c\", &c);\r\n}
\r\nfor (i = 0; i < aboveidnumber; i++)\r\nisplayer2[i] = 0;
\r\nfor (i = 0; i < games_test; i++) {\r\nfscanf(stream_test,
\"%d\", &month_test[i]);\r\nmonth[games_training+i]=month_test[i];
\r\nfscanf(stream_test,
\"%c\", &c);\r\nfscanf(stream_test,
\"%d\", &whiteplayer_test[i]);\r\nwhiteplayer[games_training+i]=whiteplayer_test[i];
\r\nisplayer2[whiteplayer_test[i]] = 1;
\r\nfscanf(stream_test,
\"%c\", &c);\r\nfscanf(stream_test,
\"%d\", &blackplayer_test[i]);\r\nblackplayer[games_training+i]=blackplayer_test[i];
\r\nisplayer2[blackplayer_test[i]] = 1;
\r\nfscanf(stream_test,
\"%c\", &c); /* , */\r\nfscanf(stream_test,
\"%c\", &c); /* enter */\r\n}
\r\nfclose(stream_test);
\r\n}
\r\n}
\r\nvoid
read_training_data()\r\n{
\r\n//step 2 read the training data for every game we have month white black and result \r\nint i;\r\nchar c;\r\ndouble sum_result=0;\r\n/* start reading from stream */\r\nfor (i = 1; i < 53; i++) \r\n{
\r\nfscanf(stream_training,
\"%c\", &c);\r\nprintf(
\"%c\", c);\r\n}
\r\nmemset(isplayer, 0,
sizeof(isplayer));\r\nfor (i = 0; i < games_training; i++) \r\n{
\r\nfscanf(stream_training,
\"%d\", &month[i]);\r\nfscanf(stream_training,
\"%c\", &c);\r\nfscanf(stream_training,
\"%d\", &whiteplayer[i]);\r\nisplayer[whiteplayer[i]] = 1;
\r\nfscanf(stream_training,
\"%c\", &c);\r\nfscanf(stream_training,
\"%d\", &blackplayer[i]);\r\nisplayer[blackplayer[i]] = 1;
\r\nfscanf(stream_training,
\"%c\", &c);\r\nfscanf(stream_training,
\"%f\", &read_result[i]); /* 0.5 */\r\nresult[i] = read_result[i];
\r\nsum_result=sum_result+result[i];
\r\nfscanf(stream_training,
\"%c\", &c); /* enter */\r\n}
\r\nprintf(
\"sum is %f \",sum_result);\r\n}
\r\nvoid
fill_num_opp_array()\r\n{
//step 3 building the basic arrays\r\n//the arrays are:1)num_opp[num_player][num_month][0]\r\n//means number of opponents of player with id num_player in num_month\r\n//num_opp[num_player][num_month][j] for j>0 means num_player of opponent number j at the same month\r\n//num_color[num_player][num_month][j] for the same j>0 gives the color that num_player played in game number j of \r\n//month num_month\r\n//num_result of the same parameters means the result that the player got in the relevant game when win is 2\r\n//draw is 1 and loss is 0\r\n//result_player[i] means the total half points that i got in the training games\r\nint i,j,k,num,sum;\r\nint white,black;\r\nint month1;\r\nint diff;\r\ndouble weight;\r\nfor (i=0;i<aboveidnumber;i++)\r\nfor (j=1;j<=100;j++)\r\nnum_opp[i][0][j]=0;
\r\nfor (i=0;i<aboveidnumber;i++)\r\nresult_player[i]=0;
\r\nfor (i=0;i<games_training+games_test;i++)\r\n{
\r\nmonth1=month[i];
\r\nwhite=whiteplayer[i];
\r\nblack=blackplayer[i];
\r\nif (i<games_training)\r\n{
\r\nif (result[i] == 1)\r\nresult_player[white] += 2;
\r\nelse \r\nif (result[i] == 0)\r\nresult_player[black] += 2;
\r\nelse \r\n{
\r\nresult_player[white]++;
\r\nresult_player[black]++;
\r\n}
\r\n}
\r\nnum_opp[white][month1][0]++;
\r\nnum_opp[black][month1][0]++;
\r\nnum_opp[white][month1][num_opp[white][month1][0]]=black;
\r\nnum_color[white][month1][num_opp[white][month1][0]]=whitecolor;
\r\nnum_opp[black][month1][num_opp[black][month1][0]]=white;
\r\nnum_color[black][month1][num_opp[black][month1][0]]=blackcolor;
\r\nnum_result[white][month1][num_opp[white][month1][0]]=1;
\r\nnum_result[black][month1][num_opp[black][month1][0]]=1;
\r\nif (result[i] == 1)\r\n{
\r\nnum_result[white][month1][num_opp[white][month1][0]]=2;
\r\nnum_result[black][month1][num_opp[black][month1][0]]=0;
\r\n}
\r\nelse\r\nif (result[i]==0)\r\n{
\r\nnum_result[white][month1][num_opp[white][month1][0]]=0;
\r\nnum_result[black][month1][num_opp[black][month1][0]]=2;
\r\n}
\r\n}
\r\n//initialization of arrays like numgames that is the number of games of player i after j months\r\n//expected_result that is the expected result of player i after j months \r\n//and obsereved_result that is the observed result of player i after j months\r\n//connected means that the player is connected to all the player and the default value 0 means not connected\r\nfor (i = 0; i < aboveidnumber; i++) \r\n{
\r\nfor (j = 0; j < 106; j++) \r\n{
\r\nnumgames[i][j] = 0;
\r\nexpected_result[i][j] = 0;
\r\nobserved_result[i][j] = 0;
\r\nfor (k=0;k<=4;k++)\r\n{
\r\nobserved_result_small[i][j][k]=0;
\r\nexpected_result_small[i][j][k]=0;
\r\n}
\r\n}
\r\nconnected[i] = 0;
\r\n}
\r\n//1 is connected and every player who played with 1 or played with a connected player is connected\r\nconnected[1] = 1;
\r\nfor (j = 0; j < 5; j++) \r\n{
\r\nfor (i = 0; i < games_training; i++) \r\n{
\r\nif (connected[whiteplayer[i]] == 1)\r\nconnected[blackplayer[i]] = 1;
\r\nif (connected[blackplayer[i]] == 1)\r\nconnected[whiteplayer[i]] = 1;
\r\n}
\r\n}
\r\nsum = 0;
\r\nfor (i = 0; i < aboveidnumber; i++)\r\nsum = sum + connected[i];
\r\nprintf(
\"connected=%d\\n\", sum);\r\n//updating the numagames data to be correct\r\n//we need also to update expected and observed data\r\nfor (i = 0; i < games_training+games_test; i++) \r\n{
\r\nj = month[i];
\r\nwhile (j <= 105) \r\n{
\r\nnumgames[whiteplayer[i]][j]++;
\r\nnumgames[blackplayer[i]][j]++;
\r\nj++;
\r\n}
\r\n}
\r\n//counting players in the test data\r\nsum = 0;
\r\nfor (i = 0; i < aboveidnumber; i++) \r\n{
\r\nif (isplayer2[i] == 1) \r\nsum++;
\r\n}
\r\nprintf(
\"players in test are %d \", sum);\r\n\r\n
}
\r\n\r\n
void
calc_observed()\r\n{
\r\n//step 4 calculating the observed result for every player in every month\r\n//do it only one time we already initialized the observed array to 0 do the same for\r\n//observe_small\r\nint i,white,black,order,delay,start_check;\r\ndouble observed;\r\ni=0;
\r\nwhile (i < games_training) \r\n{
\r\nwhite = whiteplayer[i];
\r\nblack = blackplayer[i];
\r\norder = month[i];
\r\nobserved = result[i];
\r\nobserved_result[white][order] += observed;
\r\nobserved_result[black][order] += (1 - observed);
\r\nfor (delay=1;delay<=5;delay++)\r\n{
//we are at month number order we have results of month number order-delay and not results of the next 5 months\r\nexperienced_players[i][delay-1]=0;
\r\nif (order>delay)\r\n{
\r\nstart_check=order-delay-48;
\r\nif (start_check<0)\r\nstart_check=0;
\r\nif ((numgames[white][order-delay]-numgames[white][start_check]>=12)&&\r\n(numgames[black][order-delay]-numgames[black][start_check]>=12))
\r\n{
//player, number month of playing,delay in predicting minus 1\r\nobserved_result_small[white][order][delay-1] += observed;
//the observed results at month number order.\r\nobserved_result_small[black][order][delay-1] += (1 - observed);
\r\nexperienced_players[i][delay-1]=1;
\r\n}
\r\n}
\r\n}
\r\ni++;
\r\n}
\r\n}
\r\nint
is_candidate_chess_strength(int month,int missing,double candidate)\r\n{
\r\nint i;\r\nint sum=0;\r\nint monthmin=month-48;\r\nint monthmax=month;\r\nif (monthmin<0)\r\n{
\r\nmonthmin=0;
\r\nmonthmax=48;
\r\n}
\r\nfor (i=0;i<aboveidnumber;i++)\r\nif ((isplayer[i]==1)&&(numgames[i][monthmax]-numgames[i][monthmin]>=10))\r\nif (strength[i][month]>=2625-candidate)\r\nsum++;
\r\nif ((sum<50)&&(candidate>=0))\r\n{
//increasing by candidate is needed and done because number 50 is not more than \r\n// 2625-candidate<2625\r\nfor (i=0;i<aboveidnumber;i++)\r\nif (isplayer[i]==1) \r\nstrength[i][month]+=candidate;
\r\nreturn 1;\r\n}
\r\nelse\r\nif ((sum>=50)&&(candidate<0))\r\n{
\r\n//reducing by -candidate is needed and done because \r\n//there are 50 players with at least 2625-candidate>2625\r\nfor (i=0;i<aboveidnumber;i++)\r\nif (isplayer[i]==1) \r\nstrength[i][month]+=candidate;
\r\n}
\r\nreturn 0;\r\n\r\n
}
\r\n\r\n
void
fixplace50_chess_strength(int month,int missing)\r\n{
\r\nint sum=0;//this function changes the rating of player number 50 to be 2625\r\ndouble candidate;\r\nif (is_candidate_chess_strength(month,missing,0)==1)\r\ncandidate=1600;
\r\nelse\r\ncandidate=-1600;
\r\nwhile ((candidate>0.001)||(candidate<-0.001))\r\n{
\r\nis_candidate_chess_strength(month,missing,candidate);
\r\ncandidate=candidate/2.0;
\r\n}
\r\n}
\r\n\r\n
double
calc_strength_chess_metric_specific(int month,int missing,int max_months,\r\ndouble big_dif,double num_avg, double num_weak,\r\ndouble value_weak,double unrated,double adding,\r\ndouble minimal_game_finished,double reduction_per_game,int i)\r\n{
//used for step 5\r\n//impotant function for the prediction because it is used to calculate rating\r\nint k;\r\nint diff;\r\nint num;\r\ndouble result,opponents,weight,opp_rating,avg_rating,performance_rating,return_rating;\r\ndouble special_weight;\r\nresult=0;
\r\nopponents=0;
\r\nopp_rating=0;
\r\n//results of month+1,month+2,month+3,month+4,month+5 are missing from the data\r\nfor (k=1;k<=100;k++)\r\n{
\r\nif ((k<=missing)||(k>=missing+6))\r\n//we consider only results of these months to calculate rating at month number month\r\nif ((k>month-max_months)&&(k<month+max_months))\r\n{
\r\n\r\nif (num_opp[i][k][0]>0)\r\n
{
\r\ndiff=month-k;
\r\nif (diff<0)\r\ndiff=k-month;
\r\nweight=1-(1.0/(max_months))*diff;
\r\nfor (num=1;num<=num_opp[i][k][0];num++)\r\n{
\r\nopponents+=weight;
\r\nresult+=(num_result[i][k][num]*weight);
\r\nopp_rating+=(strength[num_opp[i][k][num]][k]*weight);
\r\nif (num_color[i][k][num]==whitecolor)\r\nresult-=0.03*weight;
\r\nelse\r\nresult+=0.03*weight;
\r\n}
\r\n}
\r\n\r\n
}
\r\n}
\r\nif (opponents>0)\r\n{
\r\navg_rating=opp_rating/opponents;
\r\nif (opponents<minimal_game_finished)\r\nvalue_weak-=(minimal_game_finished-opponents)*reduction_per_game;
\r\nperformance_rating=avg_rating+((result-opponents)/opponents)*big_dif;
\r\nreturn_rating=(performance_rating*opponents)+(avg_rating*num_avg)+(value_weak*num_weak);
\r\nreturn_rating=return_rating/(opponents+num_avg+num_weak);
\r\nreturn_rating+=adding;
\r\n}
\r\nelse\r\nreturn_rating=unrated;
\r\nif ((month>missing)&&(month<=missing+5))\r\nreturn_rating+=((numgames[i][month]-numgames[i][missing])*1.2);
\r\nreturn return_rating;\r\n}
\r\ndouble
add_opp(int i,int missing,int month)\r\n{
\r\nint k;\r\nint num_oppon=0;\r\nint num_oppon_past=0;\r\ndouble opp_rating_past=0;\r\nint num;\r\ndouble opp_rating=0;\r\ndouble past_rating=0;\r\nfor (k=missing-12;k<=missing;k++)\r\n{
\r\nif (k>=0)\r\n{
\r\nif (num_opp[i][k][0]>0)\r\nfor (num=1;num<=num_opp[i][k][0];num++)\r\n{
\r\nopp_rating_past+=strength[num_opp[i][k][num]][k];
\r\nnum_oppon_past+=1;
\r\n}
\r\n}
\r\n}
\r\nfor (k=missing+1;k<=missing+5;k++)\r\nif (num_opp[i][k][0]>0)\r\nfor (num=1;num<=num_opp[i][k][0];num++)\r\n{
\r\nopp_rating+=strength[num_opp[i][k][num]][k];
\r\nnum_oppon+=1;
\r\n}
\r\nif (num_oppon>0)\r\nopp_rating=opp_rating/num_oppon;
\r\nelse\r\nopp_rating=strength[i][month];
\r\nif (num_oppon_past>0)\r\nopp_rating_past=opp_rating_past/num_oppon_past;
\r\nelse\r\nopp_rating=strength[i][month];
\r\nif (opp_rating>opp_rating_past+60)\r\nreturn 12;\r\nif (opp_rating<opp_rating_past-60)\r\nreturn -12;\r\nreturn (opp_rating-opp_rating_past)*0.2;\r\n}
\r\nvoid
calc_strength_chess_metric(int month,int missing,int max_months,\r\ndouble big_dif,double num_avg, double num_weak,\r\ndouble value_weak,double unrated,double adding,\r\ndouble minimal_game_finished,double reduction_per_game)\r\n{
//used for step 5\r\ndouble temp_rating[aboveidnumber];\r\nint i=0;\r\nfor (i=1;i<aboveidnumber;i++)\r\nif (isplayer[i]==1)\r\ntemp_rating[i]=calc_strength_chess_metric_specific(month,missing,max_months,big_dif,num_avg,num_weak,value_weak,
\r\nunrated,adding,minimal_game_finished,reduction_per_game,i);
\r\nfor (i=1;i<aboveidnumber;i++)\r\n{
\r\nstrength[i][month]=temp_rating[i];
\r\n}
\r\nfor (i=1;i<aboveidnumber;i++)\r\nif ((month>missing)&&(month<=missing+5))\r\nstrength[i][month]+=add_opp(i,missing,month);
\r\n}
\r\nvoid
repeat_strength_estimate(int k,int max_months,double big_dif,double num_avg,double num_weak,double value_weak,\r\ndouble unrated,double minimal_game_finished,double reduction_per_game,double adding)\r\n{
//step 5 calculating the rating estimate when months k+1,...k+5 are missing k can be 0-100\r\nint i,j;\r\nfor (i=0;i<aboveidnumber;i++)\r\nfor (j=0;j<=105;j++)\r\nstrength[i][j]=2000;
\r\n//k is the last month when result is not missing for the estimate\r\nfor (i=0;i<100;i++)//i is the number of iteration\r\n{
\r\nprintf(
\" %d \",i);\r\nfor (j=0;j<=105;j++)//j is the month that we calculate rating for it.\r\n{
\r\ncalc_strength_chess_metric(j,k,max_months,big_dif,num_avg,num_weak,value_weak,unrated,adding,
\r\nminimal_game_finished,reduction_per_game);
\r\nfixplace50_chess_strength(j,k);
\r\n}
\r\n}
\r\n}
\r\ndouble
expected_number2(double diff,double max_diff)\r\n{
\r\ndouble num=0.5+(diff/(2*max_diff));//25/850=1/34\r\nif (num>0.970588)\r\nnum=0.970588;
\r\nif (num<0.1)\r\nnum=0.1;
\r\nreturn num;\r\n}
\r\ndouble
expectedwhitechess_result(int white,int black,int month)\r\n{
\r\n//this function predicts the result of white and black in specific month\r\n//I currently use the rating but it is going to be changed\r\ndouble whiterating=strength[white][month];//first missing month is 101 \r\n//in case of predicting and something else in other cases\r\ndouble blackrating=strength[black][month];\r\ndouble bonus=(whiterating+blackrating-3100)/40.0;\r\nif (bonus>50)\r\nbonus=50;
\r\nreturn expected_number2(whiterating+bonus-blackrating,425);\r\n}
\r\n\r\n
void
calc_expected(int monthx)\r\n{
//monthx+1,...monthx+5 are missing and we calculate expected result \r\n//for every player based on this information\r\nint white,black,order,i,delay,start_check,j;\r\ndouble expected;\r\ni=0;
\r\nfor (i = 0; i < aboveidnumber; i++) \r\n{
\r\nfor (j = monthx; j < monthx+5; j++) \r\nexpected_result[i][j] = 0;
\r\n}
\r\nwhile (month[i]<=monthx)\r\ni++;
\r\n\r\nwhile ((i<games_training)&&(month[i]>monthx)&&(month[i]<=monthx+5))\r\n
{
\r\nwhite = whiteplayer[i];
\r\nblack = blackplayer[i];
\r\norder = month[i];
\r\nexpected=expect_result_game[i][order-monthx-1];
\r\nexpected_result[white][order]+=expected;
\r\nexpected_result[black][order]+=(1-expected);
\r\ndelay=order-monthx;
//1-5\r\nif (experienced_players[i][delay-1]==1)\r\n{
\r\nexpected_result_small[white][order][delay-1] += expected;
//the expected results at month number order.\r\nexpected_result_small[black][order][delay-1] += (1 - expected);
\r\n}
\r\ni++;
\r\n}
\r\n}
\r\ndouble
calc_error_result_small(int monthx,int delay)\r\n{
\r\nint i;\r\nint order=monthx+delay;\r\ndouble err;\r\ndouble RMSE=0;\r\nfor (i=1;i<aboveidnumber;i++)\r\nif (isplayer[i]==1)\r\n{
\r\nerr=observed_result_small[i][order][delay-1]-expected_result_small[i][order][delay-1];
\r\nRMSE+=err*err;
\r\n}
\r\nreturn RMSE;\r\n}
\r\nvoid
build_expected_result(int monthx)\r\n{
//step 6\r\n//we build expected result table for monthx+1,...monthx+5 based on the rating list\r\n//first step is to build the expected_result table for month+1,...month+5 \r\n//based on strength in the relevant month and maybe more parameters that I will add later\r\nint white,black,i;\r\ni=0;
\r\nwhile (i<games_training)\r\n{
\r\nif ((month[i]>=monthx+1)&&(month[i]<=monthx+5))\r\n{
\r\nwhite=whiteplayer[i];
\r\nblack=blackplayer[i];
\r\nexpect_result_game[i][month[i]-monthx-1]=expectedwhitechess_result(white,black,month[i]);
\r\n//should be improved but this is an initial version \r\n}
\r\ni++;
\r\n}
\r\ncalc_expected(monthx);
\r\n}
\r\nvoid
build_stupid_csv_prediction()\r\n{
\r\n/* submission.csv */\r\nint i;\r\nchar c;\r\nFILE *stream_prediction = fopen(
\"submission119.csv\", \"w+b\");\r\nstream_test = fopen(
\"test_data.csv\", \"r+b\");\r\nassert(stream_prediction);
\r\nassert(stream_test);
\r\nif (stream_test == NULL || stream_prediction == NULL)\r\n{
\r\nputs(
\"Usage error:\\nfiles submission.cs and test_data.csv are expected to be available in the current working directory.\\n\");\r\nexit(EXIT_FAILURE);
\r\n}
\r\nfor (i = 1; i < 53; i++) {\r\nfscanf(stream_test,
\"%c\", &c);\r\nfprintf(stream_prediction,
\"%c\", c);\r\n}
\r\nfor (i = 0; i < games_test; i++) {\r\nfprintf(stream_prediction,
\"%d\", month_test[i]);\r\nfprintf(stream_prediction,
\"%c\", ',');\r\nfprintf(stream_prediction,
\"%d\", whiteplayer_test[i]);\r\nassert(whiteplayer[games_training+i]==whiteplayer_test[i]);
\r\nfprintf(stream_prediction,
\"%c\", ',');\r\nfprintf(stream_prediction,
\"%d\", blackplayer_test[i]);\r\nassert(blackplayer[games_training+i]==blackplayer_test[i]);
\r\nfprintf(stream_prediction,
\"%c\", ',');\r\nfprintf(stream_prediction,
\"%f\", predicted[i]);\r\nfprintf(stream_prediction,
\"%c\", '\\n');\r\n}
\r\nfclose(stream_test);
\r\nfclose(stream_prediction);
\r\n}
\r\n\r\n
void
predicting_chess_metrics(double white_bonus,double max_diff)\r\n{
//425\r\nint i;\r\nint white,black;\r\nfor (i = 0; i < games_test; i++) \r\n{
\r\nwhite = whiteplayer_test[i];
\r\nblack = blackplayer_test[i];
\r\npredicted[i]=expectedwhitechess_result(white,black,month_test[i]);
\r\n}
\r\nbuild_stupid_csv_prediction();
\r\n\r\n
}
\r\nint
main(void)\r\n{
\r\nint i,j;\r\nint sum = 0;\r\ndouble sum_result=0;\r\ndouble error=0;\r\nread_test();
//step 1\r\nif ((stream_training = fopen(\"training_data.csv\", \"r+b\")) == NULL) /* C4996 */\r\nprintf(
\"The file 'training_data.csv' was not opened\\n\");\r\nelse\r\nprintf(
\"The file 'training_data.csv' was opened\\n\");\r\nif (stream_training) \r\n{
\r\nread_training_data();
//step 2 \r\nfill_num_opp_array();
//step 3\r\ncalc_observed();
//step 4\r\nfor (i=90;i<=100;i++)\r\n{
//i should be a parameter\r\n\r\n
repeat_strength_estimate(i,81,310,5.9,2.2,2210,2285,15,12,39);
//step 5\r\n//months i+1,i+2,i+3,i+4,i+5 are missing and we need to predict them\r\nbuild_expected_result(i);
//step 6 this function is going to build \r\n//expected result table based on strength estimate(months i+1,...i+5 missing)\r\nfor (j=1;j<=5;j++)\r\nif ((i+j)<=100)\r\nerror+=calc_error_result_small(i,j);
\r\nprintf(
\" error=%f \",error);\r\n\r\n
}
\r\npredicting_chess_metrics(45,425);
//bonus for white and maximal difference\r\nfclose(stream_training);
\r\n}
\r\n}
" }, { "id": 1258, "postDate": "2010-11-20T04:38:53Z", "content": "only one correction of the code
The original code had
for (i=0;i<10;i++)//i is the number of iteration
I changed it to 100 iterations in the code that I posted.
100 iterations probably give better result than the result that I got but not good enough for the first place(my tests suggest small improvement in predicting of less than 0.1%) .