Knowledge-aware Graph Neural Networks with Label Smoothness Regularization for Recommender Systems

Introduction

Recommender systems are widely used in Internet applications to meet user’s personalized interests and alleviate the information overload (Covington et al. 2016; Wang et al. 2018a; Ying et al. 2018). Traditional recommender systems that are based on collaborative filtering (Koren et al. 2009; Wang et al. 2017b) usually suffer from the cold-start problem and have trouble recommending brand new items that have not yet been heavily explored by the users. The sparsity issue can be addressed by introducing additional sources of information such as user/item profiles (Wang et al. 2018b) or social networks (Wang et al. 2017b).

Knowledge graphs (KGs) capture structured information and relations between a set of entities (Zhang et al. 2016; Wang et al. 2018d; Huang et al. 2018; Yu et al. 2014; Zhao et al. 2017; Hu et al. 2018; Wang et al. 2018c; Sun et al. 2018; Wang et al. 2019b; Wang et al. 2019c; Wang et al. 2019a). KGs are heterogeneous graphs in which nodes correspond to entities (e.g., items or products, as well as their properties and characteristics) and edges correspond to relations. KGs provide connectivity information between items via different types of relations and thus capture semantic relatedness between the items.

The core challenge in utilizing KGs in recommender systems is to learn how to capture user-specific item-item relatedness captured by the KG. Existing KG-aware recommender systems can be classified into path-based methods (Yu et al. 2014; Zhao et al. 2017; Hu et al. 2018), embedding-based methods (Zhang et al. 2016; Wang et al. 2018d; Huang et al. 2018; Wang et al. 2019b), and hybrid methods (Wang et al. 2018c; Sun et al. 2018; Wang et al. 2019c). However, these approaches rely on manual feature engineering, are unable to perform end-to-end training, and have poor scalability. Graph Neural Networks (GNNs), which aggregate node feature information from node’s local network neighborhood using neural networks, represent a promising advancement in graph-based representation learning (Bruna et al. 2014; Defferrard et al. 2016; Kipf and Welling 2017; Duvenaud et al. 2015; Niepert et al. 2016; Hamilton et al. 2017). Recently, several works developed GNNs architecture for recommender systems (Ying et al. 2018; Monti et al. 2017; van den Berg et al. 2017; Wu et al. 2018; Wang et al. 2019c), but these approaches are mostly designed for homogeneous bipartite user-item interaction graphs or user-/item-similarity graphs. It remains an open question how to extend GNNs architecture to heterogeneous knowledge graphs.

In this paper, we develop Knowledge-aware Graph Neural Networks with Label Smoothness regularization (KGNN-LS) that extends GNNs architecture to knowledge graphs to simultaneously capture semantic relationships between the items as well as personalized user preferences and interests. To account for the relational heterogeneity in KGs, similar to (Wang et al. 2019c), we use a trainable and personalized relation scoring function that transforms the KG into a user-specific weighted graph, which characterizes both the semantic information of the KG as well as user’s personalized interests. For example, in the movie recommendation setting the relation scoring function could learn that a given user really cares about “director” relation between movies and persons, while somebody else may care more about the “lead actor” relation. Using this personalized weighted graph, we then apply a graph neural network that for every item node computes its embedding by aggregating node feature information over the local network neighborhood of the item node. This way the embedding of each item captures it’s local KG structure in a user-personalized way.

A significant difference between our approach and traditional GNNs is that the edge weights in the graph are not given as input. We set them using user-specific relation scoring function that is trained in a supervised fashion. However, the added flexibility of edge weights makes the learning process prone to overfitting, since the only source of supervised signal for the relation scoring function is coming from user-item interactions (which are sparse in general). To remedy this problem, we develop a technique for regularization of edge weights during the learning process, which leads to better generalization. We develop an approach based on label smoothness (Zhu et al. 2003; Zhang and Lee 2007), which assumes that adjacent entities in the KG are likely to have similar user relevancy labels/scores. In our context this assumption means that users tend to have similar preferences to items that are nearby in the KG. We prove that label smoothness regularization is equivalent to label propagation and we design a leave-one-out loss function for label propagation to provide extra supervised signal for learning the edge scoring function. We show that the knowledge-aware graph neural networks and label smoothness regularization can be unified under the same framework, where label smoothness can be seen as a natural choice of regularization on knowledge-aware graph neural networks.

