The proposed KGRec model

Our proposed KGRec model is composed of four major components: the Collaborative Knowledge Graph, the Embedding Layer, the Attentive Embedding Propagation Layer, and the Prediction Layer. The Collaborative Knowledge Graph is first constructed from the input data, where both users and items are represented as nodes, and their interactions, together with external knowledge, form the edges of the graph. Subsequently, the Embedding Layer parameterizes each node by mapping it into a low-dimensional vector representation, which serves as the foundation for learning meaningful semantic features. Building on this, the Attentive Embedding Propagation Layer enhances the expressiveness of node representations by iteratively aggregating information not only from direct neighbors but also from higher-order neighbors, while the attention mechanism assigns different weights to neighbors according to their relative importance. Finally, the Prediction Layer computes the compatibility score between a user and an item based on their learned embeddings, and this score is used to generate the final recommendation. An overview of the overall architecture of our proposed KGRec model is illustrated in Fig 1.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 1. The overall architecture of our proposed KGRec model.

https://doi.org/10.1371/journal.pone.0344585.g001

Collaborative knowledge graph

In this study, we use the Collaborative Knowledge Graph (CKG) and emphasize the importance of high-order connections between nodes as well as composite relations [9]. The structure of a CKG is defined as follows:

User–item graph.

In the context of recommender systems, historical interaction data between users and items (e.g., purchases or clicks) is represented as a bipartite graph . This graph is formally defined as:

(1)

Where U and I denote the sets of users and items, respectively. The variable indicates the interaction between a user and an item, where if user u has interacted with item i, and otherwise.

Knowledge graph.

Beyond user–item interactions, additional information about items (such as item attributes and external knowledge) is also incorporated. This supplementary data consists of real-world entities and the relationships among them to describe an item (for example, a movie can be characterized by its director, actors, and genres). Such information is typically organized as triples (head, relation, tail), or . In this study, we define the knowledge graph as a directed graph constructed from these triples , specifically:

(2)

Here, E denotes the set of entities and R represents the set of relations. For instance, the triple (Hugh Jackman, ActorOf, Logan) indicates that Hugh Jackman is an actor in the movie Logan. In addition, we define a set of item–entity links: which specifies that an item i is associated with an entity e in the knowledge graph. Fig 2 describes an example of a knowledge graph.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 2. An example of a knowledge graph.

https://doi.org/10.1371/journal.pone.0344585.g002

Collaborative knowledge graph (CKG).

The CKG is a unified structure that integrates user behaviors and item knowledge into a single relational graph. Each user behavior is represented as a triple , where is treated as an additional Interact relation between user u and item i. Based on the set of item–entity links A, the user–item graph can be seamlessly integrated with the knowledge graph to form a unified structure:

(3)

Where and .

Embedding layer

The embedding layer is responsible for parameterizing each node in the CKG into a representation vector such that the structure of the graph—including users, items, entities, and the relationships among them—is preserved. In this study, we employ the TransR method [26], a popular knowledge graph embedding approach, to embed nodes in the CKG into embedding vectors through the translation principle. Each entity h (head entity) and t (tail entity) in the CKG is represented by a vector in the entity space: where d is the dimension of the entity space. Each relation r (relation) is represented by a translation vector where k is the dimension of the relation space (which may differ from d). Additionally, each relation r is associated with a projection matrix that maps entities from the entity space to the relation space. TransR assumes that for each triple existing in the CKG, in the relation space r, the projected vector of the head entity () added to the relation vector () approximates the projected vector of the tail entity (). Formally, this can be expressed as follows:

(4)

Where:

• : the representation of h in the relation space.
• : the representation of t in the relation space.

For each triple , we compute its plausibility score using the squared Euclidean distance [27]. The plausibility score is defined as:

(5)

When the value of is lower, it means that is closer to in the relation space, indicating that the triple is more likely to be valid. Conversely, a higher score suggests that the triple is less plausible.

The training of TransR employs a pairwise ranking loss function [28] to distinguish between valid and invalid triples. This facilitates modeling entities and relations at the triple level, serving as a regularizer and incorporating direct connections into the representations, thereby enhancing the model’s representational capacity.

Attentive embedding propagation layer

