RSNMF recommender for rating prediction

src/MyMediaLite/DataType/MatrixExtensions.cs

@@ -1,3 +1,4 @@
+// Copyright (C) 2015 Zeno Gantner, Dimitris Paraschakis
 // Copyright (C) 2011, 2012 Zeno Gantner
 // Copyright (C) 2010 Steffen Rendle, Zeno Gantner
 //
@@ -68,6 +69,22 @@ static public void InitNormal(this Matrix<float> matrix, double mean, double std
 				matrix.data[i] = (float) nd.Sample();
 		}
 
+	        // Initializes a float matrix with non-negative random values within a range [0,1]
+	        static public void InitNonNegative(this Matrix<float> matrix)
+	        {
+	            System.Random rand = new System.Random();
+
+	            for (int i = 0; i < matrix.data.Length; i++)
+	                matrix.data[i] = (float)rand.NextDouble();
+	        }
+
+	        // Initializes a float matrix with zeros
+	        static public void InitZeros(this Matrix<float> matrix)
+	        {
+	            for (int i = 0; i < matrix.data.Length; i++)
+	                matrix.data[i] = 0;
+	        }
+
 		/// <summary>Increments the specified matrix element by a double value</summary>
 		/// <param name="matrix">the matrix</param>
 		/// <param name="i">the row</param>
@@ -86,7 +103,7 @@ static public void Inc(this Matrix<float> matrix1, Matrix<float> matrix2)
 			if (matrix1.dim1 != matrix2.dim1 || matrix1.dim2 != matrix2.dim2)
 				throw new ArgumentOutOfRangeException("Matrix sizes do not match.");
 
-			for (int i = 0; i < matrix1.data.Length; i++)
+            for (int i = 0; i < matrix1.data.Length; i++)
 				matrix1.data[i] += matrix2.data[i];
 		}
 
@@ -104,7 +121,7 @@ static public void Inc(this Matrix<int> matrix, int i, int j)
 		/// <param name="v">the value to increment with</param>
 		static public void Inc(this Matrix<float> matrix, float v)
 		{
-			for (int i = 0; i < matrix.data.Length; i++)
+            for (int i = 0; i < matrix.data.Length; i++)
 				matrix.data[i] += v;
 		}
 
@@ -157,7 +174,7 @@ static public float ColumnAverage(this Matrix<float> matrix, int col)
 		/// <param name="f">the number to multiply with</param>
 		static public void Multiply(this Matrix<float> matrix, float f)
 		{
-			for (int i = 0; i < matrix.data.Length; i++)
+            for (int i = 0; i < matrix.data.Length; i++)
 				matrix.data[i] *= f;
 		}
 
@@ -170,7 +187,7 @@ static public void Multiply(this Matrix<float> matrix, float f)
 		static public float FrobeniusNorm(this Matrix<float> matrix)
 		{
 			double squared_entry_sum = 0;
-			for (int i = 0; i < matrix.data.Length; i++)
+            for (int i = 0; i < matrix.data.Length; i++)
 				squared_entry_sum += Math.Pow(matrix.data[i], 2);
 			return (float) Math.Sqrt(squared_entry_sum);
 		}
@@ -304,11 +321,13 @@ static public int Max(this Matrix<int> m)
 			return m.data.Max();
 		}
 
+
+
 		/// <summary>return the maximum value contained in a matrix</summary>
 		/// <param name='m'>the matrix</param>
 		static public float Max(this Matrix<float> m)
 		{
 			return m.data.Max();
 		}
 	}
-}
+}

src/MyMediaLite/RatingPrediction/MatrixFactorization.cs

@@ -1,3 +1,4 @@
+// Copyright (C) 2015 Zeno Gantner, Dimitris Paraschakis
 // Copyright (C) 2011, 2012 Zeno Gantner
 // Copyright (C) 2010 Zeno Gantner, Steffen Rendle, Christoph Freudenthaler
 //
@@ -101,6 +102,7 @@ protected internal virtual void InitModel()
 			// init factor matrices
 			user_factors = new Matrix<float>(MaxUserID + 1, NumFactors);
 			item_factors = new Matrix<float>(MaxItemID + 1, NumFactors);
+
 			user_factors.InitNormal(InitMean, InitStdDev);
 			item_factors.InitNormal(InitMean, InitStdDev);
 
@@ -115,6 +117,26 @@ protected internal virtual void InitModel()
 			current_learnrate = LearnRate;
 		}
 