We apply the proposed method to four real-world datasets of movie, book, music, and restaurant recommendations, in which the first three datasets are public datasets and the last is from Meituan-Dianping Group. Experiments show that our method achieves significant gains over state-of-the-art methods in recommendation accuracy. We also show that our method maintains strong recommendation performance in the cold-start scenarios where user-item interactions are sparse.

Related Work

Graph Neural Networks (or Graph Convolutional Neural Networks, GCNs) aim to generalize convolutional neural networks to non-Euclidean domains (such as graphs) for robust feature learning. Bruna et al. (Bruna et al. 2014) define the convolution in Fourier domain and calculate the eigendecomposition of the graph Laplacian, Defferrard et al. (Defferrard et al. 2016) approximate the convolutional filters by Chebyshev expansion of the graph Laplacian, and Kipf et al. (Kipf and Welling 2017) propose a convolutional architecture via a first-order approximation. In contrast to these spectral GCNs, non-spectral GCNs operate on the graph directly and apply “convolution” (i.e., weighted average) to local neighbors of a node (Duvenaud et al. 2015; Niepert et al. 2016; Hamilton et al. 2017).

Recently, researchers also deployed GNNs in recommender systems: PinSage (Ying et al. 2018) applies GNNs to the pin-board bipartite graph in Pinterest. Monti et al. (Monti et al. 2017) and Berg et al. (van den Berg et al. 2017) model recommender systems as matrix completion and design GNNs for representation learning on user-item bipartite graphs. Wu et al. (Wu et al. 2018) use GNNs on user/item structure graphs to learn user/item representations. The difference between these works and ours is that they are all designed for homogeneous bipartite graphs or user/item-similarity graphs where GNNs can be used directly, while here we investigate GNNs for heterogeneous KGs. Wang et al. (Wang et al. 2019c) use GCNs in KGs for recommendation, but simply applying GCNs to KGs without proper regularization is prone to overfitting and leads to performance degradation as we will show later. Schlichtkrull et al. also propose using GNNs to model KGs (Schlichtkrull et al. 2018), but not for the purpose of recommendations.

2. Semi-supervised Learning on Graphs

The goal of graph-based semi-supervised learning is to correctly label all nodes in a graph given that only a few nodes are labeled. Prior work often makes assumptions on the distribution of labels over the graph, and one common assumption is smooth variation of labels of nodes across the graph. Based on different settings of edge weights in the input graph, these methods are classified as: (1) Edge weights are assumed to be given as input and therefore fixed (Zhu et al. 2003; Zhou et al. 2004; Baluja et al. 2008); (2) Edge weights are parameterized and therefore learnable (Zhang and Lee 2007; Wang and Zhang 2008; Karasuyama and Mamitsuka 2013). Inspired by these methods, we design a module of label smoothness regularization in our proposed model. The major distinction of our work is that the label smoothness constraint is not used for semi-supervised learning on graphs, but serves as regularization to assist the learning of edge weights and achieves better generalization for recommender systems.

3. Recommendations with Knowledge Graphs

In general, existing KG-aware recommender systems can be classified into three categories: (1) Embedding-based methods (Zhang et al. 2016; Wang et al. 2018d; Huang et al. 2018; Wang et al. 2019b) pre-process a KG with knowledge graph embedding (KGE) (Wang et al. 2017a) algorithms, then incorporate learned entity embeddings into recommendation. Embedding-based methods are highly flexible in utilizing KGs to assist recommender systems, but the KGE algorithms focus more on modeling rigorous semantic relatedness (e.g., TransE (Bordes et al. 2013) assumes $head+relation=tail$), which are more suitable for graph applications such as link prediction rather than recommendations. In addition, embedding-based methods usually lack an end-to-end way of training. (2) Path-based methods (Yu et al. 2014; Zhao et al. 2017; Hu et al. 2018) explore various patterns of connections among items in a KG (a.k.a meta-path or meta-graph) to provide additional guidance for recommendations. Path-based methods make use of KGs in a more intuitive way, but they rely heavily on manually designed meta-paths/meta-graphs, which are hard to tune in practice. (3) Hybrid methods (Wang et al. 2018c; Sun et al. 2018; Wang et al. 2019c) combine the above two categories and learn user/item embeddings by exploiting the structure of KGs. Our proposed model can be seen as an instance of hybrid methods.

