public void SetUp()
{
training_data = new PosOnlyFeedback<SparseBooleanMatrix>();
training_data.Add(1, 1);
training_data.Add(1, 2);
training_data.Add(2, 2);
training_data.Add(2, 3);
training_data.Add(3, 1);
training_data.Add(3, 2);
recommender = new MostPopular() { Feedback = training_data };
recommender.Train();
test_data = new PosOnlyFeedback<SparseBooleanMatrix>();
test_data.Add(2, 3);
test_data.Add(2, 4);
test_data.Add(4, 4);
all_users = Enumerable.Range(1, 4).ToList();
candidate_items = Enumerable.Range(1, 5).ToList();
}
/// <summary>Evaluate an iterative recommender on the folds of a dataset split, display results on STDOUT</summary>
/// <param name="recommender">an item recommender</param>
/// <param name="split">a positive-only feedback dataset split</param>
/// <param name="test_users">a collection of integers with all test users</param>
/// <param name="candidate_items">a collection of integers with all candidate items</param>
/// <param name="candidate_item_mode">the mode used to determine the candidate items</param>
/// <param name="repeated_events">allow repeated events in the evaluation (i.e. items accessed by a user before may be in the recommended list)</param>
/// <param name="max_iter">the maximum number of iterations</param>
/// <param name="find_iter">the report interval</param>
/// <param name="show_fold_results">if set to true to print per-fold results to STDERR</param>
public static void DoIterativeCrossValidation(
this IRecommender recommender,
ISplit<IPosOnlyFeedback> split,
IList<int> test_users,
IList<int> candidate_items,
CandidateItems candidate_item_mode,
RepeatedEvents repeated_events,
uint max_iter,
uint find_iter = 1,
bool show_fold_results = false)
{
if (!(recommender is IIterativeModel))
throw new ArgumentException("recommender must be of type IIterativeModel");
if (!(recommender is ItemRecommender))
throw new ArgumentException("recommender must be of type ItemRecommender");
var split_recommenders = new ItemRecommender[split.NumberOfFolds];
var iterative_recommenders = new IIterativeModel[split.NumberOfFolds];
var fold_results = new ItemRecommendationEvaluationResults[split.NumberOfFolds];
// initial training and evaluation
Parallel.For(0, (int) split.NumberOfFolds, i =>
{
try
{
split_recommenders[i] = (ItemRecommender) recommender.Clone(); // to avoid changes in recommender
split_recommenders[i].Feedback = split.Train[i];
split_recommenders[i].Train();
iterative_recommenders[i] = (IIterativeModel) split_recommenders[i];
fold_results[i] = Items.Evaluate(split_recommenders[i], split.Test[i], split.Train[i], test_users, candidate_items, candidate_item_mode, repeated_events);
if (show_fold_results)
Console.WriteLine("fold {0} {1} iteration {2}", i, fold_results, iterative_recommenders[i].NumIter);
}
catch (Exception e)
{
Console.Error.WriteLine("===> ERROR: " + e.Message + e.StackTrace);
throw;
}
});
Console.WriteLine("{0} iteration {1}", new ItemRecommendationEvaluationResults(fold_results), iterative_recommenders[0].NumIter);
// iterative training and evaluation
for (int it = (int) iterative_recommenders[0].NumIter + 1; it <= max_iter; it++)
{
Parallel.For(0, (int) split.NumberOfFolds, i =>
{
try
{
iterative_recommenders[i].Iterate();
if (it % find_iter == 0)
{
fold_results[i] = Items.Evaluate(split_recommenders[i], split.Test[i], split.Train[i], test_users, candidate_items, candidate_item_mode, repeated_events);
if (show_fold_results)
Console.WriteLine("fold {0} {1} iteration {2}", i, fold_results, it);
}
}
catch (Exception e)
{
Console.Error.WriteLine("===> ERROR: " + e.Message + e.StackTrace);
throw;
}
});
Console.WriteLine("{0} iteration {1}", new ItemRecommendationEvaluationResults(fold_results), it);
}
}
static void Main(string[] args)
{
Assembly assembly = Assembly.GetExecutingAssembly();
Assembly.LoadFile(Path.GetDirectoryName(assembly.Location) + Path.DirectorySeparatorChar + "MyMediaLiteExperimental.dll");
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(Handlers.UnhandledExceptionHandler);
Console.CancelKeyPress += new ConsoleCancelEventHandler(AbortHandler);
// check number of command line parameters
if (args.Length < 1)
Usage("Not enough arguments.");
// read command line parameters
string method = args[0];
RecommenderParameters parameters = null;
try { parameters = new RecommenderParameters(args, 1); }
catch (ArgumentException e) { Usage(e.Message); }
// arguments for iteration search
find_iter = parameters.GetRemoveInt32( "find_iter", 0);
max_iter = parameters.GetRemoveInt32( "max_iter", 500);
epsilon = parameters.GetRemoveDouble( "epsilon", 1);
err_cutoff = parameters.GetRemoveDouble( "err_cutoff", 2);
// data arguments
string data_dir = parameters.GetRemoveString( "data_dir");
if (data_dir != string.Empty)
data_dir = data_dir + "/mml-track2";
else
data_dir = "mml-track2";
sample_data = parameters.GetRemoveBool( "sample_data", false);
predict_rated = parameters.GetRemoveBool( "predict_rated", false);
predict_score = parameters.GetRemoveBool( "predict_score", false);
// other arguments
save_model_file = parameters.GetRemoveString( "save_model");
load_model_file = parameters.GetRemoveString( "load_model");
int random_seed = parameters.GetRemoveInt32( "random_seed", -1);
prediction_file = parameters.GetRemoveString( "prediction_file");
if (predict_rated)
predict_score = true;
Console.Error.WriteLine("predict_score={0}", predict_score);
if (random_seed != -1)
MyMediaLite.Util.Random.InitInstance(random_seed);
recommender_validate = Recommender.CreateItemRecommender(method);
if (recommender_validate == null)
Usage(string.Format("Unknown method: '{0}'", method));
Recommender.Configure(recommender_validate, parameters, Usage);
recommender_final = recommender_validate.Clone() as ItemRecommender;
if (parameters.CheckForLeftovers())
Usage(-1);
// load all the data
LoadData(data_dir);
if (load_model_file != string.Empty)
{
Recommender.LoadModel(recommender_validate, load_model_file + "-validate");
Recommender.LoadModel(recommender_final, load_model_file + "-final");
}
Console.Write(recommender_validate.ToString());
DoTrack2();
}
