1 Introduction
With the explosive growth of ecommerce and social media platforms, recommendation algorithms have become indispensable tools for many businesses. Two main branches of recommender algorithms are often distinguished: contentbased recommender systems [24] and collaborative filtering models [9]. Contentbased recommender systems use content information of users and items, such as their respective occupation and genre, to predict the next purchase of a user or rating of an item. Collaborative filtering models solve the matrix completion task by taking into account the collective interaction data to predict future ratings or purchases.
In this work, we view matrix completion as a link prediction problem on graphs: the interaction data in collaborative filtering can be represented by a bipartite graph between user and item nodes, with observed ratings/purchases represented by links. Content information can naturally be included in this framework in the form of node features. Predicting ratings then reduces to predicting labeled links in the bipartite useritem graph.
We propose graph convolutional matrix completion (GCMC): a graphbased autoencoder framework for matrix completion, which builds on recent progress in deep learning on graphs [2, 6, 19, 5, 15, 30, 14]. The autoencoder produces latent features of user and item nodes through a form of message passing on the bipartite interaction graph. These latent user and item representations are used to reconstruct the rating links through a bilinear decoder.
The benefit of formulating matrix completion as a link prediction task on a bipartite graph becomes especially apparent when recommender graphs are accompanied with structured external information such as social networks. Combining such external information with interaction data can alleviate performance bottlenecks related to the cold start problem. We demonstrate that our graph autoencoder model efficiently combines interaction data with side information, without resorting to recurrent frameworks as in [22].
2 Matrix completion as link prediction in bipartite graphs
Consider a rating matrix of shape , where is the number of users and is the number of items. Entries in this matrix encode either an observed rating (user rated item ) from a set of discrete possible rating values, or the fact that the rating is unobserved (encoded by the value ). See Figure 1 for an illustration. The task of matrix completion or recommendation can be seen as predicting the value of unobserved entries in .
In an equivalent picture, matrix completion or recommendation can be cast as a link prediction problem on a bipartite useritem interaction graph. More precisely, the interaction data can be represented by an undirected graph with entities consisting of a collection of user nodes with , and item nodes with , such that . The edges carry labels that represent ordinal rating levels, such as . This connection was previously explored in [18] and led to the development of graphbased methods for recommendation.
Previous graphbased approaches for recommender systems (see [18]
for an overview) typically employ a multistage pipeline, consisting of a graph feature extraction model and a link prediction model, all of which are trained separately. Recent results, however, have shown that results can often be significantly improved by modeling graphstructured data with endtoend learning techniques
[2, 6, 19, 23, 5, 15, 21] and specifically with graph autoencoders [30, 14]for unsupervised learning and link prediction. In what follows, we introduce a specific variant of graph autoencoders for the task of recommendation.
2.1 Graph autoencoders
We revisit graph autoencoders which were originally introduced in [30, 14] as an endtoend model for unsupervised learning [30] and link prediction [14] on undirected graphs. We specifically consider the setup introduced in [14], as it makes efficient use of (convolutional) weight sharing and allows for inclusion of side information in the form of node features. Graph autoencoders are comprised of 1) a graph encoder model , which take as input an feature matrix and a graph adjacency matrix , and produce an node embedding matrix , and 2) a pairwise decoder model , which takes pairs of node embeddings and predicts respective entries in the adjacency matrix. Note that denotes the number of nodes, the number of input features, and the embedding size.
For bipartite recommender graphs , we can reformulate the encoder as , where is the adjacency matrix associated with rating type , such that contains ’s for those elements for which the original rating matrix contains observed ratings with value . and are now matrices of user and item embeddings with shape and
, respectively. A single user (item) embedding takes the form of a realvalued vector
() for user (item ).Analogously, we can reformulate the decoder as , i.e. as a function acting on the user and item embeddings and returning a (reconstructed) rating matrix of shape . We can train this graph autoencoder by minimizing the reconstruction error between the predicted ratings in and the observed groundtruth ratings in . Examples of metrics for the reconstruction error are the root mean square error, or the cross entropy when treating the rating levels as different classes.
2.2 Graph convolutional encoder
In what follows, we propose a particular choice of encoder model that makes efficient use of weight sharing across locations in the graph and that assigns separate processing channels for each edge type (or rating type)
. The form of weight sharing is inspired by a recent class of convolutional neural networks that operate directly on graphstructured data
[2, 6, 5, 15], in the sense that the graph convolutional layer performs local operations that only take the firstorder neighborhood of a node into account, whereby the same transformation is applied across all locations in the graph.This type of local graph convolution can be seen as a form of message passing [4, 8], where vectorvalued messages are being passed and transformed across edges of the graph. In our case, we can assign a specific transformation for each rating level, resulting in edgetype specific messages from items to users of the following form:
(1) 
Here, is a normalization constant, which we choose to either be (left normalization) or (symmetric normalization) with denoting the set of neighbors of node . is an edgetype specific parameter matrix and is the (initial) feature vector of node . Messages from users to items are processed in an analogous way. After the message passing step, we accumulate incoming messages at every node by summing over all neighbors under a specific edgetype , and by subsequently accumulating them into a single vector representation:
(2) 
where denotes an accumulation operation, such as , i.e. a concatenation of vectors (or matrices along their first dimension), or , i.e. summation of all messages.
denotes an elementwise activation function such as the
. To arrive at the final embedding of user node , we transform the intermediate output as follows:(3) 
The item embedding is calculated analogously with the same parameter matrix . In the presence of user and itemspecific side information we use separate parameter matrices for user and item embeddings. We will refer to (2) as a graph convolution layer and to (3) as a dense layer. Note that deeper models can be built by stacking several layers (in arbitrary combinations) with appropriate activation functions. In initial experiments, we found that stacking multiple convolutional layers did not improve performance and a simple combination of a convolutional layer followed by a dense layer worked best.
It is worth mentioning that the model demonstrated here is only one particular possible, yet relatively simple choice of an encoder, and other variations are potentially worth exploring. Instead of a simple linear message transformation, one could explore variations where is a neural network in itself. Instead of choosing a specific normalization constant for individual messages, such as done here, one could employ some form of attention mechanism, where the individual contribution of each message is learned and determined by the model.
2.3 Bilinear decoder
For reconstructing links in the bipartite interaction graph we consider a bilinear decoder, and treat each rating level as a separate class. Indicating the reconstructed rating between user and item with
, the decoder produces a probability distribution over possible rating levels through a bilinear operation followed by the application of a
function:(4) 
with a trainable parameter matrix of shape , and the dimensionality of hidden user (item) representations (). The predicted rating is computed as
(5) 
2.4 Model training
Loss function
During model training, we minimize the following negative log likelihood of the predicted ratings :
(6) 
with when and zero otherwise. The matrix serves as a mask for unobserved ratings, such that ones occur for elements corresponding to observed ratings in , and zeros for unobserved ratings. Hence, we only optimize over observed ratings.
Node dropout
In order for the model to generalize well to unobserved ratings, it is trained in a denoising setup by randomly dropping out all outgoing messages of a particular node, with a probability , which we will refer to as node dropout. Messages are rescaled after dropout as in [28]. In initial experiments we found that node dropout was more efficient in regularizing than message dropout. In the latter case individual outgoing messages are dropped out independently, making embeddings more robust against the presence or absence of single edges. In contrast, node dropout also causes embeddings to be more independent of particular user or item influences. We furthermore also apply regular dropout [28] to the hidden layer units (3).
Minibatching
We introduce minibatching by sampling contributions to the loss function in Eq. (
6) from different observed ratings. That is, we sample only a fixed number of contributions from the sum over user and item pairs. By only considering a fixed number of contributions to the loss function, we can remove respective rows of users and items in in Eq. (7) that do not appear in the current batch. This serves both as an effective means of regularization, and reduces the memory requirement to train the model, which is necessary to fit the full model for MovieLens10M into GPU memory. We experimentally verified that training with minibatches and full batches leads to comparable results for the MovieLens1M dataset while adjusting for regularization parameters. For all datasets except for the MovieLens10M, we opt for fullbatch training since it leads to faster convergence than training with minibatches in this particular setting.2.5 Vectorized implementation
In practice, we can use efficient sparse matrix multiplications, with complexity linear in the number of edges, i.e. , to implement the graph autoencoder model. The graph convolutional encoder (Eq. 3), for example in the case of left normalization, can be vectorized as follows:
(7)  
(8)  
(9) 
The summation in (8) can be replaced with concatenation, similar to (2). In this case denotes the diagonal node degree matrix with nonzero elements . Vectorization for an encoder with a symmetric normalization, as well as vectorization of the bilinear decoder, follows in an analogous manner. Note that it is only necessary to evaluate observed elements in , given by the mask in Eq. 6.
2.6 Input feature representation and side information
Features containing information for each node, such as content information, can in principle be injected into the graph encoder directly at the inputlevel (i.e. in the form of an input feature matrix ). However, when the content information does not contain enough information to distinguish different users (or items) and their interests, feeding the content information directly into the graph convolution layer leads to a severe bottleneck of information flow. In such cases, one can include side information in the form of user and item feature vectors (for node ) via a separate processing channel directly into the the dense hidden layer:
(10) 
where and are trainable weight matrices, and
is a bias. The weight matrices and bias vector are different for users and items. The input feature matrix
containing the node features for the graph convolution layer is then chosen as an identity matrix, with a unique onehot vector for every node in the graph. For the datasets considered in this paper, the user (item) content information is of limited size, and we thus opt to include this as side information while using Eq. (
10).In [29], Strub et al. propose to include content information along similar lines, although in their case the proposed model is strictly user or itembased, and thus only supports side information for either users or items.
Note that side information does not necessarily need to come in the form of pernode feature vectors, but can also be provided in the form of, e.g., graphstructured, natural language, or image data. In this case, the dense layer in (10
) is replaced by an appropriate differentiable module, such as a recurrent neural network, a convolutional neural network, or another graph convolutional network.
2.7 Weight sharing
In the collaborative filtering setting with onehot vectors as input, the columns of the weight matrices play the role of latent factors for each separate node for one specific rating value . These latent factors are passed onto connected user or item nodes through message passing. However, not all users and items necessarily have an equal number of ratings for each rating level. This results in certain columns of to be optimized significantly less frequently than others. Therefore, some form of weight sharing between the matrices for different is desirable to alleviate this optimization problem. Following [32], we therefore implement the following weight sharing setup:
(11) 
We will refer to this type of weight sharing as ordinal weight sharing due to the increasing number of weight matrices included for higher rating levels.
As an effective means of regularization of the pairwise bilinear decoder, we resort to weight sharing in the form of a linear combination of a set of basis weight matrices :
(12) 
with and being the number of basis weight matrices. Here, are the learnable coefficients that determine the linear combination for each decoder weight matrix . Note that in order to avoid overfitting and to reduce the number of parameters, the number of basis weight matrices should naturally be lower than the number of rating levels.
3 Related work
Autoencoders
User or itembased autoencoders [27, 32, 29] are a recent class of stateoftheart collaborative filtering models that can be seen as a special case of our graph autoencoder model, where only either user or item embeddings are considered in the encoder. AutoRec by Sedhain et al. [27] is the first such model, where the user’s (or item’s) partially observed rating vector is projected onto a latent space through an encoder layer, and reconstructed using a decoder layer with mean squared reconstruction error loss.
The CFNADE algorithm by Zheng et al. [32] can be considered as a special case of the above autoencoder architecture. In the userbased setting, messages are only passed from items to users, and in the itembased case the reverse holds. Note that in contrast to our model, unrated items are assigned a default rating of in the encoder, thereby creating a fullyconnected interaction graph. CFNADE imposes a random ordering on nodes, and splits incoming messages into two sets via a random cut, only one of which is kept. This model can therefore be seen as a denoising autoencoder, where part of the input space is dropped out at random in every iteration.
Factorization models
Many of the most popular collaborative filtering algorithms fall into the class of matrix factorization (MF) models. Methods of this sort assume the rating matrix to be well approximated by a low rank matrix: , with and , with . The rows of and can be seen as latent feature representations of users and items, representing an encoding for their interests through their rating pattern. Probabilistic matrix factorization (PMF) by Salakhutdinov et al. [20] assumes that the ratings contained in are independent stochastic variables with Gaussian noise. Optimization of the maximum likelihood then leads one to minimize the mean squared error between the observed entries in and the reconstructed ratings in . BiasedMF by Koren et al. [16] improves upon PMF by incorporating a user and item specific bias, as well as a global bias. Neural network matrix factorization (NNMF) [7]
extends the MF approach by passing the latent user and item features through a feed forward neural network. Local low rank matrix approximation by Lee et al.
[17], introduces the idea of reconstructing rating matrix entries using different (entry dependent) combinations of low rank approximations.Matrix completion with side information
In matrix completion (MC) [3], the objective is to approximate the rating matrix with a lowrank rating matrix. Rank minimization, however, is an intractable problem, and Candes & Recht [3]
replaced the rank minimization with a minimization of the nuclear norm (the sum of the singular values of a matrix), turning the objective function into a tractable convex one. Inductive matrix completion (IMC) by Jain & Dhillon, 2013 and Xu et al., 2013 incorporates content information of users and items in feature vectors and approximates the observed elements of the rating matrix as
, with and representing the feature vector of user and item respectively.The geometric matrix completion (GMC) model proposed by Kalofolias et al. in 2014 [12] introduces a regularization of the MC model by adding side information in the form of user and item graphs. In [25], a more efficient alternating least squares optimization optimization method (GRALS) is introduced to the graphregularized matrix completion problem. Most recently, Monti et al. [22] suggested to incorporate graphbased side information in matrix completion via the use of convolutional neural networks on graphs, combined with a recurrent neural network to model the dynamic rating generation process. Their work is different from ours, in that we model the rating graph directly using a graph convolutional encoder/decoder approach that predicts unseen ratings in a single, noniterative step.
4 Experiments
We evaluate our model on a number of common collaborative filtering benchmark datasets: MovieLens^{2}^{2}2https://grouplens.org/datasets/movielens/ (100K, 1M, and 10M), Flixster, Douban, and YahooMusic. The datasets consist of user ratings for items (such as movies) and optionally incorporate additional user/item information in the form of features. For Flixster, Douban, and YahooMusic we use preprocessed subsets of these datasets provided by [22]^{3}^{3}3https://github.com/fmonti/mgcnn. These datasets contain subgraphs of 3000 users and 3000 items and their respective useruser and itemitem interaction graphs (if available). Dataset statistics are summarized in Table 1.
Dataset  Users  Items  Features  Ratings  Density  Rating levels 

