int
main(void) {
learned_factors_t* learned;
training_set_t* tset;
recommended_items_t* r_items = NULL;
learning_model_t model = {0};
//Model configuration
//Setup model parameters
model_parameters_t params = { 0 };
params.items_number = 3;
params.users_number = 2;
params.training_set_size = 5;
params.dimensionality = 40;
params.iteration_number = 60;
params.lambda = 0.055;
params.step = 0.0095;
params.lambda_bias = 0.02;
params.step_bias = 0.001;
//Use the basic matrix factorization model
model.learning_algorithm = learn_mf_bias;
model.rating_estimator = estimate_rating_mf_bias;
model.parameters = params;
//Learning
//Initialize a training set
tset = init_training_set(params);
set_known_rating(0, 0, 1, tset);
set_known_rating(0, 1, 0, tset);
set_known_rating(0, 2, 6, tset);
set_known_rating(1, 1, 0, tset);
set_known_rating(1, 0, 2, tset);
compile_training_set(tset);
learned = learn(tset, model);
//Rating estimation
printf( "users [0] item [0], rating = %f \n",
estimate_rating_from_factors(0, 0, learned, model));
printf( "users [0] item [1], rating = %f \n",
estimate_rating_from_factors(0, 1, learned, model));
printf( "users [0] item [2], rating = %f \n",
estimate_rating_from_factors(0, 2, learned, model));
printf( "users [1] item [1], rating = %f \n",
estimate_rating_from_factors(1, 1, learned, model));
printf( "users [1] item [0], rating = %f \n",
estimate_rating_from_factors(1, 0, learned, model));
r_items = recommend_items(0, 3, learned, tset, model);
print_recommended_items(r_items->items->head, 0);
free_recommended_items(r_items);
free_learned_factors(learned);
free_training_set(tset);
return 0;
}
int on_url (http_parser* parser, const char *at, size_t length)
{
client_t* client = (client_t*) parser->data;
if(parser->method != 1)
return 0;
LOGF ("[ %5d ] url parsed", client->request_num);
struct http_parser_url *u = malloc (sizeof (struct http_parser_url) );
uv_tcp_t* handle = &client->handle;
char* path = malloc ((length +1)* sizeof (char) );
char * content = malloc (304800);
char * buffer = malloc (304800);
uv_buf_t resbuf;
strncpy (path, at, length);
size_t user_id=server_param->model.parameters.users_number;
path[length]=0;
sscanf (path, "/user=%u", &user_id);
if (user_id >= server_param->model.parameters.users_number)
{
strcpy (content, "{ \n"\
"\"error\": { \n"\
"\"message\": \"Unsupported get request.\", \n"\
"\"type\": \"User Not Valid\", \n"\
"}\n"\
"}");
}
else
{
rating_estimator_parameters_t* estim_param = malloc (sizeof (rating_estimator_parameters_t) );
int backup=0;
if (uv_mutex_trylock(&factors_mutex))
{
uv_mutex_lock(&factors_backup_mutex);
backup=1;
estim_param->lfactors = factors;
printf("Backup \n");
printf("factors_backup_mutex locked outside of thread \n");
}else
{
estim_param->lfactors = factors_backup;
}
estim_param->tset = training_set;
estim_param->user_index = user_id;
recommended_items_t* rec = recommend_items (estim_param, server_param->model, 4);
uv_mutex_unlock(&factors_mutex);
if(backup==1)
{
uv_mutex_unlock(&factors_backup_mutex);
}
LOG ("recommendation completed");
int i;
sprintf (content, "{ \n \"user_index\" : %u, \n",user_id);
sprintf (content, "%s \"recommended_items\" : [ \n",content);
for (i = 0; i < rec->items_number - 1; i++)
{
sprintf (content, "%s { \"item\" : %u , \"rating\" : %lf }, \n", content, rec->items[i].index, rec->items[i].rating);
}
sprintf (content, "%s { \"item\" : %u , \"rating\" : %lf } \n ], \n", content, rec->items[rec->items_number - 1].index, rec->items[rec->items_number - 1].rating);
coo_matrix_t* top_rated_items=get_top_rated_items(training_set,user_id,6);
sprintf (content, "%s \"top_rated_items\" : [ \n",content);
for(i=0;i < top_rated_items->size - 1; i++)
{
sprintf (content, "%s { \"item\" : %u , \"rating\" : %lf }, \n",
content, top_rated_items->entries[i].row_i, top_rated_items->entries[i].value);
}
sprintf (content, "%s { \"item\" : %u , \"rating\" : %lf } \n ], \n",
content, top_rated_items->entries[top_rated_items->size-1].row_i, top_rated_items->entries[top_rated_items->size-1].value);
coo_matrix_t* rated_items=get_rated_items(training_set,user_id);
sprintf (content, "%s \"rated_items\" : [ \n",content);
for(i=0;i < rated_items->current_size; i++)
{
sprintf (content, "%s { \"item\" : %u , \"rating\" : %lf }, \n",
content, rated_items->entries[i].row_i, rated_items->entries[i].value);
}
sprintf (content, "%s { \"item\" : %u , \"rating\" : %lf } \n ] \n",
content, rated_items->entries[rated_items->current_size-1].row_i, rated_items->entries[rated_items->current_size-1].value);
sprintf (content, "%s \n }", content);
free_coo_matrix(rated_items);
free_coo_matrix(top_rated_items);
}
sprintf (buffer, "%s %u \r\n\r\n%s\n", HEADER, strlen (content), content);
resbuf.base = buffer;
resbuf.len = strlen (resbuf.base);
uv_write (
&client->write_req,
(uv_stream_t*) &client->handle,
&resbuf,
1,
after_write);
free (content);
free (path);
return 0;
}