After obtaining the initial vector representations of entities, items, and users through the TransR embedding layer, we implement a multi-layer attentive embedding propagation mechanism to extend the representation scope of each node from its direct neighbors to higher-order neighbors. This mechanism enables the model to leverage not only the direct connections between users and items but also indirect relational paths through intermediate entities such as genres, directors, or brands. Specifically, for each entity , we define its direct neighborhood in the CKG as:

(6)

The objective is to compute a new embedding vector for node h by aggregating information from its neighbors , while simultaneously adjusting the contribution of each neighbor through a knowledge-aware attention mechanism.

At each layer, we implement three main components:

Information propagation.

The information from neighboring nodes is propagated to the target node through a weighted summation, specifically:

(7)

Where:

• : the representation of the tail node t.
• : the attention coefficient reflecting the importance of the edge .

Knowledge-aware attention mechanism.

The attention coefficient is determined based on the interaction between the target node, the relation, and its neighboring node, and is computed as follows:

(8)

Here, we choose the activation function to be , whose values range from , enabling the model to effectively capture complex relationships. Subsequently, to normalize the attention weights, we employ the softmax function [29]:

(9)

This mechanism enables the model to focus on semantic relations with higher contributions while simultaneously reducing noise from less relevant relations.

The incorporation of the attention mechanism plays a crucial role in enabling adaptive and knowledge-aware information aggregation. In a collaborative knowledge graph, a node is typically connected to multiple neighbors through heterogeneous relations. Treating all neighbors equally during aggregation may introduce noise and dilute important semantic signals. By using Eq 9, KGRec dynamically assigns different importance weights to neighboring entities and relations. This allows the model to prioritize more informative and semantically relevant connections while suppressing less useful ones. Such selective aggregation is particularly beneficial in sparse and heterogeneous graphs, where irrelevant or weakly related neighbors can otherwise negatively affect representation learning.

Information aggregation.

After obtaining the propagated information , the embedding vector of h is combined with the aggregated embedding vectors from its neighboring nodes to generate a new representation of h at the current layer. This process aims to integrate both the intrinsic information of node h and the propagated information from its neighbors, thereby providing a more comprehensive characterization of node h. The general formula for this process is:

(10)

Where denotes the aggregator function, which determines how these two vectors are combined. In this study, we conduct experiments with three different aggregators:

• Graph Convolutional Network (GCN) [30]: This is a simple yet effective method directly inherited from the traditional GCN architecture. In this approach, the new embedding vector is computed by performing a linear summation of the central node’s vector and the aggregated vector from its neighbors, followed by a transformation matrix and a nonlinear activation function. The formula is given as:

(11)

Where is the weight matrix, and LeakyReLU is a nonlinear activation function. This method assumes that the information from the central node and its neighbors contributes equally and is combined in a linear manner, which limits its ability to capture the nonlinear interactions between the central node and its neighbors.

• GraphSAGE [17]: GraphSAGE employs vector concatenation by combining the embedding vector of the central node with the aggregated vector from its neighbors before passing it through a weighted transformation layer. The formula is given as:

(12)

This method leverages concatenation to preserve distinct information from both the central node and its neighbors, thereby allowing the model to learn separate weights for each type of signal. However, its limitation lies in the higher computational cost, as the input vector dimension is doubled.

• Bi-Interaction [13]: This is the primary method adopted in KGRec. Unlike GCN, which only performs linear summation, this approach introduces an additional nonlinear component by applying element-wise multiplication to explicitly model the detailed interactions between the central node and its neighbors. The outputs from both branches are then combined after being transformed through two separate weight matrices. The formula is given as:

(13)

Where:

• ⊙: the element-wise multiplication (Hadamard product).
• : two separate learnable matrices for each branch.

This method provides a better modeling of the nonlinear dependencies between a node and its neighbors, thereby enhancing the representational capacity in heterogeneous graphs. However, it requires higher computational cost and longer training time due to the need for learning multiple parameters.

Prediction layer

After completing the embedding propagation through L layers, each user u and each item i will have a set of representations from layer 0 to layer L: and similarly for item i. We then concatenate all the embeddings from different layers to form a comprehensive embedding vector. Specifically, the formula for aggregating the embeddings is as follows:

(14)

(15)

Subsequently, to evaluate the compatibility score between a user and an item, we compute the inner product of their two vectors and , specifically as follows:

(16)

This score reflects the probability that user u will be interested in item i. A higher score indicates a greater likelihood that the user will engage with the item, while a lower score suggests the opposite.

Loss function

In this study, we train the model using a joint optimization strategy, which includes:

