public static void Main(string[] args)
{
Assembly assembly = Assembly.GetExecutingAssembly();
Assembly.LoadFile(Path.GetDirectoryName(assembly.Location) + Path.DirectorySeparatorChar + "MyMediaLiteExperimental.dll");
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(MyMediaLite.Util.Handlers.UnhandledExceptionHandler);
Console.CancelKeyPress += new ConsoleCancelEventHandler(AbortHandler);
// recommender arguments
string method = "MostPopular";
string recommender_options = string.Empty;
// help/version
bool show_help = false;
bool show_version = false;
// variables for iteration search
int find_iter = 0;
int max_iter = 500;
double auc_cutoff = 0;
double prec5_cutoff = 0;
compute_fit = false;
// other parameters
string save_model_file = string.Empty;
string load_model_file = string.Empty;
int random_seed = -1;
string prediction_file = string.Empty;
test_ratio = 0;
var p = new OptionSet()
{
// string-valued options
{ "training-file=", v => training_file = v },
{ "test-file=", v => test_file = v },
{ "recommender=", v => method = v },
{ "recommender-options=", v => recommender_options += " " + v },
{ "data-dir=", v => data_dir = v },
{ "user-attributes=", v => user_attributes_file = v },
{ "item-attributes=", v => item_attributes_file = v },
{ "user-relations=", v => user_relations_file = v },
{ "item-relations=", v => item_relations_file = v },
{ "save-model=", v => save_model_file = v },
{ "load-model=", v => load_model_file = v },
{ "prediction-file=", v => prediction_file = v },
{ "relevant-users=", v => relevant_users_file = v },
{ "relevant-items=", v => relevant_items_file = v },
// integer-valued options
{ "find-iter=", (int v) => find_iter = v },
{ "max-iter=", (int v) => max_iter = v },
{ "random-seed=", (int v) => random_seed = v },
{ "predict-items-number=", (int v) => predict_items_number = v },
// double-valued options
// { "epsilon=", (double v) => epsilon = v },
{ "auc-cutoff=", (double v) => auc_cutoff = v },
{ "prec5-cutoff=", (double v) => prec5_cutoff = v },
{ "test-ratio=", (double v) => test_ratio = v },
// enum options
// * currently none *
// boolean options
{ "compute-fit", v => compute_fit = v != null },
{ "online-evaluation", v => online_eval = v != null },
{ "filtered-evaluation", v => filtered_eval = v != null },
{ "help", v => show_help = v != null },
{ "version", v => show_version = v != null },
};
IList <string> extra_args = p.Parse(args);
if (show_version)
{
ShowVersion();
}
if (show_help)
{
Usage(0);
}
bool no_eval = test_file == null;
if (training_file == null)
{
Usage("Parameter --training-file=FILE is missing.");
}
if (extra_args.Count > 0)
{
Usage("Did not understand " + extra_args[0]);
}
if (online_eval && filtered_eval)
{
Usage("Combination of --online-eval and --filtered-eval is not (yet) supported.");
}
if (random_seed != -1)
{
MyMediaLite.Util.Random.InitInstance(random_seed);
}
recommender = Recommender.CreateItemRecommender(method);
if (recommender == null)
{
Usage(string.Format("Unknown method: '{0}'", method));
}
Recommender.Configure(recommender, recommender_options, Usage);
// load all the data
LoadData();
Utils.DisplayDataStats(training_data, test_data, recommender);
TimeSpan time_span;
if (find_iter != 0)
{
var iterative_recommender = (IIterativeModel)recommender;
Console.WriteLine(recommender.ToString() + " ");
if (load_model_file == string.Empty)
{
iterative_recommender.Train();
}
else
{
Recommender.LoadModel(iterative_recommender, load_model_file);
}
if (compute_fit)
{
Console.Write(string.Format(CultureInfo.InvariantCulture, "fit {0,0:0.#####} ", iterative_recommender.ComputeFit()));
}
var result = Evaluate();
Items.DisplayResults(result);
Console.WriteLine(" iteration " + iterative_recommender.NumIter);
for (int i = (int)iterative_recommender.NumIter + 1; i <= max_iter; i++)
{
TimeSpan t = Utils.MeasureTime(delegate() {
iterative_recommender.Iterate();
});
training_time_stats.Add(t.TotalSeconds);
if (i % find_iter == 0)
{
if (compute_fit)
{
double fit = 0;
t = Utils.MeasureTime(delegate() { fit = iterative_recommender.ComputeFit(); });
fit_time_stats.Add(t.TotalSeconds);
Console.Write(string.Format(CultureInfo.InvariantCulture, "fit {0,0:0.#####} ", fit));
}
t = Utils.MeasureTime(delegate() { result = Evaluate(); });
eval_time_stats.Add(t.TotalSeconds);
Items.DisplayResults(result);
Console.WriteLine(" iteration " + i);
Recommender.SaveModel(recommender, save_model_file, i);
Predict(prediction_file, relevant_users_file, i);
if (result["AUC"] < auc_cutoff || result["prec@5"] < prec5_cutoff)
{
Console.Error.WriteLine("Reached cutoff after {0} iterations.", i);
Console.Error.WriteLine("DONE");
break;
}
}
} // for
DisplayStats();
}
else
{
if (load_model_file == string.Empty)
{
Console.Write(recommender.ToString() + " ");
time_span = Utils.MeasureTime(delegate() { recommender.Train(); });
Console.Write("training_time " + time_span + " ");
}
else
{
Recommender.LoadModel(recommender, load_model_file);
Console.Write(recommender.ToString() + " ");
// TODO is this the right time to load the model?
}
if (prediction_file != string.Empty)
{
Predict(prediction_file, relevant_users_file);
}
else if (!no_eval)
{
if (online_eval)
{
time_span = Utils.MeasureTime(delegate() {
var result = Items.EvaluateOnline(recommender, test_data, training_data, relevant_users, relevant_items); // TODO support also for prediction outputs (to allow external evaluation)
Items.DisplayResults(result);
});
}
else
{
time_span = Utils.MeasureTime(delegate() {
var result = Evaluate();
Items.DisplayResults(result);
});
}
Console.Write(" testing_time " + time_span);
}
Console.WriteLine();
}
Recommender.SaveModel(recommender, save_model_file);
}
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();
}