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))); }