Flixster  3,000  3,000  Users/Items  26,173  0.0029  0.5, 1, …, 5 
Douban  3,000  3,000  Users  136,891  0.0152  1, 2, …, 5 
YahooMusic  3,000  3,000  Items  5,335  0.0006  1, 2, …, 100 
MovieLens 100K (ML100K)  943  1,682  Users/Items  100,000  0.0630  1, 2, …, 5 
MovieLens 1M (ML1M)  6,040  3,706  —  1,000,209  0.0447  1, 2, …, 5 
MovieLens 10M (ML10M)  69,878  10,677  —  10,000,054  0.0134  0.5, 1, …, 5 
For all experiments, we choose from the following settings based on validation performance: accumulation function ( vs. ), whether to use ordinal weight sharing in the encoder, left vs. symmetric normalization, and dropout rate . Unless otherwise noted, we use a Adam [13] with a learning rate of , weight sharing in the decoder with 2 basis weight matrices, and layer sizes of and for the graph convolution (with ) and dense layer (no activation function), respectively. We evaluate our model on the held out test sets using an exponential moving average of the learned model parameters with a decay factor set to .
MovieLens 100K
For this task, we compare against matrix completion baselines that make use of side information in the form of user/item features. We report performance on the canonical /
train/test split. Hyperparameters are optimized on a 80/20 train/validation split of the original training set. Side information is present both for users (e.g. age, gender, and occupation) and movies (genres). Following Rao et al.
[25], we map the additional information onto feature vectors for users and movies, and compare the performance of our model with (GCMC+Feat) and without the inclusion of these features (GCMC) . Note that GMC [12], GRALS [25] and sRGCNN [22] represent user/item features via a knearestneighbor graph. We use stacking as an accumulation function in the graph convolution layer in Eq. (2), set dropout equal to , and use left normalization. GCMC+Feat uses 10 hidden units for the dense side information layer (with activation) as described in Eq. 10. We train both models for 1,000 fullbatch epochs. We report RMSE scores averaged over 5 runs with random initializations
^{4}^{4}4Standard error less than .. Results are summarized in Table 7.MovieLens 1M and 10M
We compare against current stateoftheart collaborative filtering algorithms, such as AutoRec [27], LLorma [17], and CFNADE [32]. Results are reported as averages over the same five 90/10 training/test set splits as in [32] and summarized in Table 4. Model choices are validated on an internal 95/5 split of the training set. For ML1M we use accumulate messages through summation in Eq. (2), use a dropout rate of , and symmetric normalization. As ML10M has twice the number of rating classes, we use twice the number of basis function matrices in the decoder. Furthermore, we use stacking accumulation, a dropout of and symmetric normalization. We train for 3,500 fullbatch epochs, and 18,000 minibatch iterations (20 epochs with batch size 10,000) on the ML1M and ML10M dataset, respectively.
Flixster, Douban and YahooMusic
These datasets contain user and item side information in the form of graphs. We integrate this graphbased side information into our framework by using the adjacency vector (normalized by degree) as a feature vector for the respective user/item. For a single dense feature embedding layer, this is equivalent to performing a graph convolution akin to [15] on the useruser or itemitem graph.^{5}^{5}5With a rownormalized adjacency matrix instead of the symmetric normalization from [15]. Both perform similarly in practice. We use a dropout rate of , and 64 hidden units for the dense side information layer (with activation) as described in Eq. 10. We use a left normalization, and messages in the graph convolution layer are accumulated by concatenation (as opposed to summation). All models are trained for epochs. For hyperparameter selection, we set aside a separate 80/20 train/validation split from the original training set in [22]. For final model evaluation, we train on the full original training set from [22] and report test set performance. Results are summarized in Table 3.
Model  ML100K + Feat 