Problem Formulation

We begin by describing the KG-aware recommendations problem and introducing notation. In a typical recommendation scenario, we have a set of users $\mathcal{U}$ and a set of items $\mathcal{V}$. The user-item interaction matrix ${\bf Y}$ is defined according to users’ implicit feedback, where $y_{uv}=1$ indicates that user $u$ has engaged with item $v$, such as clicking, watching, or purchasing. We also have a knowledge graph $\mathcal{G}=\{(h,r,t)\}$ available, in which $h\in\mathcal{E}$, $r\in\mathcal{R}$, and $t\in\mathcal{E}$ denote the head, relation, and tail of a knowledge triple, $\mathcal{E}$ and $\mathcal{R}$ are the set of entities and relations in the knowledge graph, respectively. For example, the triple (The Silence of the Lambs, film.film.star, Anthony Hopkins) states the fact that Anthony Hopkins is the leading actor in film “The Silence of the Lambs”. In many recommendation scenarios, an item $v\in\mathcal{V}$ corresponds to an entity $e\in\mathcal{E}$ (e.g., item “The Silence of the Lambs” in MovieLens also appears in the knowledge graph as an entity). The set of entities $\mathcal{E}$ is composed from items $\mathcal{V}$ ($\mathcal{V}\subseteq\mathcal{E}$) as well as non-items $\mathcal{E}\backslash\mathcal{V}$ (e.g. nodes corresponding to item/product properties). Given user-item interaction matrix $\bf Y$ and knowledge graph $\mathcal{G}$, our task is to predict whether user $u$ has potential interest in item $v$ with which he/she has not engaged before. Specifically, we aim to learn a prediction function ${\hat{y}}_{uv}=\mathcal{F}(u,v|\Theta,\bf Y,\mathcal{G})$, where ${\hat{y}}_{uv}$ denotes the probability that user $u$ will engage with item $v$, and $\Theta$ are model parameters of function $\mathcal{F}$.

We list the key symbols used in this paper in Table 1.

Our Approach

In this section, we first introduce knowledge-aware graph neural networks and label smoothness regularization, respectively, then we present the unified model.

The first step of our approach is to transform a heterogeneous KG into a user-personalized weighted graph, which characterizes user’s preferences. To this end, similar to (Wang et al. 2019c), we use a user-specific relation scoring function $s_{u}(r)$ that provides the importance of relation $r$ for user $u$: $s_{u}(r)=g({\bf u},{\bf r})$, where ${\bf u}$ and ${\bf r}$ are feature vectors of user $u$ and relation type $r$, respectively, and $g$ is a differentiable function such as inner product. Intuitively, $s_{u}(r)$ characterizes the importance of relation $r$ to user $u$. For example, a user may be more interested in movies that have the same director with the movies he/she watched before, but another user may care more about the leading actor of movies.

2. Label Smoothness Regularization

It is worth noticing a significant difference between our model and GNNs: In traditional GNNs, edge weights of the input graph are fixed; but in our model, edge weights ${\bf D}_{u}^{-1/2}{\bf A}_{u}{\bf D}_{u}^{-1/2}$ in Eq. (1) are learnable (including possible parameters of function $g$ and feature vectors of users and relations) and also requires supervised training like $\bf W$. Though enhancing the fitting ability of the model, this will inevitably make the optimization process prone to overfitting, since the only source of supervised signal is from user-item interactions outside GNN layers. Moreover, edge weights do play an essential role in representation learning on graphs, as highlighted by a large amount of prior works (Zhu et al. 2003; Zhang and Lee 2007; Wang and Zhang 2008; Karasuyama and Mamitsuka 2013; Velickovic et al. 2018). Therefore, more regularization on edge weights is needed to assist the learning of entity representations and to help generalize to unobserved interactions more efficiently.

We show that the minimum-energy label function is harmonic by the following theorem:

w.r.t. Eq. (2) is harmonic, i.e., $l_{u}^{*}$ satisfies

Taking the derivative of the following equation

with respect to $l_{u}(e_{i})$ where $e_{i}\in\mathcal{E}\backslash\mathcal{V}$, we have

