Papers
Topics
Authors
Recent
Gemini 2.5 Flash
Gemini 2.5 Flash
102 tokens/sec
GPT-4o
59 tokens/sec
Gemini 2.5 Pro Pro
43 tokens/sec
o3 Pro
6 tokens/sec
GPT-4.1 Pro
50 tokens/sec
DeepSeek R1 via Azure Pro
28 tokens/sec
2000 character limit reached

A Survey on Knowledge Graph-Based Recommender Systems (2003.00911v1)

Published 28 Feb 2020 in cs.IR, cs.LG, and stat.ML

Abstract: To solve the information explosion problem and enhance user experience in various online applications, recommender systems have been developed to model users preferences. Although numerous efforts have been made toward more personalized recommendations, recommender systems still suffer from several challenges, such as data sparsity and cold start. In recent years, generating recommendations with the knowledge graph as side information has attracted considerable interest. Such an approach can not only alleviate the abovementioned issues for a more accurate recommendation, but also provide explanations for recommended items. In this paper, we conduct a systematical survey of knowledge graph-based recommender systems. We collect recently published papers in this field and summarize them from two perspectives. On the one hand, we investigate the proposed algorithms by focusing on how the papers utilize the knowledge graph for accurate and explainable recommendation. On the other hand, we introduce datasets used in these works. Finally, we propose several potential research directions in this field.

User Edit Pencil Streamline Icon: https://streamlinehq.com
Authors (7)
  1. Qingyu Guo (12 papers)
  2. Fuzhen Zhuang (97 papers)
  3. Chuan Qin (43 papers)
  4. Hengshu Zhu (66 papers)
  5. Xing Xie (220 papers)
  6. Hui Xiong (244 papers)
  7. Qing He (88 papers)
Citations (661)

Summary

This survey paper provides a comprehensive overview of knowledge graph (KG)-based recommender systems, categorizing existing approaches and discussing their practical implications and potential future directions. The core idea behind these systems is to leverage the rich side information and structural properties of KGs to address common challenges in traditional recommender systems, such as data sparsity and cold start, while also enhancing explainability.

The paper groups KG-based recommender systems into three main categories based on how they utilize KG information: embedding-based methods, path-based methods, and unified methods.

Embedding-based Methods

These methods primarily utilize Knowledge Graph Embedding (KGE) techniques to encode entities and relations in the KG into low-dimensional vectors. These embeddings are then integrated into the recommendation framework to enrich user or item representations.

  1. Item-only KG: KGs are built focusing on items and their attributes (e.g., movies, actors, genres). KGE models (like TransE, TransR, DistMult) learn embeddings for items and attributes. These item/attribute embeddings are combined with representations derived from user-item interaction data.
    • Implementation: Item embeddings are often learned by applying KGE models to triples like (movie, directed_by, director). The final item representation might be a combination of its learned embedding from the KG and potentially other content features (text, visual) or collaborative filtering factors. User representations are typically learned from interaction data or aggregated item embeddings. A scoring function (e.g., inner product, multilayer perceptron) is used to predict user preference.
    • Examples: CKE [293(9672.29396)73] uses TransR for structural knowledge and combines it with textual/visual features via autoencoders for item representation. DKN [317(8876.31861)75] uses TransD for entity embeddings in news content, combining them with text embeddings via a CNN and using attention for user representation from clicked news. KSR [huang2018improving] uses TransE to embed items and attributes, integrating them into a GRU-based sequential recommender via a knowledge-enhanced memory network.
    • Multi-task Learning: Some approaches jointly train a recommendation task (predicting user-item interaction) and a KG-related task (e.g., KG completion). This allows mutual reinforcement, sharing item embeddings between tasks. MKR [330(8558.33134)11] uses a cross-content compress unit to link item embeddings in the recommendation module with entity embeddings in the KGE module. KTUP [330(8558.33137)05] jointly trains recommendation (using a translation-based model) and KG completion (using TransH). RCF [333(1184.33311)88] uses DistMult for KGE and models user preference hierarchically based on relation types and values.
  2. User-Item KG: KGs are constructed to include users, items, and their relations (including interaction data, item attributes, and potentially user attributes or social links). KGE models are applied to this joint graph.
    • Implementation: Embeddings for users, items, and relations are learned simultaneously. User preference can be modeled as a relation prediction problem in the KG, or by using scoring functions based on the user and item embeddings, sometimes incorporating relation embeddings.
    • Examples: CFKG [zhang2018learning] builds a user-item KG and models preference based on the distance between user/item embeddings under a specific relation (e.g., 'buy'). SHINE [wang2018shine] builds a sentiment network alongside social and profile networks, embedding them via autoencoders for celebrity recommendation.

