public static void Main(string[] args)
{
// load the data
var training_data = RatingData.Read(args[0]);
var test_data = RatingData.Read(args[1]);
// set up the recommender
var recommender = new UserItemBaseline();
recommender.Ratings = training_data;
recommender.Train();
// measure the accuracy on the test data set
var results = recommender.Evaluate(test_data);
Console.WriteLine("RMSE={0} MAE={1}", results["RMSE"], results["MAE"]);
Console.WriteLine(results);
// make a prediction for a certain user and item
Console.WriteLine(recommender.Predict(1, 1));
var bmf = new BiasedMatrixFactorization {
Ratings = training_data
};
Console.WriteLine(bmf.DoCrossValidation());
}
public static void BiasedMatrixFactorizationTest()
{
List <Rating> baseRatings = Tools.GetRatings(BaseRatingFile, " ");
List <Rating> testRatings = Tools.GetRatings(TestRatingFile, " ");
BiasedMatrixFactorization model = new BiasedMatrixFactorization(MaxUserId, MaxItemId);
model.TrySGD(baseRatings, testRatings, 100, 0.005, 0.02, 0.98);
}
public void TestDefaultBehaviorIsNoDecay()
{
var mf = new BiasedMatrixFactorization()
{
LearnRate = 1.1f, NumIter = 10, Ratings = TestUtils.CreateRatings()
};
mf.Train();
Assert.AreEqual(1.1f, mf.current_learnrate);
}
public static void BiasedMatrixFactorizationTest(double testSize = 0.1)
{
List <Rating> ratings = Tools.GetRatings(RatingFile, ",");
var max = Tools.GetMaxUserIdAndItemId(ratings);
var maxUserId = max.Item1 + 1;
var maxItemId = max.Item2 + 1;
BiasedMatrixFactorization model = new BiasedMatrixFactorization(maxUserId, maxItemId);
var t = Tools.TrainTestSplit(ratings, testSize);
model.TrySGD(t.Item1, t.Item2, 100, 0.005);
}
public void TestCurrentLearnRate()
{
var mf = new BiasedMatrixFactorization()
{
LearnRate = 1.1f, Ratings = TestUtils.CreateRatings()
};
mf.InitModel();
Assert.AreEqual(1.1f, mf.LearnRate);
Assert.AreEqual(1.1f, mf.current_learnrate);
}
public static void BiasedMatrixFactorizationTest(double testSize = 0.1)
{
List <Rating> ratings = Tools.GetRatings(DefaultRatingFile, "::");
Tools.UpdateIndexesToZeroBased(ratings);
var t = Tools.TrainTestSplit(ratings, testSize);
BiasedMatrixFactorization model = new BiasedMatrixFactorization(MaxUserId, MaxItemId);
model.TrySGD(t.Item1, t.Item2, 100, 0.005);
}
public static void BiasedMatrixFactorizationTest()
{
List <Rating> baseRatings = Tools.GetRatings(BaseRatingFile);
List <Rating> testRatings = Tools.GetRatings(TestRatingFile);
Tools.UpdateIndexesToZeroBased(baseRatings);
Tools.UpdateIndexesToZeroBased(testRatings);
BiasedMatrixFactorization model = new BiasedMatrixFactorization(MaxUserId, MaxItemId);
model.TrySGD(baseRatings, testRatings, 100, 0.01, 0.01, 0.95);
}
// 2017.10.26
public static void BiasedMatrixFactorizationTopNTest(double testSize = 0.125)
{
List <Rating> ratings = Tools.GetRatings(DefaultRatingFile, "::");
Tools.UpdateIndexesToZeroBased(ratings);
var data = Tools.TrainTestSplit(ratings, testSize);
var baseSamples = Tools.RandomSelectNegativeSamples(data.Item1, 1, true);
BiasedMatrixFactorization model = new BiasedMatrixFactorization(MaxUserId, MaxItemId, 100);
model.TrySGDForTopN(baseSamples, data.Item2, 100, 0.02, 0.01, 0.9);
}
/// <summary>
/// Predict the rating of the item by users
/// </summary>
private static void PredictRating(string[] args)
{
Console.WriteLine("Predicting ratings for Users...");
String outputFile = Path.Combine(args[2], outputFileForRatings);
testingFile = Path.Combine(args[1], testingFile);
testingFileModified = Path.Combine(args[2], testingFileModified);
ModifyTestingFileForRating(testingFile, testingFileModified);
float minRating = 1;
float maxRating = 5;
var userMapping = new Mapping();
var itemMapping = new Mapping();
var trainingData = StaticRatingData.Read(trainingCompactFileForRatings, userMapping, itemMapping, RatingType.FLOAT, TestRatingFileFormat.WITH_RATINGS, false);
var testUsers = trainingData.AllUsers; // users that will be taken into account in the evaluation
var candidate_items = trainingData.AllItems; // items that will be taken into account in the evaluation
var testData = StaticRatingData.Read(testingFileModified, userMapping, itemMapping, RatingType.FLOAT, TestRatingFileFormat.WITH_RATINGS, false);
var recommender = new BiasedMatrixFactorization();
recommender.MinRating = minRating;
recommender.MaxRating = maxRating;
recommender.Ratings = trainingData;
recommender.NumFactors = 30;
recommender.NumIter = 100;
recommender.RegI = 0.04F;
recommender.RegU = 0.04F;
//recommender.BiasReg = 0.09F;
recommender.FrequencyRegularization = true;
recommender.BoldDriver = true;
recommender.LearnRate = 0.07F;
Stopwatch timeKeeper = new Stopwatch();
timeKeeper.Start();
recommender.Train();
timeKeeper.Stop();
Console.WriteLine("time passed for training rating prediction model: " + timeKeeper.ElapsedMilliseconds);
// measure the accuracy on the test data set
timeKeeper = new Stopwatch();
timeKeeper.Start();
var results = recommender.Evaluate(testData);
timeKeeper.Stop();
Console.WriteLine("time passed for rating prediction: " + timeKeeper.ElapsedMilliseconds);
Console.WriteLine("RMSE={0}", results["RMSE"]);
recommender.WritePredictions(testData, outputFile, userMapping, itemMapping, "{0}-{1},{2}", "userID-itemID,rating");
}
public void TestMatrixInit()
{
var mf = new BiasedMatrixFactorization()
{
Ratings = TestUtils.CreateRatings()
};
mf.InitModel();
Assert.IsNotNull(mf.user_factors);
Assert.IsNotNull(mf.item_factors);
Assert.IsNotNull(mf.user_bias);
Assert.IsNotNull(mf.item_bias);
}
public void TestDecay()
{
var mf = new BiasedMatrixFactorization()
{
LearnRate = 1.0f, Decay = 0.5f,
NumIter = 1, Ratings = TestUtils.CreateRatings()
};
mf.Train();
Assert.AreEqual(0.5f, mf.current_learnrate);
mf.Iterate();
Assert.AreEqual(0.25f, mf.current_learnrate);
}
public void TestIncrementalUpdates()
{
var mf = new BiasedMatrixFactorization()
{
Ratings = TestUtils.CreateRatings(), FrequencyRegularization = true
};
mf.Train();
var new_ratings = new Ratings();
new_ratings.Add(mf.MaxUserID + 1, mf.MaxItemID + 1, 3f);
mf.AddRatings(new_ratings);
}
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 MatrixFactorization_IJCAI2018_Test2()
{
double testSize = 0.2;
List <Rating> ratings = Tools.GetRatings(@"D:\data\ijcai2018task\ex\train.shop.csv", ",");
var data = Tools.TrainTestSplit(ratings, testSize);
var max = Tools.GetMaxUserIdAndItemId(ratings);
Tools.WriteRatings(data.Item1, @"D:\data\ijcai2018task\ex\train.shop.1.csv");
Tools.WriteRatings(data.Item2, @"D:\data\ijcai2018task\ex\train.shop.2.csv");
BiasedMatrixFactorization model = new BiasedMatrixFactorization(max.Item1 + 1, max.Item2 + 1, 100);
model.TrySGD(data.Item1, data.Item2, 100, 0.01, 0.01, 0.94, 0, 1);
}
public void TestFoldIn()
{
var mf = new BiasedMatrixFactorization()
{
Ratings = TestUtils.CreateRatings()
};
mf.Train();
var user_ratings = new List <Tuple <int, float> >();
user_ratings.Add(new Tuple <int, float>(0, 4.0f));
var candidate_items = new List <int> {
0, 1
}; // have a known and an unknown item
var results = mf.ScoreItems(user_ratings, candidate_items);
Assert.AreEqual(2, results.Count);
}
public static void BiasedMatrixFactorization(Dictionary <string, string> pairs)
{
string separator = "\t";
if (pairs.Keys.Contains("separator"))
{
separator = pairs["separator"];
}
List <Rating> baseRatings = Tools.GetRatings(pairs["train"], separator);
List <Rating> testRatings = Tools.GetRatings(pairs["test"], separator);
int maxUserId = System.Math.Max(baseRatings.Max(r => r.UserId), testRatings.Max(r => r.UserId));
int maxItemId = System.Math.Max(baseRatings.Max(r => r.ItemId), testRatings.Max(r => r.ItemId));
Tools.UpdateIndexesToZeroBased(baseRatings);
Tools.UpdateIndexesToZeroBased(testRatings);
int f = 10;
if (pairs.Keys.Contains("f"))
{
f = Int32.Parse(pairs["f"]);
}
int epochs = 100;
if (pairs.Keys.Contains("epochs"))
{
epochs = Int32.Parse(pairs["epochs"]);
}
double gamma = 0.01;
if (pairs.Keys.Contains("gamma"))
{
gamma = Double.Parse(pairs["gamma"]);
}
double lambda = 0.01;
if (pairs.Keys.Contains("lambda"))
{
lambda = Double.Parse(pairs["lambda"]);
}
double min_rating = 1.0;
if (pairs.Keys.Contains("min_rating"))
{
min_rating = Double.Parse(pairs["min_rating"]);
}
double max_rating = 5.0;
if (pairs.Keys.Contains("max_rating"))
{
max_rating = Double.Parse(pairs["max_rating"]);
}
BiasedMatrixFactorization model = new BiasedMatrixFactorization(maxUserId, maxItemId, f);
model.TrySGD(baseRatings, testRatings, epochs, gamma, lambda, min_rating, max_rating);
}