MC [3]  
IMC [11, 31]  
GMC [12]  
GRALS [25]  
sRGCNN [22]  
GCMC (Ours)  
GCMC+Feat 
Model  Flixster  Douban  YahooMusic 

GRALS  
sRGCNN  
GCMC 
Model  ML1M  ML10M 

PMF [20]  –  
IRBM [26]  
BiasMF [16]  
NNMF [7]  –  
LLORMALocal [17]  
IAUTOREC [27]  
CFNADE [32]  
GCMC (Ours) 
Coldstart analysis
To gain insight into how the GCMC model makes use of side information, we study the performance of our model in the presence of users with only very few ratings (coldstart users). We adapt the ML100K benchmark dataset, so that for a fixed number of coldstart users all ratings except for a minimum number are removed from the training set (chosen at random with a fixed seed across experiments). Note that ML100K in its original form contains only users with at least 20 ratings.
We analyze model performance for and , both with and without using user/item features as side information (see Figure 3). Hyperparameters and test set are chosen as before, i.e. we report RMSE on the complete canonical test set split. The benefit of incorporating side information, such as user and item features, is especially pronounced in the presence of many users with only a single rating.
Discussion
On the ML100K task with side information, our model outperforms related methods by a significant margin. Remarkably, this is even the case without the use of side information. Most related to our method is sRGCNN by Monti et al. [22]
that uses graph convolutions on the nearestneighbor graphs of users and items, and learns representations in an iterative manner using recurrent neural networks. Our results demonstrate that a direct estimation of the rating matrix from learned user/item representations using a simple decoder model can be more effective, while being computationally more efficient.
Our results on ML1M and ML10M demonstrate that it is possible to scale our method to larger datasets, putting it into the vicinity of recent stateoftheart collaborative filtering user or itembased methods in terms of predictive performance. At this point, it is important to note that several techniques introduced in CFNADE [32], such as layerspecific learning rates, a special ordinal loss function, and the autoregressive modeling of ratings, can be seen as orthogonal to our approach and can be used in conjunction with our framework.
For the Flixster, Douban, and YahooMusic datasets our model achieves stateoftheart results, while using a single hyperparameter setting across all three datasets.
5 Conclusions
In this work, we have introduced graph convolutional matrix completion (GCMC): a graph autoencoder framework for the matrix completion task in recommender systems. The encoder contains a graph convolution layer that constructs user and item embeddings through message passing on the bipartite useritem interaction graph. Combined with a bilinear decoder, new ratings are predicted in the form of labeled edges.
The graph autoencoder framework naturally generalizes to include side information for both users and items. In this setting, our proposed model outperforms recent related methods by a large margin, as demonstrated on a number of benchmark datasets with feature and graphbased side information. We further show that our model can be trained on larger scale datasets through stochastic minibatching. In this setting, our model achieves results that are competitive with recent stateoftheart collaborative filtering.
In future work, we wish to extend this model to largescale multimodal data (comprised of text, images, and other graphbased information), such as present in many realisitic recommendation platforms. In such a setting, the GCMC model can be combined with recurrent (for text) or convolutional neural networks (for images). To address scalability, it is necessary to develop efficient approximate schemes, such as subsampling local neighborhoods [10]. Finally, attention mechanisms [1] provide a promising future avenue for extending this class of models.
Acknowledgments
We would like to thank Jakub Tomczak, Christos Louizos, Karen Ullrich and Peter Bloem for helpful discussions and comments. This project is supported by the SAP Innovation Center Network.
References
 [1] Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014.
 [2] Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann LeCun. Spectral networks and locally connected networks on graphs. arXiv preprint arXiv:1312.6203, 2013.
 [3] Emmanuel Candes and Benjamin Recht. Exact matrix completion via convex optimization. Communications of the ACM, 55(6):111–119, 2012.