+        protected internal virtual void InitModelNonNegative()
+        {
+            // init factor matrices
+            user_factors = new Matrix<float>(MaxUserID + 1, NumFactors);
+            item_factors = new Matrix<float>(MaxItemID + 1, NumFactors);
+
+            user_factors.InitNonNegative();
+            item_factors.InitNonNegative();
+
+            // set factors to zero for users and items without training examples
+            for (int u = 0; u < ratings.CountByUser.Count; u++)
+                if (ratings.CountByUser[u] == 0)
+                    user_factors.SetRowToOneValue(u, 0);
+            for (int i = 0; i < ratings.CountByItem.Count; i++)
+                if (ratings.CountByItem[i] == 0)
+                    item_factors.SetRowToOneValue(i, 0);
+
+            current_learnrate = LearnRate;
+        }
+
 		///
 		public override void Train()
 		{

src/MyMediaLite/RatingPrediction/RSNMF.cs

@@ -0,0 +1,165 @@
+// Copyright (C) 2015 Dimitris Paraschakis
+//
+// This file is part of MyMediaLite.
+//
+// MyMediaLite is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// MyMediaLite is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with MyMediaLite.  If not, see <http://www.gnu.org/licenses/>.
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Threading.Tasks;
+using MyMediaLite.DataType;
+using MyMediaLite.Data;
+using System.Linq;
+
+namespace MyMediaLite.RatingPrediction
+{
+	/// <summary>Regularized single-element-based non-negative matrix factorization (RSNMF)</summary>
+    /// <remarks>
+    ///   <para>
+    ///     Literature:
+    ///     <list type="bullet">
+    ///       <item><description>
+    ///         Luo et al. (2014): "An efficient non-negative matrix-factorization-based approach to collaborative filtering for recommender systems".
+    ///         IEEE Transaction and Industrial Informatics, Vol. 10, No. 2, 2014
+    ///       </description></item>
+    ///   </para>
+    /// </remarks>
+	public class RSNMF : MatrixFactorization
+	{
+        private Matrix<float> P;
+        private Matrix<float> Q;
+
+        /// <summary>Regularization parameter</summary>
+        public float Lambda { get { return lambda; } set { lambda = value; } }
+        float lambda = 0.12f;
+
+		public RSNMF() {}
+
+        public override void Train()
+        {            
+            InitModelNonNegative();
+            P = user_factors;
+            Q = (Matrix<float>) item_factors.Transpose();
+
+            Matrix<float> UserUP = new Matrix<float>(P);
+            Matrix<float> UserDOWN = new Matrix<float>(P);
+            Matrix<float> ItemUP = new Matrix<float>(Q);
+            Matrix<float> ItemDOWN = new Matrix<float>(Q);
+
+            for (int iter = 0; iter < NumIter; iter++)
+            {
+                UserUP.InitZeros();
+                UserDOWN.InitZeros();
+                ItemUP.InitZeros();
+                ItemDOWN.InitZeros();
+
+                Parallel.For(0, Ratings.Count, index =>
+                {
+                    int u = Ratings.Users[index];
+                    int i = Ratings.Items[index];
+
+                    float R_ui = Ratings[index];
+                    float R_ui_hat = R_hat(u, i);
+                    for (int k = 0; k < NumFactors; k++)
+                    {
+                        UserUP[u, k] += Q[k, i] * R_ui;
+                        UserDOWN[u, k] += Q[k, i] * R_ui_hat;
+                        ItemUP[k, i] += P[u, k] * R_ui;
+                        ItemDOWN[k, i] += P[u, k] * R_ui_hat;
+                    }
+                });
+
+                foreach (int u in Ratings.Users.Distinct())
+                {
+                    int I_u = Ratings.ByUser[u].Count;
+                    for (int k = 0; k < NumFactors; k++)
+                    {
+                        UserDOWN[u, k] += I_u * lambda * P[u, k];
+                        P[u, k] *= UserUP[u, k] / (UserDOWN[u, k]);
+                    }
+                }
+
+                foreach (int i in Ratings.Items.Distinct())
+                {
+                    int U_i = Ratings.ByItem[i].Count;
+                    for (int k = 0; k < NumFactors; k++)
+                    {
+                        ItemDOWN[k, i] += U_i * lambda * Q[k, i];
+                        Q[k, i] *= ItemUP[k, i] / (ItemDOWN[k, i]);
+                    }
+                }
+
+                /*
+                // Evaluate objective function
+                float sum_error = 0;
+
+                //Parallel.For(0, Ratings.Count, index =>
+                for (int index = 0; index < Ratings.Count; index++)
+                {
+                    int u = Ratings.Users[index];
+                    int i = Ratings.Items[index];
+
+                    float R_ui = Ratings[index];
+
+                    float R_ui_hat = 0;
+                    float p_2 = 0;
+                    float q_2 = 0;
+
+                    for (int k = 0; k < NumFactors; k++)
+                    {
+                        R_ui_hat += P[u, k] * Q[k, i];
+                        p_2 += (float)Math.Pow(P[u, k], 2);
+                        q_2 += (float)Math.Pow(Q[k, i], 2);
+                    }
+                    sum_error += (float)Math.Pow((R_ui - R_ui_hat), 2) + lambda * p_2 + lambda * q_2;
+                }
+                Console.WriteLine("Iteration {0}:\t{1}", iter, sum_error);
+                */
+
+            }
+            user_factors = P;
+            item_factors = (Matrix<float>) Q.Transpose();
+        }
+
+        private float R_hat(int u, int i)
+        {
+            float result = 0;
+            for (int k = 0; k < NumFactors; k++)
+            {
+                result += P[u, k] * Q[k, i];
+            }
+            return result;
+        }
+
+        public override float Predict(int user_id, int item_id)
+        {
+            return base.Predict(user_id, item_id);
+        }
+
+		///
+		public override float ComputeObjective()
+		{
+			return -1;
+		}
+
+		///
+		public override string ToString()
+		{
+			return string.Format(
+				CultureInfo.InvariantCulture,
+				"RSNMF num_factors={0} num_iter={1} lambda={2}",
+				NumFactors, NumIter, Lambda);
+		}
+	}
+}