The minimum-energy label function $l_{u}^{*}$ should satisfy that

The harmonic property indicates that the value of $l_{u}^{*}$ at each non-item entity $e_{i}\in\mathcal{E}\backslash\mathcal{V}$ is the average of its neighboring entities, which leads to the following label propagation scheme (Zhu et al. 2005):

Propagate labels for all entities: $l_{u}(\mathcal{E})\leftarrow{\bf D}_{u}^{-1}{\bf A}_{u}l_{u}(\mathcal{E})$, where $l_{u}(\mathcal{E})$ is the vector of labels for all entities;

Reset labels of all items to initial labels: $l_{u}(\mathcal{V})\leftarrow{\bf Y}[u,\mathcal{V}]^{\top}$, where $l_{u}(\mathcal{V})$ is the vector of labels for all items and ${\bf Y}[u,\mathcal{V}]=[y_{uv_{1}},y_{uv_{2}},\cdots]$ are initial labels;

will lead to $l_{u}\rightarrow l_{u}^{*}$.

Then the label propagation scheme is equivalent to

where $l_{u}^{(0)}(\mathcal{E}\backslash\mathcal{V})$ is the initial value for $l_{u}(\mathcal{E}\backslash\mathcal{V})$. Now we show that $lim_{n\rightarrow\infty}({\bf P}_{EE})^{n}l_{u}^{(0)}(\mathcal{E}\backslash\mathcal{V})={\bf 0}$. Since $\bf P$ is row-normalized and ${\bf P}_{EE}$ is a sub-matrix of $\bf P$, we have

for all possible row index $i$. Therefore,

As $n$ goes infinity, the row sum of $({\bf P}_{EE})^{n}$ converges to zero, which implies that $({\bf P}_{EE})^{n}l_{u}^{(0)}(\mathcal{E}\backslash\mathcal{V})\rightarrow{\bf 0}$. It’s clear that the choice of initial value $l_{u}^{(0)}(\mathcal{E}\backslash\mathcal{V})$ does not affect the convergence.

Since $lim_{n\rightarrow\infty}({\bf P}_{EE})^{n}l_{u}^{(0)}(\mathcal{E}\backslash\mathcal{V})={\bf 0}$, Eq. (6) becomes

This is the unique fixed point and therefore the unique solution to Eq. (5). Repeating the steps in Theorem 2 leads to

Theorem 2 provides a way for reaching the minimum-energy of relevancy label function $E$. However, $l_{u}^{*}$ does not provide any signal for updating the edge weights matrix ${\bf A}_{u}$, since the labeled part of $l_{u}^{*}$, i.e., $l_{u}^{*}(\mathcal{V})$, equals their true relevancy labels ${\bf Y}[u,\mathcal{V}]$; Moreover, we do not know true relevancy labels for the unlabeled nodes $l_{u}^{*}(\mathcal{E}\backslash\mathcal{V})$.

To solve the issue, we propose minimizing the leave-one-out loss (Zhang and Lee 2007). Suppose we hold out a single item $v$ and treat it unlabeled. Then we predict its label by using the rest of (labeled) items and (unlabeled) non-item entities. The prediction process is identical to label propagation in Theorem 2, except that the label of item $v$ is hidden and needs to be calculated. This way, the difference between the true relevancy label of $v$ (i.e., $y_{uv}$) and the predicted label $\hat{l}_{u}(v)$ serves as a supervised signal for regularizing edge weights:

where $J$ is the cross-entropy loss function. Given the regularization in Eq. (7), an ideal edge weight matrix $\bf A$ should reproduce the true relevancy label of each held-out item while also satisfying the smoothness of relevancy labels.

3. The Unified Loss Function

Combining knowledge-aware graph neural networks and LS regularization, we reach the following complete loss function:

where $\|\mathcal{F}\|^{2}_{2}$ is the L2-regularizer, $\lambda$ and $\gamma$ are balancing hyper-parameters. In Eq. (8), the first term corresponds to the part of GNN that learns the transformation matrix $\bf{W}$ and edge weights $\bf{A}$ simultaneously, while the second term $R(\cdot)$ corresponds to the part of label smoothness that can be seen as adding constraint on edge weights $\bf{A}$. Therefore, $R(\cdot)$ serves as regularization on $\bf{A}$ to assist GNN in learning edge weights.