[4]
Hanjun Dai, Bo Dai, and Le Song.
Discriminative embeddings of latent variable models for structured
data.
In
International Conference on Machine Learning (ICML)
, 2016.  [5] Michaël Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on graphs with fast localized spectral filtering. In Advances in Neural Information Processing Systems, pages 3837–3845, 2016.
 [6] David K. Duvenaud, Dougal Maclaurin, Jorge Iparraguirre, Rafael Bombarell, Timothy Hirzel, Alán AspuruGuzik, and Ryan P. Adams. Convolutional networks on graphs for learning molecular fingerprints. In Advances in neural information processing systems (NIPS), pages 2224–2232, 2015.
 [7] Gintare Karolina Dziugaite and Daniel M Roy. Neural network matrix factorization. arXiv preprint arXiv:1511.06443, 2015.
 [8] Justin Gilmer, Samuel S. Schoenholz, Patrick F. Riley, Oriol Vinyals, and George E. Dahl. Neural message passing for quantum chemistry.
 [9] David Goldberg, David Nichols, Brian M. Oki, and Douglas Terry. Using collaborative filtering to weave an information tapestry. Communications of the ACM, 35(12):61–70, 1992.
 [10] William L. Hamilton, Rex Ying, and Jure Leskovec. Inductive representation learning on large graphs. arXiv preprint arXiv:1706.02216, 2017.
 [11] Prateek Jain and Inderjit S Dhillon. Provable inductive matrix completion. arXiv preprint arXiv:1306.0626, 2013.
 [12] Vassilis Kalofolias, Xavier Bresson, Michael Bronstein, and Pierre Vandergheynst. Matrix completion on graphs. arXiv preprint arXiv:1408.1717, 2014.
 [13] Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
 [14] Thomas N. Kipf and Max Welling. Variational graph autoencoders. NIPS Bayesian Deep Learning Workshop, 2016.
 [15] Thomas N. Kipf and Max Welling. Semisupervised classification with graph convolutional networks. ICLR, 2017.
 [16] Yehuda Koren, Robert Bell, and Chris Volinsky. Matrix factorization techniques for recommender systems. Computer, 42(8):30–37, August 2009.
 [17] Joonseok Lee, Seungyeon Kim, Guy Lebanon, and Yoram Singer. Local lowrank matrix approximation. In Sanjoy Dasgupta and David McAllester, editors, Proceedings of the 30th International Conference on Machine Learning (ICML), volume 28 of Proceedings of Machine Learning Research, pages 82–90, Atlanta, Georgia, USA, 17–19 Jun 2013. PMLR.
 [18] Xin Li and Hsinchun Chen. Recommendation as link prediction in bipartite graphs: A graph kernelbased machine learning approach. Decision Support Systems, 54(2):880 – 890, 2013.
 [19] Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. ICLR, 2016.
 [20] Andriy Mnih and Ruslan R. Salakhutdinov. Probabilistic matrix factorization. In Advances in neural information processing systems, pages 1257–1264, 2008.
 [21] Federico Monti, Davide Boscaini, Jonathan Masci, Emanuele Rodolà, Jan Svoboda, and Michael M Bronstein. Geometric deep learning on graphs and manifolds using mixture model cnns. CVPR, 2017.
 [22] Federico Monti, Michael M. Bronstein, and Xavier Bresson. Geometric matrix completion with recurrent multigraph neural networks. NIPS, 2017.
 [23] Mathias Niepert, Mohamed Ahmed, and Konstantin Kutzkov. Learning convolutional neural networks for graphs. In Proceedings of the 33rd annual international conference on machine learning. ACM, 2016.
 [24] Michael J Pazzani and Daniel Billsus. Contentbased recommendation systems. In The adaptive web, pages 325–341. Springer, 2007.
 [25] Nikhil Rao, HsiangFu Yu, Pradeep K. Ravikumar, and Inderjit S. Dhillon. Collaborative filtering with graph information: Consistency and scalable methods. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett, editors, Advances in Neural Information Processing Systems 28, pages 2107–2115. Curran Associates, Inc., 2015.
 [26] Ruslan Salakhutdinov, Andriy Mnih, and Geoffrey Hinton. Restricted boltzmann machines for collaborative filtering. In Proceedings of the 24th international conference on Machine learning, pages 791–798. ACM, 2007.