• The knowledge graph embedding loss from TransR.
• The collaborative filtering loss , which employs Bayesian Personalized Ranking (BPR) [31]. The formula is:

(17)

In addition, we employ a regularization coefficient to prevent the model from overfitting. Finally, the overall loss function of the model is formulated as follows:

(18)

Where λ is the regularization coefficient, and θ denotes the set of model parameters.

Experiments

We design experiments to address two key research questions:

• RQ1: How does KGRec perform in comparison with state-of-the-art knowledge-aware recommendation methods?
• RQ2: How do different architectural components—such as the attention, the adjacency matrix normalization mechanisms, the number of layers and the choice of aggregator—affect the performance of the model?

The following section provides a detailed explanation of these experiments and their results.

Dataset

To evaluate the effectiveness of KGRec in knowledge graph-based recommendation, we employ four publicly available benchmark datasets: Yelp2018, Last-FM, Amazon-Book and MovieLens-1M. These datasets represent different application domains (e-commerce, music, and local businesses), with varying scales and levels of sparsity, making them suitable for assessing the generalizability and scalability of the model. For each of the above datasets, we split the data into 80% for training, 10% for validation, and 10% for testing. Dataset statistics are shown in Table 1.

• Yelp2018 [32]: The Yelp2018 dataset is derived from the 2018 Yelp Challenge, and is one of the standard benchmarks in location and service recommendation research. The original data consist of user reviews of local businesses such as restaurants, cafés, and fitness centers. We apply the 10-core criterion to ensure that each user and each business has a minimum level of interaction.
• Last-FM [33]: The Last-FM dataset is constructed from users’ music listening histories on the Last.fm platform, covering the period from January to June 2015. Each user can interact with one or more music artists through listening behavior. Similar to Amazon-Book, we apply the 10-core criterion to filter users and artists with a sufficient number of interactions.
• Amazon-Book [34]: The Amazon-Book dataset is extracted from the Amazon product review dataset (2018), widely used in product recommendation research. In this dataset, users interact with items (books) through ratings and reviews. To ensure data quality and stability, we apply the 10-core filtering strategy, which retains only users and items with at least 10 interactions.
• MovieLens-1M [35]: The MovieLens-1M dataset is a widely used benchmark in recommender-system research, containing 1 million movie ratings collected from real users on the MovieLens platform. It provides rich information including user profiles, movie metadata, and timestamped ratings, making it suitable for building and evaluating collaborative-filtering and hybrid models. Similar to other datasets, we apply the 10-core criterion to filter users and movies with a sufficient number of interactions.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 1. Dataset Statistics.

https://doi.org/10.1371/journal.pone.0344585.t001

Ranking strategy

During evaluation, the model computes the predicted compatibility score for all items with respect to each user u. The items are then ranked in descending order according to their . From this ranked list, the model selects the top-K items with the highest scores, which are regarded as the recommendation results for user u. In this study, we set , meaning that the model returns the 20 items with the highest predicted scores for each user.

Evaluation metrics

In this study, to evaluate the performance of the model, we employ four widely used metrics: Precision, Recall, F1-score [36] and NDCG [37].

• Precision@K: This metric measures the proportion of recommended items that are relevant, defined as: (19)
• Recall@K: This metric measures the ability of the model to correctly recommend the items that a user is truly interested in. For each user, the model generates a ranked list of the top-K items with the highest predicted scores, and then checks how many of the items the user actually interacted with appear in this list. The formula is given as: (20)
• F1-score: This metric is the harmonic mean of Precision and Recall, defined as: (21)
• NDCG@K: This metric not only evaluates the presence of relevant items in the recommendation list but also takes into account their positions within the list. Items appearing at higher ranks are assigned greater importance. This provides a more accurate reflection of the model’s ranking quality. The general formula is given as: (22)

Where denotes the relevance of the item at position i, IDCG is the ideal DCG value (i.e., the maximum value achieved if all relevant items appear at the top positions).

Note that Precision@K, Recall@K, and F1@K are ranking-based top-K metrics. In large-scale and sparse recommendation settings, their absolute values are typically small (often below 0.1) and are not directly comparable to classification-based F1 scores. For instance, while some baseline models like CKAN may report F1 scores higher than 0.7 in binary classification tasks (such as CTR prediction), their performance in top-K ranking tasks on sparse datasets like Amazon-Book is significantly lower due to the increased difficulty of the ranking objective. In this study, we strictly follow the top-K ranking protocol to ensure a fair and consistent comparison across all models.