It is also worth noticing that the first term can be seen as feature propagation on the KG while the second term $R(\cdot)$ can be seen as label propagation on the KG. A recommender for a specific user $u$ is actually a mapping from item features to user-item interaction labels, i.e., $\mathcal{F}_{u}:{\bf E}_{v}\rightarrow y_{uv}$ where ${\bf E}_{v}$ is the feature vector of item $v$. Therefore, Eq. (8) utilizes the structural information of the KG on both the feature side and the label side of $\mathcal{F}_{u}$ to capture users’ higher-order preferences.

4. Discussion

How can the knowledge graph help find users’ interests? To intuitively understand the role of the KG, we make an analogy with a physical equilibrium model as shown in Figure 2. Each entity/item is seen as a particle, while the supervised positive user-relevancy signal acts as the force pulling the observed positive items up from the decision boundary and the negative items signal acts as the force pushing the unobserved items down. Without the KG (Figure 2(a)), these items are only loosely connected with each other through the collaborative filtering effect (which is not drawn here for clarity). In contrast, edges in the KG serve as the rubber bands that impose explicit constraints on connected entities. When number of layers is $L=1$ (Figure 2(b)), representation of each entity is a mixture of itself and its immediate neighbors, therefore, optimizing on the positive items will simultaneously pull their immediate neighbors up together. The upward force goes deeper in the KG with the increase of $L$ (Figure 2(c)), which helps explore users’ long-distance interests and pull up more positive items. It is also interesting to note that the proximity constraint exerted by the KG is personalized since the strength of the rubber band (i.e., $s_{u}(r)$) is user-specific and relation-specific: One user may prefer relation $r_{1}$ (Figure 2(b)) while another user (with same observed items but different unobserved items) may prefer relation $r_{2}$ (Figure 2(d)).

Despite the force exerted by edges in the KG, edge weights may be set inappropriately, for example, too small to pull up the unobserved items (i.e., rubber bands are too weak). Next, we show by Figure 2(e) that how the label smoothness assumption helps regularizing the learning of edge weights. Suppose we hold out the positive sample in the upper left and we intend to reproduce its label by the rest of items. Since the true relevancy label of the held-out sample is 1 and the upper right sample has the largest label value, the LS regularization term $R({\bf A})$ would enforce the edges with arrows to be large so that the label can “flow” from the blue one to the striped one as much as possible. As a result, this will tighten the rubber bands (denoted by arrows) and encourage the model to pull up the two upper pink items to a greater extent.

Experiments

In this section, we evaluate the proposed KGNN-LS model, and present its performance on four real-world scenarios: movie, book, music, and restaurant recommendations.

We utilize the following four datasets in our experiments for movie, book, music, and restaurant recommendations, respectively, in which the first three are public datasets and the last one is from Meituan-Dianping Group. We use Satori https://searchengineland.com/library/bing/bing-satori, a commercial KG built by Microsoft, to construct sub-KGs for MovieLens-20M, Book-Crossing, and Last.FM datasets. The KG for Dianping-Food dataset is constructed by the internal toolkit of Meituan-Dianping Group. Further details of datasets are provided in Appendix A.

MovieLens-20M https://grouplens.org/datasets/movielens/ is a widely used benchmark dataset in movie recommendations, which consists of approximately 20 million explicit ratings (ranging from 1 to 5) on the MovieLens website. The corresponding KG contains 102,569 entities, 499,474 edges and 32 relation-types.

Book-Crossing http://www2.informatik.uni-freiburg.de/~cziegler/BX/ contains 1 million ratings (ranging from 0 to 10) of books in the Book-Crossing community. The corresponding KG contains 25,787 entities, 60,787 edges and 18 relation-types.

Last.FM https://grouplens.org/datasets/hetrec-2011/ contains musician listening information from a set of 2 thousand users from Last.fm online music system. The corresponding KG contains 9,366 entities, 15,518 edges and 60 relation-types.

Dianping-Food is provided by Dianping.com https://www.dianping.com/, which contains over 10 million interactions (including clicking, buying, and adding to favorites) between approximately 2 million users and 1 thousand restaurants. The corresponding KG contains 28,115 entities, 160,519 edges and 7 relation-types.