[27]
Suvash Sedhain, Aditya Krishna Menon, Scott Sanner, and Lexing Xie.
Autorec: Autoencoders meet collaborative filtering.
In Proceedings of the 24th International Conference on World Wide Web, pages 111–112. ACM, 2015.  [28] Nitish Srivastava, Geoffrey E. Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1):1929–1958, 2014.
 [29] Florian Strub, Romaric Gaudel, and Jérémie Mary. Hybrid recommender system based on autoencoders. In Proceedings of the 1st Workshop on Deep Learning for Recommender Systems, DLRS 2016, pages 11–16, New York, NY, USA, 2016. ACM.
 [30] Fei Tian, Bin Gao, Qing Cui, Enhong Chen, and TieYan Liu. Learning deep representations for graph clustering. In AAAI, pages 1293–1299, 2014.
 [31] Miao Xu, Rong Jin, and ZhiHua Zhou. Speedup matrix completion with side information: Application to multilabel learning. In Advances in Neural Information Processing Systems, pages 2301–2309, 2013.
 [32] Yin Zheng, Bangsheng Tang, Wenkui Ding, and Hanning Zhou. A neural autoregressive approach to collaborative filtering. In Proceedings of the 33nd International Conference on Machine Learning, pages 764–773, 2016.
Comments
There are no comments yet.