Path-based Methods

These methods leverage the connectivity patterns between entities in a user-item graph (often a heterogeneous information network or HIN) to infer relationships and make recommendations.

  1. Meta-path/Meta-graph based: Define or discover specific sequences of relations (meta-paths) or graph structures (meta-graphs) connecting users and items. The similarity or features derived from these paths/graphs are used for recommendation.
    • Implementation: Similarity measures like PathSim [sun2011pathsim] can quantify the relatedness of entities along defined meta-paths. These similarity scores can be used as regularization terms in collaborative filtering (e.g., matrix factorization) or to enrich the user-item matrix. More advanced methods learn embeddings for paths or meta-graphs.
    • Examples: Hete-MF [yu2013collaborative] and Hete-CF [luo2014hete] use meta-path-based similarity as regularization in matrix factorization. HeteRec [yu2013recommendation] and HeteRec-p [yu2014personalized] diffuse user preference along meta-paths. FMG [zhao2017meta] uses meta-graphs instead of meta-paths and applies factorization machines. SemRec [shi2015semantic] considers positive and negative interaction paths. RuleRec [ma2019jointly] learns explainable rules as meta-paths from an external KG.
    • Explicit Path Embedding: Newer methods explicitly learn embeddings for paths connecting user-item pairs.
      • Implementation: Paths are extracted or sampled. Each path (sequence of entities and relations) is encoded using sequence models (e.g., RNN, LSTM) or other aggregation functions. Path embeddings are then aggregated (e.g., pooling, attention) to represent the user-item connection, which is used to compute the preference score.
      • Examples: MCRec [hu2018leveraging] uses CNNs to embed path instances and aggregates them via attention. RKGE [324(0323.32403)61] uses an RNN to encode user-to-item paths and aggregates their final states. KPRN [wang2019explainable] uses LSTM to encode paths of entity and relation embeddings. EIUM [huang2019explainable] also uses path encoding with attention for sequential recommendation, incorporating a multi-modal fusion constraint.
    • Reinforcement Learning for Path Exploration: RL is used to dynamically explore relevant paths in the KG to find connections between users and items, which can also serve as explanations.
      • Examples: PGPR [xian2019reinforcement] formulates path finding as a Markov decision process, training an agent to discover relevant paths. EKar* [song2019explainable] also uses RL for explainable recommendation based on KG paths.

Unified Methods

These methods combine the benefits of semantic embeddings and structural connectivity by propagating information along the graph structure, often using Graph Neural Networks (GNNs). The propagation process refines entity/user embeddings by incorporating information from their neighbors up to a certain hop distance.

  1. Preference Propagation (User-centric): Propagates user preferences from historical interacted items through their neighbors in the KG.
    • Implementation: Starting from a user's interacted items, information is propagated outwards along KG edges. At each step, the embeddings of neighboring entities are aggregated based on their relation to the head entity and potentially the target item. The aggregated information from multi-hop neighbors contributes to the user's final representation.
    • Example: RippleNet [326(9206.32717)39, wang2019exploring] propagates user preferences by iteratively aggregating information from k-hop ripple sets (triples whose head entities are k-1 hop relevant entities) and the candidate item embedding. AKUPM [tang2019akupm] and its extension RCoLM [li2019unifying] use attention mechanisms for preference propagation.
  2. Embedding Propagation (Item/Entity-centric): Refines item/entity representations by aggregating information from their multi-hop neighbors in the KG.
    • Implementation: GNN-like architectures are commonly used. Information from an entity's neighbors is aggregated, and the entity's embedding is updated based on its current embedding and the aggregated neighbor information. This is done iteratively for multiple layers (hops). Common aggregation operators include sum, concatenation, neighbor-only, or bi-interaction.
    • Examples: KGCN [330(8558.33134)17] uses graph convolutional networks to aggregate information from item neighbors inwardly, refining item representations. KGCN-LS [3330836] adds a label smoothness mechanism. KGAT [3330989] applies an attention network within a GCN-like framework to propagate embeddings outwards from entities themselves, enriching both user and item representations in a joint graph. KNI [qu2019end] considers interactions between item-side and user-side neighbors. IntentGC [zhao2019intentgc] uses a GCN framework fusing heterogeneous information for user-centric recommendation. AKGE [sha2019attentive] constructs a subgraph around the user-item pair and uses an attention-based GNN.