The statistics of the four datasets are shown in Table 2.

2. Baselines

We compare the proposed KGNN-LS model with the following baselines for recommender systems, in which the first two baselines are KG-free while the rest are all KG-aware methods. The hyper-parameter setting of KGNN-LS is provided in Appendix B.

SVD (Koren 2008) is a classic CF-based model using inner product to model user-item interactions. We use the unbiased version (i.e., the predicted engaging probability is modeled as $y_{uv}={\bf u}^{\top}{\bf v}$). The dimension and learning rate for the four datasets are set as: $d=8$, $\eta=0.5$ for MovieLens-20M, Book-Crossing; $d=8$, $\eta=0.1$ for Last.FM; $d=32$, $\eta=0.1$ for Dianping-Food.

LibFM (Rendle 2012) is a widely used feature-based factorization model for CTR prediction. We concatenate user ID and item ID as input for LibFM. The dimension is set as $\{1,1,8\}$ and the number of training epochs is $50$ for all datasets.

LibFM + TransE extends LibFM by attaching an entity representation learned by TransE (Bordes et al. 2013) to each user-item pair. The dimension of TransE is $32$ for all datasets.

PER (Yu et al. 2014) is a representative of path-based methods, which treats the KG as heterogeneous information networks and extracts meta-path based features to represent the connectivity between users and items. We use manually designed “user-item-attribute-item” as meta-paths, i.e., “user-movie-director-movie”, “user-movie-genre-movie”, and “user-movie-star-movie” for MovieLens-20M; “user-book-author-book” and “user-book-genre-book” for Book-Crossing, “user-musician-date_of_birth-musician” (date of birth is discretized), “user-musician-country-musician”, and “user-musician-genre-musician” for Last.FM; “user-restaurant-dish-restaurant”, “user-restaurant-business_area-restaurant”, “user-restaurant-tag-restaurant” for Dianping-Food. The settings of dimension and learning rate are the same as SVD.

CKE (Zhang et al. 2016) is a representative of embedding-based methods, which combines CF with structural, textual, and visual knowledge in a unified framework. We implement CKE as CF plus a structural knowledge module in this paper. The dimension of embedding for the four datasets are $64$, $128$, $64$, $64$. The training weight for KG part is $0.1$ for all datasets. The learning rate are the same as in SVD.

RippleNet (Wang et al. 2018c) is a representative of hybrid methods, which is a memory-network-like approach that propagates users’ preferences on the KG for recommendation. For RippleNet, $d=8$, $H=2$, $\lambda_{1}=10^{-6}$, $\lambda_{2}=0.01$, $\eta=0.01$ for MovieLens-20M; $d=16$, $H=3$, $\lambda_{1}=10^{-5}$, $\lambda_{2}=0.02$, $\eta=0.005$ for Last.FM; $d=32$, $H=2$, $\lambda_{1}=10^{-7}$, $\lambda_{2}=0.02$, $\eta=0.01$ for Dianping-Food.

3. Validating the Connection between 𝒢\mathcal{G} and 𝐘\bf Y

To validate the connection between the knowledge graph $\mathcal{G}$ and user-item interaction $\bf Y$, we conduct an empirical study where we investigate the correlation between the shortest path distance of two randomly sampled items in the KG and whether they have common user(s) in the dataset, that is there exist user(s) that interacted with both items. For MovieLens-20M and Last.FM, we randomly sample ten thousand item pairs that have no common users and have at least one common user, respectively, then count the distribution of their shortest path distances in the KG. The results are presented in Figure 3, which clearly show that if two items have common user(s) in the dataset, they are likely to be more close in the KG. For example, if two movies have common user(s) in MovieLens-20M, there is a probability of $0.92$ that they will be within 2 hops in the KG, while the probability is $0.80$ if they have no common user. This finding empirically demonstrates that exploiting the proximity structure of the KG can assist making recommendations. This also justifies our motivation to use label smoothness regularization to help learn entity representations.

4. Results

We evaluate our method in two experiment scenarios: (1) In top-$K$ recommendation, we use the trained model to select $K$ items with highest predicted click probability for each user in the test set, and choose $Recall@K$ to evaluate the recommended sets. (2) In click-through rate (CTR) prediction, we apply the trained model to predict each piece of user-item pair in the test set (including positive items and randomly selected negative items). We use $AUC$ as the evaluation metric in CTR prediction.

