///
public override float ComputeObjective()
{
double user_complexity = 0;
for (int user_id = 0; user_id <= MaxUserID; user_id++)
{
if (ratings.CountByUser.Count > user_id)
{
user_complexity += Math.Pow(VectorExtensions.EuclideanNorm(user_factors.GetRow(user_id)), 2);
user_complexity += BiasReg * Math.Pow(user_bias[user_id], 2);
}
}
double item_complexity = 0;
for (int item_id = 0; item_id <= MaxItemID; item_id++)
{
if (ratings.CountByItem.Count > item_id)
{
item_complexity += Math.Pow(VectorExtensions.EuclideanNorm(item_factors.GetRow(item_id)), 2);
item_complexity += BiasReg * Math.Pow(item_bias[item_id], 2);
}
}
double complexity = RegU * user_complexity + RegI * item_complexity;
double social_regularization = 0;
for (int user_id = 0; user_id <= MaxUserID; user_id++)
{
double bias_diff = 0;
var factor_diffs = new double[NumFactors];
foreach (int v in user_connections[user_id])
{
bias_diff -= user_bias[v];
for (int f = 0; f < factor_diffs.Length; f++)
{
factor_diffs[f] -= user_factors[v, f];
}
}
if (user_connections[user_id].Count > 0)
{
bias_diff /= user_connections[user_id].Count;
}
bias_diff += user_bias[user_id];
social_regularization += Math.Pow(bias_diff, 2);
for (int f = 0; f < factor_diffs.Length; f++)
{
if (user_connections[user_id].Count > 0)
{
factor_diffs[f] /= user_connections[user_id].Count;
}
factor_diffs[f] += user_factors[user_id, f];
social_regularization += Math.Pow(factor_diffs[f], 2);
}
}
social_regularization *= this.social_regularization;
return((float)(ComputeLoss() + complexity + social_regularization));
}
///
protected double[] ComputeMappingFit()
{
double rmse = 0;
double penalty = 0;
double[] rmse_and_penalty_per_factor = new double[num_factors];
int num_users = 0;
for (int i = 0; i <= MaxUserID; i++)
{
var user_items = Feedback.UserMatrix[i];
var user_attrs = user_attributes[i];
if (user_items.Count == 0 || user_attrs.Count == 0)
{
continue;
}
num_users++;
double[] est_factors = MapUserToLatentFactorSpace(user_attributes[i]);
for (int j = 0; j < num_factors; j++)
{
double error = Math.Pow(est_factors[j] - user_factors[i, j], 2);
double reg_term = reg_mapping * VectorExtensions.EuclideanNorm(attribute_to_factor.GetColumn(j));
rmse += error;
penalty += reg_term;
rmse_and_penalty_per_factor[j] += error + reg_term;
}
}
for (int i = 0; i < num_factors; i++)
{
rmse_and_penalty_per_factor[i] = (double)rmse_and_penalty_per_factor[i] / num_users;
Console.Error.Write("{0:0.####} ", rmse_and_penalty_per_factor[i]);
}
rmse = (double)rmse / (num_factors * num_users);
penalty = (double)penalty / (num_factors * num_users);
Console.Error.WriteLine(" > {0:0.####} ({1:0.####})", rmse, penalty);
return(rmse_and_penalty_per_factor);
}
