[Test()] public void TestRemoveAt()
{
var ratings = new RatingsProxy(CreateRatings(), Enumerable.Range(0, 8).ToList());
Assert.AreEqual(8, ratings.Count);
Assert.AreEqual(0.4f, ratings[2, 5]);
Assert.AreEqual(3, ratings.ByUser[2].Count);
Assert.AreEqual(1, ratings.ByUser[6].Count);
Assert.AreEqual(2, ratings.ByItem[3].Count);
Assert.AreEqual(1, ratings.ByItem[5].Count);
Assert.AreEqual(3, ratings.CountByUser[2]);
Assert.AreEqual(1, ratings.CountByUser[6]);
Assert.AreEqual(2, ratings.CountByItem[3]);
Assert.AreEqual(1, ratings.CountByItem[5]);
ratings.RemoveAt(ratings.GetIndex(2, 5));
Assert.AreEqual(7, ratings.Count);
Assert.AreEqual(2, ratings.ByUser[2].Count);
Assert.AreEqual(0, ratings.ByItem[5].Count);
Assert.AreEqual(2, ratings.CountByUser[2]);
Assert.AreEqual(0, ratings.CountByItem[5]);
ratings.RemoveAt(ratings.GetIndex(6, 3));
Assert.AreEqual(6, ratings.Count);
Assert.AreEqual(0, ratings.ByUser[6].Count);
Assert.AreEqual(1, ratings.ByItem[3].Count);
Assert.AreEqual(0, ratings.CountByUser[6]);
Assert.AreEqual(1, ratings.CountByItem[3]);
float r;
Assert.IsFalse(ratings.TryGet(2, 5, out r));
}
public static void Main(string[] args)
{
// TODO add random seed
// TODO report per-user times
string data_file = args[0];
string method = args[1];
string options = args[2];
int num_test_users = int.Parse(args[3]);
// load the data
var all_data = RatingData.Read(data_file);
// TODO randomize
var test_users = new HashSet<int>(Enumerable.Range(0, num_test_users));
var update_indices = new List<int>();
var eval_indices = new List<int>();
foreach (int user_id in test_users)
if (all_data.ByUser[user_id].Count > 1)
{
var user_indices = all_data.ByUser[user_id];
for (int i = 0; i < user_indices.Count - 1; i++)
update_indices.Add(user_indices[i]);
for (int i = user_indices.Count - 1; i < user_indices.Count; i++)
eval_indices.Add(user_indices[i]);
}
var training_indices = new List<int>();
for (int i = 0; i < all_data.Count; i++)
if (!test_users.Contains(all_data.Users[i]))
training_indices.Add(i);
var training_data = new MyMediaLite.Data.Ratings();
foreach (int i in training_indices)
training_data.Add(all_data.Users[i], all_data.Items[i], all_data[i]);
var update_data = new RatingsProxy(all_data, update_indices);
var eval_data = new RatingsProxy(all_data, eval_indices);
Console.Write(training_data.Statistics());
Console.Write(update_data.Statistics());
Console.Write(eval_data.Statistics());
// prepare recommender
RatingPredictor recommender = Recommender.CreateRatingPredictor(method);
recommender.Configure(options);
recommender.Ratings = training_data;
Console.WriteLine(string.Format(CultureInfo.InvariantCulture, "ratings range: [{0}, {1}]", recommender.MinRating, recommender.MaxRating));
Console.WriteLine("recommender: {0}", recommender);
recommender.Train();
// I. complete retraining
Console.WriteLine(
"complete training: {0}",
recommender.EvaluateFoldInCompleteRetraining(update_data, eval_data));
// II. online updates
Console.WriteLine(
"incremental training: {0}",
((IncrementalRatingPredictor)recommender).EvaluateFoldInIncrementalTraining(update_data, eval_data));
// III. fold-in
Console.WriteLine(
"fold-in: {0}",
((IFoldInRatingPredictor)recommender).EvaluateFoldIn(update_data, eval_data));
}
/// <summary>Performs user-wise fold-in evaluation, but instead of folding in perform a complete re-training with the new data</summary>
/// <remarks>
/// This method can be quite slow.
/// </remarks>
/// <returns>the evaluation results</returns>
/// <param name='recommender'>a rating predictor capable of performing a user fold-in</param>
/// <param name='update_data'>the rating data used to represent the users</param>
/// <param name='eval_data'>the evaluation data</param>
static public RatingPredictionEvaluationResults EvaluateFoldInCompleteRetraining(this RatingPredictor recommender, IRatings update_data, IRatings eval_data)
{
double rmse = 0;
double mae = 0;
double cbd = 0;
int rating_count = 0;
foreach (int user_id in update_data.AllUsers)
if (eval_data.AllUsers.Contains(user_id))
{
var local_recommender = (RatingPredictor) recommender.Clone();
var known_ratings = new RatingsProxy(update_data, update_data.ByUser[user_id]);
local_recommender.Ratings = new CombinedRatings(recommender.Ratings, known_ratings);
local_recommender.Train();
var items_to_rate = (from index in eval_data.ByUser[user_id] select eval_data.Items[index]).ToArray();
var predicted_ratings = recommender.Recommend(user_id, candidate_items:items_to_rate);
foreach (var pred in predicted_ratings)
{
float prediction = pred.Item2;
float actual_rating = eval_data.Get(user_id, pred.Item1, eval_data.ByUser[user_id]);
float error = prediction - actual_rating;
rmse += error * error;
mae += Math.Abs(error);
cbd += Eval.Ratings.ComputeCBD(actual_rating, prediction, recommender.MinRating, recommender.MaxRating);
rating_count++;
}
Console.Error.Write(".");
}
mae = mae / rating_count;
rmse = Math.Sqrt(rmse / rating_count);
cbd = cbd / rating_count;
var result = new RatingPredictionEvaluationResults();
result["RMSE"] = (float) rmse;
result["MAE"] = (float) mae;
result["NMAE"] = (float) mae / (recommender.MaxRating - recommender.MinRating);
result["CBD"] = (float) cbd;
return result;
}
[Test()] public void TestMaxRating()
{
var ratings = new RatingsProxy(CreateRatings(), new int[] { 1, 3, 5 });
Assert.AreEqual(0.6f, ratings.Scale.Max);
}
[Test()] public void TestCount()
{
var ratings = new RatingsProxy(CreateRatings(), new int[] { 1, 3, 5 });
Assert.AreEqual(3, ratings.Count);
}
/*
[Test()]
[ExpectedException(typeof(NotSupportedException))]
public void TestRemoveAt()
{
var ratings = new CombinedRatings(CreateRatings1(), CreateRatings2());
ratings.RemoveAt(ratings.GetIndex(2, 5));
Assert.AreEqual(CreateRatings1().Count + CreateRatings2().Count - 1, ratings.Count);
double r;
Assert.IsFalse(ratings.TryGet(2, 5, out r));
ratings.RemoveAt(ratings.GetIndex(7, 9));
Assert.AreEqual(CreateRatings1().Count + CreateRatings2().Count - 2, ratings.Count);
Assert.IsFalse(ratings.TryGet(7, 9, out r));
}
[Test()]
[ExpectedException(typeof(NotSupportedException))]
public void TestRemoveUser()
{
var ratings = new CombinedRatings(CreateRatings1(), CreateRatings2());
ratings.RemoveUser(2);
}
[Test()]
[ExpectedException(typeof(NotSupportedException))]
public void TestRemoveItem()
{
var ratings = new CombinedRatings(CreateRatings1(), CreateRatings2());
ratings.RemoveItem(5);
}
*/
[Test()] public void TestIndex()
{
var ratings = new RatingsProxy(CreateRatings(), new int[] { 1, 3, 5 });
// test index[,]
Assert.AreEqual(0.2f, ratings[1, 8]);
Assert.AreEqual(0.6f, ratings[2, 2]);
Assert.AreEqual(0.2f, ratings[3, 7]);
}
[Test()] public void TestMaxItemID()
{
var ratings = new RatingsProxy(CreateRatings(), new int[] { 1, 3, 5 });
Assert.AreEqual(8, ratings.MaxItemID);
}
public void TestAdd()
{
var ratings = new RatingsProxy(CreateRatings(), new int[] { 1, 3, 5 });
ratings.Add(7, 5, 0.3f);
}
[Test()] public void TestRemoveItem()
{
var ratings = new RatingsProxy(CreateRatings(), Enumerable.Range(0, 8).ToList());
Assert.AreEqual(8, ratings.Count);
Assert.AreEqual(0.2f, ratings[2, 4]);
Assert.AreEqual(2, ratings.ByUser[1].Count);
Assert.AreEqual(3, ratings.ByUser[2].Count);
Assert.AreEqual(2, ratings.ByUser[3].Count);
Assert.AreEqual(2, ratings.CountByUser[1]);
Assert.AreEqual(3, ratings.CountByUser[2]);
Assert.AreEqual(2, ratings.CountByUser[3]);
ratings.RemoveItem(4);
Assert.AreEqual(6, ratings.Count);
Assert.AreEqual(1, ratings.ByUser[1].Count);
Assert.AreEqual(2, ratings.ByUser[2].Count);
Assert.AreEqual(1, ratings.CountByUser[1]);
Assert.AreEqual(2, ratings.CountByUser[2]);
float r;
Assert.IsFalse(ratings.TryGet(1, 4, out r));
Assert.IsFalse(ratings.TryGet(2, 4, out r));
Assert.IsFalse(ratings.TryGet(3, 4, out r));
}
[Test()] public void TestRemoveUser()
{
var ratings = new RatingsProxy(CreateRatings(), Enumerable.Range(0, 8).ToList());
Assert.AreEqual(8, ratings.Count);
Assert.AreEqual(0.4f, ratings[2, 5]);
Assert.AreEqual(1, ratings.ByItem[2].Count);
Assert.AreEqual(2, ratings.ByItem[4].Count);
Assert.AreEqual(1, ratings.ByItem[5].Count);
Assert.AreEqual(1, ratings.CountByItem[2]);
Assert.AreEqual(2, ratings.CountByItem[4]);
Assert.AreEqual(1, ratings.CountByItem[5]);
ratings.RemoveUser(2);
Assert.AreEqual(5, ratings.Count);
Assert.AreEqual(0, ratings.ByItem[2].Count);
Assert.AreEqual(1, ratings.ByItem[4].Count);
Assert.AreEqual(0, ratings.ByItem[5].Count);
Assert.AreEqual(0, ratings.CountByItem[2]);
Assert.AreEqual(1, ratings.CountByItem[4]);
Assert.AreEqual(0, ratings.CountByItem[5]);
float rating;
Assert.IsFalse(ratings.TryGet(2, 5, out rating));
Assert.IsFalse(ratings.TryGet(2, 4, out rating));
Assert.IsFalse(ratings.TryGet(2, 2, out rating));
}
public void TestMinRating()
{
var ratings = new RatingsProxy(CreateRatings(), new int[] { 1, 3, 5 });
Assert.AreEqual(0.2f, ratings.MinRating);
}
public void TestMaxUserID()
{
var ratings = new RatingsProxy(CreateRatings(), new int[] { 1, 3, 5 });
Assert.AreEqual(3, ratings.MaxUserID);
}