The results of top-$K$ recommendation and CTR prediction are presented in Tables 3 and 4, respectively, which show that KGNN-LS outperforms baselines by a significant margin. For example, the $AUC$ of KGNN-LS surpasses baselines by $5.1\%$, $6.9\%$, $8.3\%$, and $4.3\%$ on average in MovieLens-20M, Book-Crossing, Last.FM, and Dianping-Food datasets, respectively.

We also show daily performance of KGNN-LS and baselines on Dianping-Food to investigate performance stability. Figure 6 shows their $AUC$ score from September 1, 2018 to September 30, 2018. We notice that the curve of KGNN-LS is consistently above baselines over the test period; Moreover, the performance of KGNN-LS is also with low variance, which suggests that KGNN-LS is also robust and stable in practice.

4.2. Effectiveness of LS Regularization

Is the proposed LS regularization helpful in improving the performance of GNN? To study the effectiveness of LS regularization, we fix the dimension of hidden layers as $4$, $8$, and $16$, then vary $\lambda$ from $0$ to $5$ to see how performance changes. The results of $R@10$ in Last.FM dataset are plotted in Figure 6. It is clear that the performance of KGNN-LS with a non-zero $\lambda$ is better than $\lambda=0$ (the case of Wang et al. (Wang et al. 2019c)), which justifies our claim that LS regularization can assist learning the edge weights in a KG and achieve better generalization in recommender systems. But note that a too large $\lambda$ is less favorable, since it overwhelms the overall loss and misleads the direction of gradients. According to the experiment results, we find that a $\lambda$ between $0.1$ and $1.0$ is preferable in most cases.

4.3. Results in cold-start scenarios

One major goal of using KGs in recommender systems is to alleviate the sparsity issue. To investigate the performance of KGNN-LS in cold-start scenarios, we vary the size of training set of MovieLens-20M from $r=100\%$ to $r=20\%$ (while the validation and test set are kept fixed), and report the results of $AUC$ in Table 5. When $r=20\%$, $AUC$ decreases by $8.4\%$, $5.9\%$, $5.4\%$, $3.6\%$, $2.8\%$, and $4.1\%$ for the six baselines compared to the model trained on full training data ($r=100\%$), but the performance decrease of KGNN-LS is only $1.8\%$. This demonstrates that KGNN-LS still maintains predictive performance even when user-item interactions are sparse.

4.4. Hyper-parameters Sensitivity

We first analyze the sensitivity of KGNN-LS to the number of GNN layers $L$. We vary $L$ from $1$ to $4$ while keeping other hyper-parameters fixed. The results are shown in Table 6. We find that the model performs poorly when $L=4$, which is because a larger $L$ will mix too many entity embeddings in a given entity, which over-smoothes the representation learning on KGs. KGNN-LS achieves the best performance when $L=1$ or $2$ in the four datasets.

We also examine the impact of the dimension of hidden layers $d$ on the performance of KGNN-LS. The result in shown in Table 7. We observe that the performance is boosted with the increase of $d$ at the beginning, because more bits in hidden layers can improve the model capacity. However, the performance drops when $d$ further increases, since a too large dimension may overfit datasets. The best performance is achieved when $d=8\sim 64$.

5. Running Time Analysis

We also investigate the running time of our method with respect to the size of KG. We run experiments on a Microsoft Azure virtual machine with 1 NVIDIA Tesla M60 GPU, 12 Intel Xeon CPUs (E5-2690 v3 @2.60GHz), and 128GB of RAM. The size of the KG is increased by up to five times the original one by extracting more triples from Satori, and the running times of all methods on MovieLens-20M are reported in Figure 6. Note that the trend of a curve matters more than the real values, since the values are largely dependent on the minibatch size and the number of epochs (yet we did try to align the configurations of all methods). The result show that KGNN-LS exhibits strong scalability even when the KG is large.

Conclusion and Future Work

