private void CreateRecommender()
{
BiasedMatrixFactorization recommender = new BiasedMatrixFactorization();
Console.Error.Write("Reading in ratings ... ");
TimeSpan time = Utils.MeasureTime(delegate() {
recommender.Ratings = RatingPrediction.Read(ratings_file, user_mapping, item_mapping);
});
Console.Error.WriteLine("done ({0,0:0.##}).", time.TotalSeconds.ToString(CultureInfo.InvariantCulture));
//Console.Error.Write("Reading in additional ratings ... ");
//string[] rating_files = Directory.GetFiles("../../saved_data/", "user-ratings-*");
//Console.Error.WriteLine("done.");
foreach (var indices_for_item in recommender.Ratings.ByItem)
{
if (indices_for_item.Count > 0)
{
movies_by_frequency.Add(new WeightedItem(recommender.Ratings.Items[indices_for_item[0]], indices_for_item.Count));
}
}
movies_by_frequency.Sort();
movies_by_frequency.Reverse();
for (int i = 0; i < n_movies; i++)
{
top_n_movies.Add(movies_by_frequency[i].item_id);
}
Console.Error.Write("Loading prediction model ... ");
recommender.UpdateUsers = true;
recommender.UpdateItems = false;
recommender.BiasReg = 0.001;
recommender.Regularization = 0.045;
recommender.NumIter = 60;
time = Utils.MeasureTime(delegate() {
recommender.LoadModel(model_file);
});
Console.Error.WriteLine("done ({0,0:0.##}).", time.TotalSeconds.ToString(CultureInfo.InvariantCulture));
rating_predictor = recommender;
current_user_id = user_mapping.ToInternalID(current_user_external_id);
//rating_predictor.AddUser(current_user_id);
// add movies that were not in the training set
//rating_predictor.AddItem( item_mapping.InternalIDs.Count - 1 );
PredictAllRatings();
}
public static void Main(string[] args)
{
// load the data
var user_mapping = new EntityMapping();
var item_mapping = new EntityMapping();
var training_data = ItemRecommendation.Read(args[0], user_mapping, item_mapping);
var relevant_users = training_data.AllUsers; // users that will be taken into account in the evaluation
var relevant_items = training_data.AllItems; // items that will be taken into account in the evaluation
var test_data = ItemRecommendation.Read(args[1], user_mapping, item_mapping);
// set up the recommender
var recommender = new MostPopular();
recommender.Feedback = training_data;
recommender.Train();
// measure the accuracy on the test data set
var results = ItemPredictionEval.Evaluate(recommender, test_data, training_data, relevant_users, relevant_items);
foreach (var key in results.Keys)
{
Console.WriteLine("{0}={1}", key, results[key]);
}
// make a prediction for a certain user and item
Console.WriteLine(recommender.Predict(user_mapping.ToInternalID(1), item_mapping.ToInternalID(1)));
}
/// <summary>Read movie data from a StreamReader</summary>
/// <param name="reader">a StreamReader to be read from</param>
/// <param name="item_mapping">ID mapping for the movies</param>
public void Read(StreamReader reader, EntityMapping item_mapping)
{
movie_list = new List <Movie>();
IMDB_KEY_To_ID = new Dictionary <string, int>();
var separators = new string[] { "::" };
string line;
while (!reader.EndOfStream)
{
line = reader.ReadLine();
string[] tokens = line.Split(separators, StringSplitOptions.None);
if (tokens.Length != 3)
{
throw new IOException("Expected exactly three columns: " + line);
}
int movie_id = item_mapping.ToInternalID(int.Parse(tokens[0]));
string movie_imdb_key = tokens[1];
//string[] movie_genres = tokens[2].Split('|');
// TODO
int movie_year = 1900;
string movie_title = movie_imdb_key;
movie_list.Add(new Movie(movie_id, movie_title, movie_year, movie_imdb_key));
IMDB_KEY_To_ID[movie_imdb_key] = movie_id;
}
}
Read(IDataReader reader, EntityMapping user_mapping, EntityMapping item_mapping)
{
var ratings = new Ratings();
if (reader.FieldCount < 3)
{
throw new IOException("Expected at least three columns.");
}
while (reader.Read())
{
int user_id = user_mapping.ToInternalID(reader.GetInt32(0));
int item_id = item_mapping.ToInternalID(reader.GetInt32(1));
double rating = reader.GetDouble(2);
ratings.Add(user_id, item_id, rating);
}
return(ratings);
}
public static void Main(string[] args)
{
// load the data
var user_mapping = new EntityMapping();
var item_mapping = new EntityMapping();
var training_data = MyMediaLite.IO.RatingPrediction.Read(args[0], user_mapping, item_mapping);
var test_data = MyMediaLite.IO.RatingPrediction.Read(args[1], user_mapping, item_mapping);
// set up the recommender
var recommender = new UserItemBaseline();
recommender.Ratings = training_data;
recommender.Train();
// measure the accuracy on the test data set
var results = RatingEval.Evaluate(recommender, test_data);
Console.WriteLine("RMSE={0} MAE={1}", results["RMSE"], results["MAE"]);
// make a prediction for a certain user and item
Console.WriteLine(recommender.Predict(user_mapping.ToInternalID(1), item_mapping.ToInternalID(1)));
}
public static void Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(Handlers.UnhandledExceptionHandler);
// check number of command line parameters
if (args.Length < 4)
{
Usage("Not enough arguments.");
}
// read command line parameters
RecommenderParameters parameters = null;
try { parameters = new RecommenderParameters(args, 4); }
catch (ArgumentException e) { Usage(e.Message); }
// other parameters
string data_dir = parameters.GetRemoveString("data_dir");
string relevant_items_file = parameters.GetRemoveString("relevant_items");
string item_attributes_file = parameters.GetRemoveString("item_attributes");
string user_attributes_file = parameters.GetRemoveString("user_attributes");
//string save_mapping_file = parameters.GetRemoveString( "save_model");
int random_seed = parameters.GetRemoveInt32("random_seed", -1);
bool no_eval = parameters.GetRemoveBool("no_eval", false);
bool compute_fit = parameters.GetRemoveBool("compute_fit", false);
if (random_seed != -1)
{
MyMediaLite.Util.Random.InitInstance(random_seed);
}
// main data files and method
string trainfile = args[0].Equals("-") ? "-" : Path.Combine(data_dir, args[0]);
string testfile = args[1].Equals("-") ? "-" : Path.Combine(data_dir, args[1]);
string load_model_file = args[2];
string method = args[3];
// set correct recommender
switch (method)
{
case "BPR-MF-ItemMapping":
recommender = Recommender.Configure(bprmf_map, parameters, Usage);
break;
case "BPR-MF-ItemMapping-Optimal":
recommender = Recommender.Configure(bprmf_map_bpr, parameters, Usage);
break;
case "BPR-MF-ItemMapping-Complex":
recommender = Recommender.Configure(bprmf_map_com, parameters, Usage);
break;
case "BPR-MF-ItemMapping-kNN":
recommender = Recommender.Configure(bprmf_map_knn, parameters, Usage);
break;
case "BPR-MF-ItemMapping-SVR":
recommender = Recommender.Configure(bprmf_map_svr, parameters, Usage);
break;
case "BPR-MF-UserMapping":
recommender = Recommender.Configure(bprmf_user_map, parameters, Usage);
break;
case "BPR-MF-UserMapping-Optimal":
recommender = Recommender.Configure(bprmf_user_map_bpr, parameters, Usage);
break;
default:
Usage(string.Format("Unknown method: '{0}'", method));
break;
}
if (parameters.CheckForLeftovers())
{
Usage(-1);
}
// ID mapping objects
var user_mapping = new EntityMapping();
var item_mapping = new EntityMapping();
// training data
training_data = ItemRecommendation.Read(Path.Combine(data_dir, trainfile), user_mapping, item_mapping);
recommender.Feedback = training_data;
// relevant items
if (!relevant_items_file.Equals(string.Empty))
{
relevant_items = new HashSet <int>(item_mapping.ToInternalID(Utils.ReadIntegers(Path.Combine(data_dir, relevant_items_file))));
}
else
{
relevant_items = training_data.AllItems;
}
// user attributes
if (recommender is IUserAttributeAwareRecommender)
{
if (user_attributes_file.Equals(string.Empty))
{
Usage("Recommender expects user_attributes=FILE.");
}
else
{
((IUserAttributeAwareRecommender)recommender).UserAttributes = AttributeData.Read(Path.Combine(data_dir, user_attributes_file), user_mapping);
}
}
// item attributes
if (recommender is IItemAttributeAwareRecommender)
{
if (item_attributes_file.Equals(string.Empty))
{
Usage("Recommender expects item_attributes=FILE.");
}
else
{
((IItemAttributeAwareRecommender)recommender).ItemAttributes = AttributeData.Read(Path.Combine(data_dir, item_attributes_file), item_mapping);
}
}
// test data
test_data = ItemRecommendation.Read(Path.Combine(data_dir, testfile), user_mapping, item_mapping);
TimeSpan seconds;
Recommender.LoadModel(recommender, load_model_file);
// set the maximum user and item IDs in the recommender - this is important for the cold start use case
recommender.MaxUserID = user_mapping.InternalIDs.Max();
recommender.MaxItemID = item_mapping.InternalIDs.Max();
DisplayDataStats();
Console.Write(recommender.ToString() + " ");
if (compute_fit)
{
seconds = Utils.MeasureTime(delegate() {
int num_iter = recommender.NumIterMapping;
recommender.NumIterMapping = 0;
recommender.LearnAttributeToFactorMapping();
Console.Error.WriteLine();
Console.Error.WriteLine(string.Format(CultureInfo.InvariantCulture, "iteration {0} fit {1}", -1, recommender.ComputeFit()));
recommender.NumIterMapping = 1;
for (int i = 0; i < num_iter; i++, i++)
{
recommender.IterateMapping();
Console.Error.WriteLine(string.Format(CultureInfo.InvariantCulture, "iteration {0} fit {1}", i, recommender.ComputeFit()));
}
recommender.NumIterMapping = num_iter; // restore
});
}
else
{
seconds = Utils.MeasureTime(delegate() {
recommender.LearnAttributeToFactorMapping();
});
}
Console.Write("mapping_time " + seconds + " ");
if (!no_eval)
{
seconds = EvaluateRecommender(recommender, test_data, training_data);
}
Console.WriteLine();
}