Model performance (RQ1)

We train KGRec and compare its performance with six baseline models such as:

• MCRec [38]: Exploits meta-paths in the knowledge graph.
• AMIE [39]: A model that combines embeddings with the knowledge graph, but without propagation.
• CBFM [40]: A linear model that learns user–item feature interactions through embedding vectors.
• KGAT [41]: A knowledge graph attention network.
• CKAN [42]: Collaborative knowledge-aware attentive network.
• KGNN_LS [43]: Knowledge-aware graph neural networks with label smoothness regularization.

The experimental results obtained from the four benchmark datasets are summarized in Table 2. As shown in Table 2, the experimental results across the four datasets consistently demonstrate that KGRec delivers substantially better performance than the other state-of-the-art knowledge-graph-based recommendation models, including MCRec, AMIE, CBFM, KGAT, CKAN, and KGNN_LS. When evaluated using four commonly used metrics—Precision, Recall, F1-score, and NDCG—KGRec achieves the highest or co-highest performance in nearly all configurations, highlighting its robustness and adaptability across datasets of different sizes and sparsity levels.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 2. Comparison results with other baseline models.

https://doi.org/10.1371/journal.pone.0344585.t002

In particular, on the three relatively sparse datasets, Amazon-Book, Last-FM and Yelp2018, KGRec exhibits a pronounced advantage, especially in Recall and NDCG. This improvement underscores KGRec’s ability to more effectively capture high-order semantic relationships and leverage structural signals in the knowledge graph, allowing it to identify relevant items even in scenarios where user–item interactions are limited. On the denser MovieLens-1M dataset, KGRec continues to demonstrate strong superiority by maintaining stable gains over all baselines. Its improvements in both ranking- and relevance-based metrics indicate that the model’s enhanced feature aggregation and deep interaction reasoning contribute directly to more accurate top-K recommendation performance.

Overall, the expanded experimental analysis provides clear evidence that KGRec is the most effective and reliable model in the comparison group. Its consistent and significant improvements across all datasets illustrate its capacity to generalize well and deliver high-quality recommendations under diverse conditions, further validating the advantages of our proposed framework.

We conducted multiple experimental runs to ensure the reliability of our results. Specifically, we trained the KGRec model five times using different random initialization seeds to verify that the performance improvements are consistent and not merely artifacts of stochastic initialization. The results are shown in Table 3.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 3. Evaluation of multiple experimental runs.

https://doi.org/10.1371/journal.pone.0344585.t003

All training configurations and hyperparameters used in our experiments are documented in the configuration files, which are publicly available in the GitHub repository provided in the link.

The results obtained from training the KGRec model across five independent runs demonstrate a remarkably high level of stability. For key evaluation metrics such as Precision, F1-score, and NDCG, the variation between different training runs is virtually zero. This consistency indicates that the model’s performance is not influenced by minor perturbations introduced through random parameter initialization. In other words, the core mechanisms of KGRec—its graph reasoning, feature aggregation, and interaction modeling—operate reliably regardless of small stochastic differences at the start of training.

For the Recall metric, although a slight variation is observed across runs, the range remains extremely small, fluctuating only between approximately 0.1% and 0.24%. Importantly, this difference is statistically insignificant and does not suggest any instability in model behavior. All four datasets used in the experiments—Amazon-Book, Last-FM, Yelp2018 and MovieLens-1M—exhibit the same overall trend: KGRec consistently produces nearly identical outcomes with low variance and no observable anomalies across repeated tests.

Taken together, these findings demonstrate that KGRec exhibits excellent robustness and reproducibility. The model is largely insensitive to random fluctuations and can reliably reproduce its performance even when trained multiple times under independent initialization conditions. This strong stability further confirms the reliability of the model and supports its ability to generalize effectively across different learning scenarios and datasets.

We also conducted experiments on training time and memory usage for all compared models. The results are shown in Table 4 and Table 5. Following these tables, we provide a detailed analysis of the model complexity and efficiency.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 4. Evaluation on time and memory of all compared models.

https://doi.org/10.1371/journal.pone.0344585.t004

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 5. Model summary of all compared models.

https://doi.org/10.1371/journal.pone.0344585.t005

