public void TestGetPositivelyCorrelatedEntities()
{
// create a test CorrelationMatrix
var matrix = new CorrelationMatrix(4);
float[] row1 = { 0.1f, 0.4f, 0.2f, 0.3f };
float[] row2 = { 0.3f, 0.1f, 0.6f, 0.7f };
float[] row3 = { 0.2f, 0.6f, 0.3f, 0.5f };
float[] row4 = { 0.4f, 0.2f, 0.5f, 0.1f };
matrix.SetRow(0, row1);
matrix.SetRow(1, row2);
matrix.SetRow(2, row3);
matrix.SetRow(3, row4);
Assert.AreEqual(0.1f, matrix[0, 0]);
Assert.AreEqual(0.5f, matrix[3, 2]);
// test
IList <int> cor_entities_list = matrix.GetPositivelyCorrelatedEntities(2);
int[] cor_entities = new int[5];
cor_entities_list.CopyTo(cor_entities, 0);
int[] pos_cor_entities = { 1, 3, 0, 0, 0 };
Assert.AreEqual(pos_cor_entities, cor_entities);
}
/// <summary>map to latent factor space (actual function)</summary>
protected override double[] __MapToLatentFactorSpace(int item_id)
{
var est_factors = new double[num_factors];
IList <int> relevant_items = item_correlation.GetPositivelyCorrelatedEntities(item_id);
double weight_sum = 0;
uint neighbors = k;
foreach (int item_id2 in relevant_items)
{
if (item_id2 >= item_factors.dim1) // check whether item is in training data
{
continue;
}
if (Feedback.ItemMatrix[item_id2].Count == 0)
{
continue;
}
double weight = item_correlation[item_id, item_id2];
weight_sum += weight;
for (int f = 0; f < num_factors; f++)
{
est_factors[f] += weight * item_factors[item_id2, f];
}
if (--neighbors == 0)
{
break;
}
}
for (int f = 0; f < num_factors; f++)
{
est_factors[f] /= weight_sum;
}
return(est_factors);
}
public void TestGetPositivelyCorrelatedEntities()
{
// create a test CorrelationMatrix
var matrix = new CorrelationMatrix(4);
float[] row1 = { 0.1f, 0.4f, 0.2f, 0.3f };
float[] row2 = { 0.3f, 0.1f, 0.6f, 0.7f };
float[] row3 = { 0.2f, 0.6f, 0.3f, 0.5f };
float[] row4 = { 0.4f, 0.2f, 0.5f, 0.1f };
matrix.SetRow(0, row1);
matrix.SetRow(1, row2);
matrix.SetRow(2, row3);
matrix.SetRow(3, row4);
Assert.AreEqual(0.1f, matrix[0, 0]);
Assert.AreEqual(0.5f, matrix[3, 2]);
// test
IList<int> cor_entities_list = matrix.GetPositivelyCorrelatedEntities(2);
int[] cor_entities = new int[5];
cor_entities_list.CopyTo(cor_entities, 0);
int[] pos_cor_entities = { 1, 3, 0, 0, 0 };
Assert.AreEqual(pos_cor_entities, cor_entities);
}
/// <summary>Predict the rating of a given user for a given item</summary>
/// <remarks>
/// If the user or the item are not known to the recommender, a suitable average rating is returned.
/// To avoid this behavior for unknown entities, use CanPredict() to check before.
/// </remarks>
/// <param name="user_id">the user ID</param>
/// <param name="item_id">the item ID</param>
/// <returns>the predicted rating</returns>
public override double Predict(int user_id, int item_id)
{
if (user_id < 0)
{
throw new ArgumentException("user is unknown: " + user_id);
}
if (item_id < 0)
{
throw new ArgumentException("item is unknown: " + item_id);
}
if ((user_id > MaxUserID) || (item_id > MaxItemID))
{
return(base.Predict(user_id, item_id));
}
double sum = 0;
double weight_sum = 0;
uint neighbors = K;
if (Entity == EntityType.USER)
{
IList <int> relevant_users = correlation.GetPositivelyCorrelatedEntities(user_id);
foreach (int user_id2 in relevant_users)
{
if (entity_data[user_id2, item_id])
{
double rating = ratings.Get(user_id2, item_id, ratings.ByUser[user_id2]);
double weight = correlation[user_id, user_id2];
weight_sum += weight;
sum += weight * (rating - base.Predict(user_id2, item_id));
if (--neighbors == 0)
{
break;
}
}
}
}
else if (Entity == EntityType.ITEM)
{
IList <int> relevant_items = correlation.GetPositivelyCorrelatedEntities(item_id);
foreach (int item_id2 in relevant_items)
{
if (entity_data[item_id2, user_id])
{
double rating = ratings.Get(user_id, item_id2, ratings.ByItem[item_id2]);
double weight = correlation[item_id, item_id2];
weight_sum += weight;
sum += weight * (rating - base.Predict(user_id, item_id2));
if (--neighbors == 0)
{
break;
}
}
}
}
else
{
throw new ArgumentException("Unknown entity type: " + Entity);
}
double result = base.Predict(user_id, item_id);
if (weight_sum != 0)
{
result += sum / weight_sum;
}
if (result > MaxRating)
{
result = MaxRating;
}
if (result < MinRating)
{
result = MinRating;
}
return(result);
}