public static void MatrixFactorizationTest()
{
List <Rating> baseRatings = Tools.GetRatings(BaseRatingFile, " ");
List <Rating> testRatings = Tools.GetRatings(TestRatingFile, " ");
MatrixFactorization model = new MatrixFactorization(MaxUserId, MaxItemId);
model.TrySGD(baseRatings, testRatings, 100, 0.005, 0.02, 0.98);
}
public void TestDefaultBehaviorIsNoDecay()
{
var mf = new MatrixFactorization()
{
LearnRate = 1.1f, NumIter = 10, Ratings = TestUtils.CreateRatings()
};
mf.Train();
Assert.AreEqual(1.1f, mf.current_learnrate);
}
// Algorithm testing
public static void MatrixFactorizationTest(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;
MatrixFactorization model = new MatrixFactorization(maxUserId, maxItemId);
var t = Tools.TrainTestSplit(ratings, testSize);
model.TrySGD(t.Item1, t.Item2, 100);
}
public void TestMatrixInit()
{
var mf = new MatrixFactorization()
{
Ratings = TestUtils.CreateRatings()
};
mf.InitModel();
Assert.IsNotNull(mf.user_factors);
Assert.IsNotNull(mf.item_factors);
}
public void TestCurrentLearnRate()
{
var mf = new MatrixFactorization()
{
LearnRate = 1.1f, Ratings = TestUtils.CreateRatings()
};
mf.InitModel();
Assert.AreEqual(1.1f, mf.LearnRate);
Assert.AreEqual(1.1f, mf.current_learnrate);
}
public static void MatrixFactorizationTest(double testSize = 0.2)
{
List <Rating> ratings = Tools.GetRatings(DefaultRatingFile, "::");
Tools.UpdateIndexesToZeroBased(ratings);
var t = Tools.TrainTestSplit(ratings, testSize);
MatrixFactorization model = new MatrixFactorization(MaxUserId, MaxItemId);
model.TrySGD(t.Item1, t.Item2, 100, 0.005);
}
// Algorithm testing
public static void MatrixFactorizationTest()
{
List <Rating> baseRatings = Tools.GetRatings(BaseRatingFile);
List <Rating> testRatings = Tools.GetRatings(TestRatingFile);
Tools.UpdateIndexesToZeroBased(baseRatings);
Tools.UpdateIndexesToZeroBased(testRatings);
MatrixFactorization model = new MatrixFactorization(MaxUserId, MaxItemId);
model.TrySGD(baseRatings, testRatings, 100);
}
public static void MatrixFactorizationTopNTest(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);
MatrixFactorization model = new MatrixFactorization(MaxUserId, MaxItemId, 100);
model.TrySGDForTopN(baseSamples, data.Item2, 100, 0.02, 0.01, 0.9);
}
IFoldInRatingPredictor CreateRecommender()
{
var training_data = RatingData.Read("../../../../data/ml-100k/u.data");
var recommender = new MatrixFactorization();
recommender.Ratings = training_data;
recommender.NumFactors = 4;
recommender.NumIter = 5;
recommender.Train();
return(recommender);
}
public static void MatrixFactorizationTopNTest(int f = 10)
{
List <Rating> baseRatings = Tools.GetRatings(BaseRatingFile);
List <Rating> testRatings = Tools.GetRatings(TestRatingFile);
Tools.UpdateIndexesToZeroBased(baseRatings);
Tools.UpdateIndexesToZeroBased(testRatings);
var baseSamples = Tools.RandomSelectNegativeSamples(baseRatings, 4, true);
MatrixFactorization model = new MatrixFactorization(MaxUserId, MaxItemId, f);
model.TrySGDForTopN(baseSamples, testRatings, 100, 0.02, 0.01, 0.9);
}
public void TestExplicitTrust()
{
//var socialReguls = new float[] { 0.1F, 0.2F, 0.5F, 0.8F, 1F, 1.5F, 2F, 3F, 5F};
//var numFactors = new uint[] {2, 5, 10, 15, 20};
var socialReguls = new float[] { 1 };
var numFactors = new uint[] { 5, 10 };
// step 1: dataset
var config = new CsvConfiguration();
config.Delimiter = " ";
var trainReader = new CsvReader <ItemRating>(Paths.EpinionTrain75, config, new ItemRatingMap());
var testReader = new CsvReader <ItemRating>(Paths.EpinionTest25, config, new ItemRatingMap());
var dataset = new Dataset <ItemRating>(trainReader, testReader);
var relations = File.ReadAllLines(Paths.EpinionRelations).ToCsvDictionary(' ')
.Select(i => new Relation()
{
UserId = i["UserId"], ConnectedId = i["ConnectionId"], DatasetId = 1
});
foreach (uint num in numFactors)
{
string rmseValues = "", maeValues = "";
foreach (float regul in socialReguls)
{
// step 2: recommender
var algorithm = new MatrixFactorization();
algorithm.NumFactors = num;
//algorithm.SocialRegularization = regul;
var recommender = new MediaLiteRatingPredictor(algorithm, relations);
// step3: evaluation
var context = new EvalutationContext <ItemRating>(recommender, dataset);
var ep = new EvaluationPipeline <ItemRating>(context);
ep.Evaluators.Add(new RMSE());
ep.Evaluators.Add(new MAE());
ep.Run();
rmseValues += context["RMSE"] + "\t";
maeValues += context["MAE"] + "\t";
}
Console.WriteLine(num + "\t" + rmseValues + "\t" + maeValues);
}
}
public void TestDecay()
{
var mf = new MatrixFactorization()
{
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 TestMovieLensSingleDomain()
{
int numDomains = 1;
// load data
var movieLensReader = new MovieLensCrossDomainReader(Paths.MovieLens1MMovies, Paths.MovieLens1M);
var container = new MovieLensCrossDomainContainer(numDomains);
movieLensReader.LoadData(container);
// set taget and active domains
var targetDomain = container.SpecifyTargetDomain("ml0");
container.PrintStatistics();
var startTime = DateTime.Now;
var splitter = new CrossDomainSimpleSplitter(container, 0.25f);
// recommender with non-CrossDomain feature builder
var model = new MatrixFactorization();
model.NumIter = 50;
model.NumFactors = 8;
model.Regularization = 0.1f;
//var recommender = new MediaLiteRatingPredictor(model);
var recommender = new LibFmTrainTester();
// evaluation
var ctx = new EvalutationContext <ItemRating>(recommender, splitter);
var ep = new EvaluationPipeline <ItemRating>(ctx);
ep.Evaluators.Add(new RMSE());
ep.Evaluators.Add(new MAE());
ep.Run();
var duration = (int)DateTime.Now.Subtract(startTime).TotalMilliseconds;
Console.WriteLine("RMSE\tDuration\n{0}\t{1}", ctx["RMSE"], duration);
//container.CreateClusterFiles(Paths.MovieLens1M.GetDirectoryPath() + "\\movies.clust.raw", Paths.MovieLens1M.GetDirectoryPath() + "\\movies.clust.feat");
//container.WriteClusters(Paths.MovieLens1M.GetDirectoryPath() + "\\movies.clust");
}
/// <summary>Initializes a new instance of the <see cref="LapackNativeWrapper" /> class.
/// </summary>
public LapackNativeWrapper()
{
Name = LongName = new IdentifierString("LAPACK");
LinearEquations = new LapackLinearEquations(
MatrixConditionalNumbers.Create(),
MatrixEquilibration.Create(),
MatrixFactorization.Create(),
MatrixInversion.Create(),
Solver.Create(),
ErrorEstimationSolver.Create());
EigenValues = new LapackEigenvalues(
GeneralizedNonsymmetricEigenvalueProblems.Create(),
GeneralizedSymmetricEigenvalueProblems.Create(),
NonSymmetricEigenvalueProblems.Create(),
SymmetricEigenvalueProblems.Create(),
SingularValueDecomposition.Create(),
GeneralizedSingularValueDecomposition.Create(),
LinearLeastSquaresProblems.Create());
AuxiliaryRoutines = new LapackAuxiliaryUtilityRoutines(AuxiliaryUtilityRoutines.Create());
}
public static void MatrixFactorization(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"]);
}
MatrixFactorization model = new MatrixFactorization(maxUserId, maxItemId, f);
model.TrySGD(baseRatings, testRatings, epochs, gamma, lambda, min_rating, max_rating);
}