Complexity and Efficiency Analysis: We acknowledge that, as shown in Table 5, KGRec has the highest or nearly highest number of parameters among the compared models. This is primarily due to the deliberate architectural design of KGRec, which integrates a knowledge-aware attention mechanism, multi-layer embedding propagation, and a Bi-Interaction aggregator. These components introduce additional trainable parameters but are essential for capturing high-order semantic relations in the collaborative knowledge graph. Importantly, the parameter scale of KGRec is comparable to other advanced KG-based models such as KGAT and CKAN, and does not represent a significant increase relative to their model capacities. In contrast, lighter models (e.g., AMIE and CBFM) employ simpler architectures without deep propagation or attention mechanisms, which explains both their smaller size and inferior recommendation performance.

Moreover, as demonstrated in Table 4, the increased number of parameters does not lead to prohibitive computational costs. We agree that model size is an important factor affecting training time; however, training efficiency is not determined solely by the number of model parameters. In graph-based recommender systems, training time is also strongly influenced by dataset characteristics such as the number of entities and triples in the knowledge graph, graph sparsity, neighborhood size, and convergence behavior. This explains why KGRec exhibits relatively higher training time on the Amazon-Book dataset, which contains a large-scale and sparse knowledge graph with over 2.5 million triples, leading to more expensive neighbor aggregation during propagation. In contrast, the LastFM dataset has a much smaller knowledge graph with fewer relations, and MovieLens-1M is both compact and relatively dense, allowing KGRec to converge faster despite having a comparable number of parameters. KGRec maintains competitive training time and acceptable memory consumption across all datasets, while consistently achieving superior performance in terms of Precision, Recall, F1-score, and NDCG. This indicates a favorable trade-off between model complexity and recommendation effectiveness.

Architectural components affecting the performance of KGRec (RQ2)

To gain deeper insights into the core components of KGRec and to assess the contribution of each factor to the overall performance, we conduct a series of in-depth analyses on the four aforementioned datasets, with the following specific objectives:

• Impact of Attention: We investigate how integrating attention influences the recommendation performance of the model. The results are presented in Table 6.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 6. Impact of attention mechanism on model performance.

https://doi.org/10.1371/journal.pone.0344585.t006

The experimental results obtained from the four benchmark datasets —Amazon-Book, Last-FM, Yelp2018 and MovieLens-1M—demonstrate a consistent and substantial performance improvement when the attention mechanism is incorporated into the KGRec architecture. Across all evaluation metrics, the attention-enhanced version of KGRec outperforms the variant that excludes attention, indicating that this component plays a critical role in strengthening the model’s ability to capture meaningful relational patterns within the knowledge graph.

More specifically, the attention mechanism enables the model to dynamically weigh the importance of different neighboring entities and relations, allowing KGRec to focus on the most informative semantic signals during the feature aggregation process. This selective weighting results in richer and more discriminative user–item representations, which in turn leads to more accurate recommendation outcomes. The consistent performance gains across diverse datasets—ranging from highly sparse (Amazon-Book, Last-FM, Yelp2018) to relatively dense (MovieLens-1M)—further highlight the robustness and general applicability of the attention mechanism.

Overall, these findings affirm that the attention mechanism is a crucial and indispensable component within KGRec. By enabling the model to learn enhanced semantic representations and prioritize relevant information more effectively, attention contributes significantly to the model’s ability to achieve strong and reliable recommender performance across multiple data conditions and domains.

• Impact of Adjacency Matrix Normalization: We evaluate how different adjacency matrix normalization mechanisms in the graph affect the model. The results are presented in Table 7.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 7. Performance comparison of adjacency matrix normalization mechanisms.

https://doi.org/10.1371/journal.pone.0344585.t007

The experimental results obtained from the four benchmark datasets indicate that adopting the random-walk adjacency matrix normalization leads to consistently better performance compared to using symmetric normalization. Although the magnitude of improvement is relatively small, it remains highly stable across nearly all evaluation metrics. This effect is especially pronounced on the three sparse datasets—Amazon-Book, Last-FM, and Yelp2018—where the quality of graph-based signal propagation plays a more critical role due to limited user–item interactions.

The superior performance of the random-walk normalization can be attributed to its ability to model personalized transition probabilities by normalizing each node according to its outgoing degree. This formulation allows information to flow through the graph in a direction-sensitive manner, enabling the model to better capture asymmetric structural relationships and prioritize more informative neighbors during message passing. In contrast, symmetric normalization imposes an equalized structure that may dilute important signals, particularly in graphs with high sparsity or skewed degree distributions.

