public void ItemRecommenderTestsInit()
{
if (_itemRecommender == null)
{
_itemRecommender = new ItemRecommender(Config["Values:MLserviceUrl"],
Config["Values:ProductAPIServiceURL"],
Config["Values:MLServiceBearerToken"]);
}
}
/// <summary>Computes the AUC fit of a recommender on the training data</summary>
/// <returns>the AUC on the training data</returns>
/// <param name='recommender'>the item recommender to evaluate</param>
/// <param name="test_users">a list of integers with all test users; if null, use all users in the test cases</param>
/// <param name="candidate_items">a list of integers with all candidate items</param>
/// <param name="candidate_item_mode">the mode used to determine the candidate items</param>
public static double ComputeFit(
this ItemRecommender recommender,
IList <int> test_users = null,
IList <int> candidate_items = null,
CandidateItems candidate_item_mode = CandidateItems.OVERLAP)
{
return(recommender.Evaluate(
recommender.Feedback, recommender.Feedback,
test_users, candidate_items,
candidate_item_mode, RepeatedEvents.Yes)["AUC"]);
}
public async Task GetRecommendationTest()
{
var dbConnectionString = Config["Values:DBConnectionString"];
var productAPIuri = Config["Values:ProductAPIServiceURL"];
var recommendationContext = new ItemRecommender(dbConnectionString, "product_data", productAPIuri);
var items = await recommendationContext.GetRecommendation("568793129");
foreach (var item in items)
{
Console.WriteLine(JsonConvert.SerializeObject(item));
}
}
public async Task GetRecommendationTest()
{
var serviceuri = Config["Values:CosmosCoreAPIUri"];
var accesskey = Config["Values:CosmosCoreAccessKey"];
var dbName = Config["Values:CosmosDatabaseName"];
var productAPIuri = Config["Values:ProductAPIServiceURL"];
var cosmosSettings = new CosmosStoreSettings(dbName,
serviceuri,
accesskey);
ICosmosStore <Models.Recommendations> recommendation = new CosmosStore <Models.Recommendations>(cosmosSettings);
var recommendationContext = new ItemRecommender(recommendation, productAPIuri);
var items = await recommendationContext.GetRecommendation("568793129");
foreach (var item in items)
{
Console.WriteLine(JsonConvert.SerializeObject(item));
}
}
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();
}
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();
}
public MediaLiteItemRecommender(ItemRecommender itemRecommender)
: this(itemRecommender, -1)
{
}
public GetRecommendationUsers(ItemRecommender itemRecommender)
{
_itemRecommender = itemRecommender;
}
/// <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>
static public 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);
}
}
public MediaLitePosFeedbakItemRecommender(ItemRecommender itemRecommender)
: this(itemRecommender, -1)
{
}
