public static DataMatrix PredictRatings(DataMatrix R_train, DataMatrix R_unknown,
int maxEpoch, double learnRate, double regularization, int factorCount)
{
int userCount = R_train.UserCount;
int itemCount = R_train.ItemCount;
int ratingCount = R_train.NonZerosCount;
double meanOfGlobal = R_train.GetGlobalMean();
DataMatrix R_train_unknown = R_train.IndexesOfNonZeroElements(); // For testing convergence
// User latent vectors with default seed
Matrix<double> P = Utils.CreateRandomMatrixFromNormal(userCount, factorCount, 0, 0.1, Config.Seed);
// Matrix<double> P = Utils.CreateRandomMatrixFromUniform(userCount, factorCount, 0, 0.1, Config.Seed);
// Item latent vectors with a different seed
Matrix<double> Q = Utils.CreateRandomMatrixFromNormal(factorCount, itemCount, 0, 0.1, Config.Seed + 1);
//Matrix<double> Q = Utils.CreateRandomMatrixFromUniform(factorCount, itemCount, 0, 0.1, Config.Seed + 1);
// SGD
double e_prev = double.MaxValue;
for (int epoch = 0; epoch < maxEpoch; ++epoch)
{
foreach (Tuple<int, int, double> element in R_train.Ratings)
{
int indexOfUser = element.Item1;
int indexOfItem = element.Item2;
double rating = element.Item3;
double e_ij = rating - (meanOfGlobal + P.Row(indexOfUser).DotProduct(Q.Column(indexOfItem)));
// Update feature vectors
Vector<double> P_u = P.Row(indexOfUser);
Vector<double> Q_i = Q.Column(indexOfItem);
Vector<double> P_u_updated = P_u + (Q_i.Multiply(e_ij) - P_u.Multiply(regularization)).Multiply(learnRate);
P.SetRow(indexOfUser, P_u_updated);
Vector<double> Q_i_updated = Q_i + (P_u.Multiply(e_ij) - Q_i.Multiply(regularization)).Multiply(learnRate);
Q.SetColumn(indexOfItem, Q_i_updated);
#region Update feature vectors loop version
/*
// Update feature vectors
for (int k = 0; k < factorCount; ++k)
{
double factorOfUser = P[indexOfUser, k];
double factorOfItem = Q[k, indexOfItem];
P[indexOfUser, k] += learnRate * (e_ij * factorOfItem - regularization * factorOfUser);
Q[k, indexOfItem] += learnRate * (e_ij * factorOfUser - regularization * factorOfItem);
}
*/
#endregion
}
// Display the current regularized error see if it converges
double e_curr = 0;
if (epoch == 0 || epoch == maxEpoch - 1 || epoch % (int)Math.Ceiling(maxEpoch * 0.1) == 4)
{
Matrix<double> predictedMatrix = R_train_unknown.PointwiseMultiply(P.Multiply(Q));
SparseMatrix correctMatrix = R_train.Matrix;
double squaredError = (correctMatrix - predictedMatrix).SquaredSum();
double regularizationPenaty = regularization * (P.SquaredSum() + Q.SquaredSum());
double objective = squaredError + regularizationPenaty;
#region Linear implementation
/*
double e = 0;
foreach (Tuple<int, int, double> element in R_train.Ratings)
{
int indexOfUser = element.Item1;
int indexOfItem = element.Item2;
double rating = element.Item3;
e += Math.Pow(rating - P.Row(indexOfUser).DotProduct(Q.Column(indexOfItem)), 2);
for (int k = 0; k < factorCount; ++k)
{
e += (regularization / 2) * (Math.Pow(P[indexOfUser, k], 2) + Math.Pow(Q[k, indexOfItem], 2));
}
}
*/
#endregion
// Record the current error
e_curr = objective;
// Stop the learning if the regularized error falls below a certain threshold
if (e_prev - e_curr < 0.001)
{
Console.WriteLine("Improvment less than 0.001, learning stopped.");
break;
}
e_prev = e_curr;
Utils.PrintEpoch("Epoch", epoch, maxEpoch, "Objective cost", objective);
}
}
SparseMatrix R_predicted = new SparseMatrix(R_unknown.UserCount, R_unknown.ItemCount);
foreach(var element in R_unknown.Matrix.EnumerateIndexed(Zeros.AllowSkip))
{
int indexOfUser = element.Item1;
int indexOfItem = element.Item2;
double r_predicted = meanOfGlobal + P.Row(indexOfUser) * Q.Column(indexOfItem);
if (r_predicted > Config.Ratings.MaxRating) r_predicted = Config.Ratings.MaxRating;
if (r_predicted < Config.Ratings.MinRating) r_predicted = Config.Ratings.MinRating;
R_predicted[indexOfUser, indexOfItem] = r_predicted;
}
return new DataMatrix(R_predicted);
//return new RatingMatrix(R_unknown.PointwiseMultiply(P.Multiply(Q)));
}