Across all datasets, the results consistently demonstrate that random-walk normalization enhances KGRec’s capacity to propagate semantic information more effectively through the knowledge graph, leading to more expressive user and item embeddings. This improvement ultimately contributes to higher recommendation accuracy and stronger ranking performance. Overall, the findings validate random-walk normalization as a more suitable and advantageous choice for the KGRec model, ensuring more reliable and robust recommendation quality across diverse data conditions.

• Impact of the number of propagation layers: We investigate how the number of embedding propagation layers influences the recommendation performance of the model. Each additional layer corresponds to expanding the receptive field to higher-order neighbors in the knowledge graph. The results are presented in Table 8.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 8. Impact of the number of propagation layers on the performance of KGRec.

https://doi.org/10.1371/journal.pone.0344585.t008

The experimental results across all four datasets indicate that the number of propagation layers in KGRec does influence recommendation quality, although the magnitude of change remains relatively moderate. For the Amazon-Book, Last-FM and Yelp2018 datasets, we observe a small but consistent improvement in performance when increasing the number of layers to three. Metrics such as Recall, F1-score, and NDCG all show noticeable gains compared to the 1-layer and 2-layer configurations, suggesting that deeper propagation at this level helps the model capture richer relational information from the knowledge graph. However, when the number of layers is further increased to four, the performance declines slightly, indicating that excessive propagation introduces noise and may distort the learned representations.

A similar trend appears in the MovieLens-1M dataset. The model achieves its highest performance at three layers, with NDCG reaching 0.300—the best among all tested configurations. When the depth is increased to four layers, the performance again drops, reinforcing the observation that overly deep propagation can lead to over-smoothing, where node representations become less distinguishable and the model’s discriminative power weakens.

Overall, these findings consistently demonstrate that a depth of three propagation layers is the most appropriate setting for KGRec. This configuration provides a balance between extracting useful high-order semantic information and avoiding the negative effects associated with overly deep message passing, allowing the model to fully leverage the structure of the knowledge graph while maintaining strong and stable recommendation performance.

• Impact of the aggregator function: To evaluate the effectiveness of different strategies for aggregating information from neighbors, we compare the three aggregators introduced in the methodology section: GCN [30], GraphSAGE [17], and Bi-Interaction [13]. The results are presented in Table 9.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 9. Impact of the aggregator function on the performance of KGRec.

https://doi.org/10.1371/journal.pone.0344585.t009

The experimental results indicate that the three information aggregation mechanisms evaluated in KGRec—GraphSAGE, GCN, and Bi-Interaction—provide broadly comparable levels of recommendation performance. However, Bi-Interaction consistently delivers the strongest results across all four benchmark datasets. On Amazon-Book, Last-FM and Yelp2018, Bi-Interaction demonstrates clear improvements in key metrics such as Recall, F1-score, and NDCG. These gains suggest that its ability to combine both “sum-based aggregation” and explicit “pairwise feature interaction” enables the model to capture richer relational dependencies and more expressive semantic signals from the knowledge graph. By simultaneously modeling first-order and second-order feature interactions, Bi-Interaction generates more discriminative user and item embeddings, contributing to its superior performance.

In contrast, GCN tends to produce the weakest performance among the three methods. This is largely due to its simple symmetric normalization and linear message-passing process, which may not fully capture complex relational patterns, especially in sparse or highly heterogeneous graph structures. GraphSAGE performs moderately well, generally achieving results between GCN and Bi-Interaction. Its sampling-based aggregation helps capture localized neighborhood structure more effectively than GCN, but it still lacks the richer interaction modeling that gives Bi-Interaction its advantage.

A similar pattern emerges in the MovieLens-1M dataset. Although the differences between the aggregation methods are somewhat smaller due to the dataset’s relative density, Bi-Interaction still achieves the highest scores across all evaluation metrics. This consistency across both sparse and dense datasets confirms that Bi-Interaction is better equipped to leverage graph connectivity and semantic relationships, enabling more accurate top-K recommendations.

Overall, the results strongly support Bi-Interaction as the most suitable and effective information aggregation mechanism for the KGRec model. Its ability to capture multi-level relational information and generate more expressive feature representations leads to consistently superior recommendation quality across diverse datasets, making it the preferred choice among the evaluated alternatives.