In this paper, we propose knowledge-aware graph neural networks with label smoothness regularization for recommendation. KGNN-LS applies GNN architecture to KGs by using user-specific relation scoring functions and aggregating neighborhood information with different weights. In addition, the proposed label smoothness constraint and leave-one-out loss provide strong regularization for learning the edge weights in KGs. We also discuss how KGs benefit recommender systems and how label smoothness can assist learning the edge weights. Experiment results show that KGNN-LS outperforms state-of-the-art baselines in four recommendation scenarios and achieves desirable scalability with respect to KG size.

In this paper, LS regularization is proposed for recommendation task with KGs. It is interesting to examine the LS assumption on other graph tasks such as link prediction and node classification. Investigating the theoretical relationship between feature propagation and label propagation is also a promising direction.

Acknowledgements. This research has been supported in part by NSF OAC-1835598, DARPA MCS, ARO MURI, Boeing, Docomo, Hitachi, Huawei, JD, Siemens, and Stanford Data Science Initiative.

References

Appendix

MovieLens-20M, Book-Crossing, and Last.FM dataset contain explicit feedbacks data (Last.FM provides the listening count as weight for each user-item interaction). Therefore, we transform them into implicit feedback, where each entry is marked with 1 indicating that the user has rated the item positively. The threshold of positive rating is 4 for MovieLens-20M, while no threshold is set for Book-Crossing and Last.FM due to their sparsity. Additionally, we randomly sample an unwatched set of items and mark them as 0 for each user, the number of which equals his/her positively-rated ones.

We use Microsoft Satori to construct the KGs for MovieLens-20M, Book-Crossing, and Last.FM dataset. In one triple in Satori KG, the head and tail are either IDs or textual content, and the relation is with the form “domain.head_category.tail_category” (e.g., “book.book.author”). We first select a subset of triples from the whole Satori KG with a confidence level greater than 0.9. Given the sub-KG, we collect Satori IDs of all valid movies/books/musicians by matching their names with tail of triples (head, film.film.name, tail), (head, book.book.title, tail), or (head, type.object.name, tail), for the three datasets. Items with multiple matched or no matched entities are excluded for simplicity. After having the set of item IDs, we match these item IDs with the head of all triples in Satori sub-KG, and select all well-matched triples as the final KG for each dataset.

Dianping-Food dataset is collected from Dianping.com, a Chinese group buying website hosting consumer reviews of restaurants similar to Yelp. We select approximately 10 million interactions between users and restaurants in Dianping.com from May 1, 2015 to December 12, 2018. The types of positive interactions include clicking, buying, and adding to favorites, and we sample negative interactions for each user. The KG for Dianping-Food is collected from Meituan Brain, an internal knowledge graph built for dining and entertainment by Meituan-Dianping Group. The types of entities include POI (restaurant), city, first-level and second-level category, star, business area, dish, and tag; The types of relations correspond to the types of entities (e.g., “organization.POI.has_dish”).

B Additional Details on Hyper-parameter Searching

In KGNN-LS, we set functions $g$ and $f$ as inner product, $\sigma$ as ReLU for non-last-layers and $tanh$ for the last-layer. Note that the size of neighbors of an entity in a KG may vary significantly over the KG. To keep the computation more efficient, we uniformly sample a fixed-size set of neighbors for each entity instead of using its full set of neighbors. The number of sampled neighbors for each entity is denoted by $S$. Hyper-parameter settings are given in Table 8, which are determined by optimizing $R@10$ on a validation set. The search spaces for hyper-parameters are as follows:

$\gamma=\{10^{-9},10^{-8},10^{-7},2\times 10^{-7},5\times 10^{-7},10^{-6},2\times 10^{-6},5\times 10^{-6},10^{-5},2\times 10^{-5},5\times 10^{-5},10^{-4},2\times 10^{-4},5\times 10^{-4},10^{-3}\}$;

$\eta=\{10^{-5},2\times 10^{-5},5\times 10^{-5},10^{-4},2\times 10^{-4},5\times 10^{-4},10^{-3},2\times 10^{-3},5\times 10^{-3},10^{-2},2\times 10^{-2},5\times 10^{-2},10^{-1}\}$.

For each dataset, the ratio of training, validation, and test set is $6:2:2$. Each experiment is repeated $5$ times, and the average performance is reported. All trainable parameters are optimized by Adam algorithm. The code of KGNN-LS is implemented with Python 3.6, TensorFlow 1.12.0, and NumPy 1.14.3.