neural-net-matrix-factorization
Exploring neural networks for collaborative filtering.
view repo
Data often comes in the form of an array or matrix. Matrix factorization techniques attempt to recover missing or corrupted entries by assuming that the matrix can be written as the product of two low-rank matrices. In other words, matrix factorization approximates the entries of the matrix by a simple, fixed function---namely, the inner product---acting on the latent feature vectors for the corresponding row and column. Here we consider replacing the inner product by an arbitrary function that we learn from the data at the same time as we learn the latent feature vectors. In particular, we replace the inner product by a multi-layer feed-forward neural network, and learn by alternating between optimizing the network for fixed latent features, and optimizing the latent features for a fixed network. The resulting approach---which we call neural network matrix factorization or NNMF, for short---dominates standard low-rank techniques on a suite of benchmark but is dominated by some recent proposals that take advantage of the graph features. Given the vast range of architectures, activation functions, regularizers, and optimization techniques that could be used within the NNMF framework, it seems likely the true potential of the approach has yet to be reached.
READ FULL TEXT VIEW PDF
We show that the objective function of conventional k-means clustering c...
read it
It is common to use networks to encode the architecture of interactions
...
read it
Recommender systems problems witness a growing interest for finding bett...
read it
Given a sparse rating matrix and an auxiliary matrix of users or items, ...
read it
The problem of predicting unobserved entries of a partially observed mat...
read it
A collection of U (∈N) data vectors is called a U-tuple,
and the assoc...
read it
Bayesian matrix factorization (BMF) is a powerful tool for producing low...
read it
Exploring neural networks for collaborative filtering.
We are interested in modeling arrays of data, which arise in the analysis of networks, graphs, and, more generally, relational data. For example, in collaborative filtering and recommender system applications (GNOT92; BiasedMF), we may have users and movies, and for some collection of user–movie pairs , we have recorded the rating that user gave movie . The inferential goal we focus on in this work is to predict the ratings for those pairs not in . The data can be modeled as a partial observation of an array . While the methods we discuss are applicable far beyond the setting of movie rating data or even two-dimensional arrays, we will rely on the user–movie metaphor throughout.
One of the most popular approaches to modeling relational data using latent features is based on matrix factorization. Here the idea is to assume that is well approximated by the product of two low-rank matrices and , where the rank is much less than and . Write and for the -dimensional column vectors of and , respectively. Informally, we will think of as a latent vector of features describing user , and of as a latent vector of features describing movie . The ranking is then approximated by the inner product .
Probabilistic matrix factorization (RussPMF), or simply PMF, is based on matrix factorization, and further assumes the entries of
are independent Gaussians with common variance and means given by the corresponding entries of
. Maximum likelihood inference of the features and leads one to minimize the Frobenius norm of , or equivalently, the root mean squared error (RMSE) between the inner product of the features and the observed relations. In practice, regularization of the features vectors often improves the performance of the resulting predictions, provided the regularization parameter is chosen carefully, e.g., by cross validation.PMF is extremely effective in practice, but is also easy to improve upon when dealing with large but sparsely observed array data, as is typical in collaborative filtering. One way to improve upon PMF is to introduce row and column effects that model systematic biases associated with users and with movies, leading to a model known in collaborative filtering community as BiasedMF (BiasedMF). In this approach, the mean of is taken to be , where , , and are additional latent variables representing the user, movie, and global biases, respectively. Note that the row and column effects in BiasedMF can be seen as a special case of PMF where we fix an entry of and a distinct entry of to take the value 1. In other words, BiasedMF implements a strong inductive bias. Again, regularization improves prediction performance in practice.
In this short paper, we describe a different approach to factorizing . Write for the element-wise product, i.e., the -dimensional vector whose ’th entry is . Using this notation, PMF models the mean of by , where is the function . In the same notation, BiasedPMF models the mean of by . Our idea is to learn , rather than assume it is fixed. In particular, we take to be a feed-forward neural network with weights . Given data, we learn the weights
at the same time that we learn the latent features. Note that, for fixed latent feature vectors, we effectively have a supervised learning problem, and so we can optimize the neural network by gradient descent as is typical. Fixing the neural network, we can optimize the latent feature vectors also by gradient descent, not unlike recent applications of neural networks to the problem of transferring artistic styles to ordinary images
(NeuralArt). As one would expect, regularization is critical. We used -regularization for the latent feature vectors, and chose the regularization parameter by optimizing the error on a validation set. We call our proposal neural network matrix factorization, or simply NNMF.Let
. A data array is modeled as a collection of real-valued random variables
, for , where are the indices of the observed entries of the data array. (The extension to higher-dimensional arrays or arrays whose entries are elements in spaces other than is straightforward.)To each row, , we associate a latent feature vector and a latent feature matrix . Similarly, to each column, , we associate a latent feature vector and latent feature matrix . Write for the ’th column of (and similarly for ), and write for the collection of all latent features.^{1}^{1}1Note that there is nothing forcing the latent feature vectors for users and for movies to have the same dimensionality. We made this choice for simplicity.
Let be a feed-forward neural network with weights . Viewing and the latent features as unknown parameters, we assume the entries are independent random variables with means
In other words, the neural network has real-valued input units and one real-valued output unit. The first are user-specific features; the next are movie-specific features; and the last inputs are the result of inner products between -dimensional vectors.^{2}^{2}2In our experiments, we took and large. Taking results in a model where the input to the neural network is the prediction of a rank- matrix factorization and additional features. This simple modification of matrix factorization lead to improvements, but not as dramatic as those we report in Section 5.
To learn the network weights and latent features , we minimize the objective
where is a regularization parameter, denotes the norm, and denotes the Frobenius norm. This objective can be understood as a penalized log likelihood under a Gaussian model for each entry. It can also be understood as a specifying the maximum a posterioriestimate assuming independent Gaussian priors for every latent feature.
During training, we alternated between optimizing the neural network weights, while fixing the latent features, and optimizing the latent features, while fixing the network weights. Optimization was carried out by gradient descent on the entire dataset (i.e., we did not use batches). We used RMSProp to adjust the learning rate. (See
Section 5 for details.) We did not evaluate other optimization algorithms.NNMF is very similar in spirit to the Random Function Model for modeling arrays/matrices proposed by RFMLloyd. Using probabilistic symmetry considerations, they arrive at a model where the mean of is given by , where is modeled by a Gaussian process. At a high level, our model replaces the Gaussian process prior with a parametric neural network one. We explored simply taking to be a feed-forward neural network (acting on a concatenated pair of vectors in ), but found that we achieved better performance if some of the input dimensions first underwent an element-wise product. (We discuss this further below in relationship to NTN models.) Conceivably, a deep neural network could learn to approximate the element-wise product or even outperform it, but this was not the case in our experiments, which used gradient-descent techniques to learn the neural network weights. In experiments, we found that NNMF significantly outperformed RFM, although the RFM results were those produced by an implementation that was limited to latent dimensions due to significant algorithmic issues associated with scaling up inference for the Gaussian process component. Given some recent advances in GP inference, it would be interesting to revisit the RFM, though it is not clear to the authors whether the advances are quite enough.
NNMF is related to some methods applied to Knowledge Bases and Knowledge Graphs. (See
(NickelMurphy2015)for a review of relational machine learning and Knowledge Graphs.) Knowledge bases (KBs) are relational data composed of entity–relation–entity triples. For example, a geopolitical knowledge base might contain facts such as
(Rome, capitol-of, Italy) and (Lithuania, member-of, EU). Knowledge graphs (KGs) are representations of KBs as graphs whose vertices represent entities and whose (labelled) edges represent relations between entities. Given this connection, one can see that KBs can be thought of as a collection of (extremely sparsely observed) arrays, one for each relation, or as a single three-dimensional array. The key challenge in modeling KBs and KGs is to simultaneously learn many relations using shared representations in order to augment the limited data one has on each relation. This is one of the key differences with the collaborative filtering setting.A method for KGs similar to NNMF is the Neural Tensor Network (NTN), which combines a tensor product with a single-layer neural network
(NTN2013). (Methods similar to NTN have been applied to problems in speech recognition. See, e.g., (YuDS2013).) Other approaches to KGs use neural networks to produce representations, rather than map representations to predictions, like NTN and NNMF. (See, e.g., (HuangHJ15) and (BGL2014).)NTNs model each element of a two-dimensional array by
where are feature vectors; is a linear layer weight vector;
is a bias vector;
is a weight matrix; is a third order tensor; and the nonlinearity acts element wise. The tensor product term denotes the element in whose ’th entry is equal to , where is the ’th slice of . The model is trained by optimizing the contrastive max-margin objective using L-BFGS with mini-batches.Ignoring the particularly nonlinearity used, the first layer of the NNMF model can be expressed in the form Section 4 if we take and allow ourselves to fix some entries of the latent features. (NTN employs no additional layers.) For example, taking as in our experiments, define for , , , and ,
where denotes an -dimensional column vector with all entries equal to 1 and is the weight matrix defining the first layer of the NNMF network. Then we recover the first layer of NNMF with the third-order tensor whose ’th slice is .
There have been many scalable techniques proposed to model very large KGs. NickelMurphy2015 split existing models into two categories: latent feature models and graph feature models. Latent variable methods learn unobserved representations of entities and use them to predict relations, while graph feature methods learn to predict relations directly from extracted features of local graph structure. TC2015 argue through empirical comparisons that these two categories of models exhibit complimentary strengths.
A number of state-of-the-art proposals for collaborative filtering are perhaps best thought of as incorporating aspects of graph feature models. An example of a method relaxing the low-rank assumption using graph features is the Local Low Rank Matrix Approximation (LLORMA), which assumes that every entry in the matrix is given by a combination of low rank matrices, where the combination is specific to the entry. LLORMA achieves impressive state-of-the-art performance.
Other approaches also use neural-network architectures but work by trying to predict the ground truth ratings directly from the observed ratings matrix . For example, in I-AutoRec (AutoRec)
, an autoencoder is learned that takes as input the observed movie ratings vector
for user and produces as output the ground truth . (Missing entries are typically replaced by value 3.) AutoRec achieves state-of-the-art performance, slightly besting LLORMA on some benchmarks, but a careful comparison would likely require a fresh data set and strict controls on how the numerous parameters for both models are chosen (BH15; Dwork07082015). Another model in this category is the I-RBM (I-RBM), but its performance is now far from the state of the art.Both LLORMA and I-AutoRec can be seen as models combining aspects of both graph feature and latent feature models. LLORMA identifies similar rows and columns (entities) using graph features, but model each local low-rank approximation using latent features. I-AutoRec takes as input all observed ratings (relations) for a user (entity), allowing the network to model the graph features, which in this case are similarities and distances among movies.
In Section 5, we compare the performance of NNMF and other approaches on benchmarks including link prediction in graphs, as well as collaborative filtering in movie rating datasets. In our experiments, NNMF dominated other latent feature methods, as well as the I-RBM model. However, NNMF was dominated by both LLORMA and I-AutoRec. One possibility is that a different approach to learning the underlying neural network would deliver results on par with these methods. Another possibility is that the difference reflects some fundamental limitation of latent feature models, which assume that the ratings are conditionally independent given the latent feature representations. Local graph structure may contain information that would aid in predicting ratings. In particular, NNMF does not learn from the pattern of missing ratings,which can reveal information about a user or movie: e.g., a user might tend only to give ratings when those ratings are extreme, and movies with low ratings are less likely to be viewed in the first place. In contrast to NNMF, both LLORMA and AutoRec could, in principle, be taking advantage of the information latent in the pattern of missing ratings, although the strength of this effect has not been studied. In LLORMA, the sparsity pattern affects the notion of locality. In AutoRec, the entire pattern of ratings is fed as input, although the sparsity is obscured somewhat by missing entries being replaced by 3’s.
Some recent work by LHG14 demonstrates that explicitly modeling the non-random pattern of missing ratings can lead to a slight improvement in performance for latent feature models, although the gains they demonstrated were not dramatic enough that they would have closed the gap between NNMF and LLORMA/AutoRec. Indeed, we implemented a neural architecture similar in spirit to theirs, but were only able to improve the RMSE score by approximately . A more careful analysis would be necessary to make more definitive conclusions.
NIPS | Protein | ML100k | ML1m | |
---|---|---|---|---|
Vertices X | 234 | 230 | 943 | 6040 |
Vertices Y | - | - | 1682 | 3900 |
Edges | 27144 | 52900 | 100000 | 1000209 |
NIPS | Protein | ML-100K | |
RFM (3) | 0.110 | 0.136 | - |
PMF (3) | 0.130 | 0.139 | - |
PMF (60) | 0.062 | 0.104 | 0.952 |
BiasedMF (60) | 0.065 | 0.111 | 0.911 |
NTN (60) | 0.048 | 0.071 | 0.910 |
NNMF (3HL) | 0.040 | 0.065 | 0.907 |
NNMF (4HL) | - | - | 0.903 |
ML-1M | |
PMF (60) | 0.883 |
LLORMA-GLOBAL | 0.865 |
I-RBM | 0.854 |
BiasedMF (60) | 0.852 |
NTN (60) | 0.852 |
LLORMA-LOCAL | 0.833 |
I-AutoRec | 0.831 |
NNMF (3HL) | 0.846 |
NNMF (4HL) | 0.843 |
We evaluated NNMF on two graph datasets (NIPS and Protein) and two collaborative filtering datasets (MovieLens 100K and 1M). See Table 1 for more information about the datasets.
NNMF, NTN, PMF model performance was evaluated on 5 randomly subsampled test sets, each comprising of the data points, and then averaged. The remaining of the data was split into training and validation sets: For the graph datasets, we used a of the training data for validation. Due to the larger size of collaborative filtering datasets, we used and of the training data for validation on the MovieLens 100K and 1M datasets, respectively. These numbers were chosen to make the Monte Carlo error of the validation set estimate sufficiently small. (It is likely that results could be improved by better use of the training and validation data.)
The regularization parameter, , and optimal stopping time were chosen by optimizing the error on the validation set. For every fixed setting of , the network and features were learned by optimizing Section 3 as described in Section 3.
For simplicity, and to avoid the pitfalls of choosing parameters that produce good test set performance, the number and dimensionality of the features, as well as the network architecture, were fixed across experiments. It is conceivable that cross validating these parameters would have yielded better results. On the other hand, it would be wise to employ safeguards (Dwork07082015) before embarking on an adaptive search for better architectures, learning rates, activation functions, etc.
We chose feature dimensions to be preprocessed by an element-wise product, and included additional features for each user and each movie. The feed-forward neural network was chosen to have 3 hidden layers with 50 sigmoidal units each. The network weights were sampled uniformly in , where ,
denote the number of inbound and outbound connections. The latent features were randomly initialized from a zero-mean Gaussian distribution with standard deviation
. The features and weights were learned by gradient descent, and RMSPROP was used to adjust the learning rate, which was initialized to for NIPS, Protein, and ML-100K, and to for ML-1M.To train the PMF model, we chose 60 dimensions after evaluating the performance of PMF with various choices for the dimensionality and finding that this worked best. On each run, the regularization parameter was chosen from a large range by optimizing the validation error. (We tried many other settings for PMF, and have reported the best numbers we obtained here to make the comparison conservative.)
NTN model hyperparameters were chosen to match NNMF ones—we used 60-dimensional latent features, and
units in the hidden layer. This setup yields a third order tensor with entries. Compared to the network underlying NNMF, a NTN of approximately the same size has roughly 20 times more parameters. The model was trained with gradient descent on the same objective function as for NNMF. We had to use mini-batches for the MovieLens 1M dataset to avoid memory issues. Just as for other models, we chose the regularization parameter by optimizing it the error on the validation set. Note, that in the original NTN model was trained with a contrastive max-margin objective function withregularization of all parameters. We applied a sigmoid nonlinearity to the output layer of the original NTN, to ensure that its outputs fell in
.The results appear in Table 2. As mentioned above, NNMF dominates PMF, RFM, and to a lesser extent NTN. In (RFMLloyd), the performance of RFM is compared with PMF when both models use the same number of latent dimensions. The performance of PMF, however, tends to improve with the higher dimension, assuming proper regularization, and so RFM (3) is seen here to perform worse than PMF (60). It is possible that recent advances in Gaussian process regression could in turn improve the performance of RFM.
NNMF outperforms BaisedMF, although the margin narrows as we move to the sparsely-observed MovieLens datasets. We note that adding bias correction terms to NNMF also improves the performance of NNMF, although the improvement is on the order of , and so may not be robust. It is also possible that using more of the training data might widen the gap.
NNMF beats the (low-rank) global version of LLORMA, but not the local version that relaxes the low-rank constraint. NNMF is also bested by AutoRec. It is also not clear if we could have reliably found much better network weights and features had we made different choices around the architecture, composition, and training of the neural network. Given that NNMF dominates PMF so handily on the graph datasets, it might stand to reason that there is a lot of room for improvement on MovieLens through better engineering of NNMF. It is worth noting that a ‘local’ versions of NNMF could be developed along the same lines as were for LLORMA. Given that NNMF dominates PMF, it might then also stand to reason that a local version of NNMF would dominate LLORMA, because LLORMA can be understood as a local version of PMF.
To see whether deeper networks performed better on the collaborative filtering datasets, we also evaluated NNMF on the MovieLens data sets using a 4 hidden layer network. We observed that fewer units per layer yielded better results. (We compared 50 units per layer when to 20 units per layer when .) However, to draw any conclusions, more experiments would be needed, with care to avoid overfitting. We reported scores for 4 hidden layer networks, with 20 units per hidden layer, and latent feature dimensions. We believe that adding additional layers would likely improve the results, though we suspect the performance would saturate quickly (and then drop if we did not very carefully initialize and regularize the network).
NNMF achieves state-of-the-art results among latent feature models, but is dominated by approaches that take into account local graph structure. However, it is possible that our experiments have not identified the limits of the NNMF model. It is difficult to exhaustively explore the range of network architectures, activation functions, regularization techniques, and cross-validation strategies. Even if we could explore them all, we would be in danger of overfitting and losing any hope of insight into the usefulness of NNMF. Indeed, we erred towards not trying to optimize over the model’s many possible configuration. It would be interesting to apply recent advances in adaptive estimation to control the possibility of overfitting during this phase of designing and evaluating a new model (Dwork07082015).
The authors would like to thank Zoubin Ghahramani for feedback and helpful discussions.
Comments
There are no comments yet.