Explainability

A significant advantage of KG-based RS is their potential for explainability.

  • Path-based methods: The meta-paths or discovered paths naturally provide a reason for recommendation (e.g., recommending a movie because the user liked another movie by the same director, connected via the "like"-"directed_by" path). Models like KPRN [wang2019explainable], PGPR [xian2019reinforcement], and RuleRec [ma2019jointly] explicitly generate or utilize paths/rules as explanations.
  • Unified methods: The propagation process can reveal which neighbors and relations significantly influenced the final user or item representation or the preference score, offering a form of step-by-step reasoning.

Datasets and Applications

KG-based RS have been applied across various domains, including:

  • Movie: MovieLens, DoubanMovie. KGs are often built by linking movies to external KGs (Satori, DBpedia, Freebase) or by utilizing attributes within the datasets.
  • Book: Book-Crossing, Amazon-Book, DoubanBook, DBbook2014, IntentBooks. KGs are constructed similarly by linking books to external KGs or using internal attributes.
  • Music: Last.FM, KKBox. KGs link music to attributes or entities in external KGs (Freebase, Satori) or internal data.
  • Product: Amazon Product data, Alibaba Taobao. KGs leverage product attributes, reviews, categories, and user behaviors, sometimes linking to external KGs (Freebase).
  • POI: Yelp Challenge, Dianping-Food, CEM. KGs are built from check-ins, reviews, attributes, and potentially external geographic or business KGs.
  • News: Bing-News. KGs connect news entities to concepts in external KGs (Satori) to capture higher-level semantic relations.
  • Social Platform: Weibo, DBLP, MeetUp. KGs incorporate social connections, user profiles, and entities related to recommended targets (celebrities, conferences, meetings).

Constructing the KG involves identifying relevant entities (users, items, attributes, related concepts) and relations from the dataset itself (e.g., user-item interaction, item categories, user demographics) and/or external KGs. Items are often mapped to entities in large-scale KGs to enrich their representation.

Future Directions

The survey identifies several promising areas for future research:

  • Dynamic Recommendation: Modeling rapidly changing user interests by incorporating dynamic KG networks or time-aware propagation mechanisms.
  • Multi-task Learning: Exploring joint training with other KG-related tasks beyond completion, such as entity linking or classification, to further leverage KG structure and content.
  • Cross-Domain Recommendation: Using KGs to transfer knowledge and connect users/items across different recommendation domains, especially in cold-start scenarios.
  • Knowledge Enhanced Language Representation: Integrating KG information more deeply into LLMs for text-based items (like news or reviews) to improve content understanding for recommendation.
  • Knowledge Graph Embedding Method Comparison: Conducting thorough empirical studies to understand which KGE methods are most effective for specific recommendation tasks, datasets, and model architectures.
  • User Side Information: More comprehensively integrating diverse user attributes, social networks, and behavioral data into the KG structure for richer user modeling.

In conclusion, the paper highlights the significant progress and potential of KG-based recommender systems in improving accuracy and interpretability by effectively leveraging structured knowledge from KGs. The categorization and discussion of existing methods and datasets provide a valuable framework for understanding the field and guiding future research and practical implementation.