The Graph Attention Recommendation Method for Enhancing User Features Based on Knowledge Graphs

Abstract

Knowledge graphs have shown great potential in alleviating the data sparsity problem in recommendation systems. However, existing graph-attention-based recommendation methods primarily focus on user–item–entity interactions, overlooking potential relationships between users while introducing noisy entities and redundant high-order information. To address these challenges, this paper proposes a graph-attention-based recommendation method that enhances user features using knowledge graphs (KGAEUF). This method models user relationships through collaborative propagation, links entities via similar user entities, and filters highly relevant entities from both user–entity and user–relation perspectives to reduce noise interference. In multi-layer propagation, a distance-aware weight allocation mechanism is introduced to optimize high-order information aggregation. Experimental results demonstrate that KGAEUF outperforms existing methods on AUC and F1 metrics on the Last.FM and Book-Crossing datasets, validating the model’s effectiveness.

1. Introduction

With the advent of the big data era, recommendation systems play a crucial role in providing users with fast and accurate personalized information and item recommendations. Traditional recommendation methods, such as content-based, collaborative filtering, and hybrid recommendations, can address user needs to some extent, but they face issues such as data sparsity, cold start, and poor interpretability [1]. In 2012, Google launched the Knowledge Graph project, building a vast knowledge network by integrating massive data from the internet. This greatly improved the personalized recommendation experience for users and also alleviated data sparsity and cold start problems [2]. In recent years, researchers have increasingly focused on methods that combine knowledge graphs with graph attention networks. As a structured information representation in the form of triples, knowledge graphs can effectively alleviate issues like data sparsity by introducing rich entity relationships and attributes through external knowledge, thereby improving the accuracy and diversity of recommendation results [3]. With the introduction of the graph attention mechanism, information can be aggregated by adaptively assigning weights, providing more accurate recommendation results [4].

However, existing graph attention models for knowledge graphs face the following core issues. Neglect of user relationships: Most methods primarily focus on user–item–entity interaction features, ignoring the potential interest similarities between users. Users with similar interest characteristics may share similar preferences, and these relationships can provide critical contextual information for recommendation systems [5]. Noisy entity selection issue: When using random walk strategies to select a fixed number of neighboring entities, the model tends to introduce noisy entities unrelated to user interests. These entities neither improve recommendation accuracy nor contribute positively to user embedding representation [6]. Insufficient hierarchical weight handling: Entities from different layers contribute differently to user preferences. Traditional methods fail to effectively distinguish these topological differences, leading to information redundancy during multi-layer aggregation [7].

To address the above issues, this paper proposes a graph attention recommendation method based on knowledge graphs to enhance user features, named KGAEUF (Knowledge Graph Attention Enhancing User Features). By introducing user relationship modeling, noise-reducing entity selection, and a distance-aware multi-layer weight allocation mechanism, the performance of recommendation systems is enhanced from multiple perspectives. Since the current model does not consider the relationships between users, this paper first obtains a set of users with similar preferences to the target user through the user–item historical interaction matrix. Then, it calculates user similarity and selects the top k most similar users for entity linking. To address the noise problem caused by the vast amount of entity information, and considering that different users may have varying degrees of preference for the same entity, the relevance of entities to different users is calculated from two perspectives: user–relationship and user–entity. The top k neighbors with the highest relevance scores are then aggregated. After obtaining the initial entity set representations for users and items, knowledge-aware attention is applied to distinguish the contributions of different neighbors based on the triple’s head entity, tail entity, and relationship vector. Finally, in the prediction layer, considering the topological proximity structure of ripple-concentrated entities, the weight values of entity sets at each layer should be different. The initial entity set representation best reflects the user’s interest features. Hierarchical weighting is applied to each layer, and a weighted aggregation using a concat aggregator is performed to generate more accurate user–item embedding representations, enhancing personalized recommendation results. The contributions of this paper are as follows:

• The potential relationships between users have been considered, and the entities of the top k most similar users are selected for linking, enhancing the initial entity set representation of the user–item pair.
• The relevance of entities to different users is calculated from two perspectives: user–relationship and user–entity. The top k neighbors with the highest relevance scores are selected for aggregation, reducing the noise caused by irrelevant entities.
• The topological proximity structure of ripple-concentrated entities is processed, with hierarchical weighting applied to each layer. A weighted aggregation using a concat aggregator is performed, strengthening the user’s feature representation and improving the accuracy of the recommendation results.

2. Relate Work

Existing knowledge-graph-based graph attention network recommendation systems are mainly divided into three types: embedding-based, path-based, and propagation-based methods. Among them, the mainstream method for knowledge-graph-based graph attention recommendation systems is the propagation-based method [8].

(1) The core of embedding-based methods is to map entities and relationships into a continuous low-dimensional vector space, such that similar entities are close in spatial distance, while dissimilar entities are farther apart [9]. Embedding-based methods use knowledge-graph-embedding techniques, such as CKE (Knowledge Graph Embedding), to embed entities and relationships from the knowledge graph. Zhang [10] proposed the CKE (Collaborative Knowledge Base Embedding) model, which uses TransR to extract item features and capture implicit relationships between users and items. However, this model does not fully utilize the feature information in the knowledge graph. Subsequently, Khan [11] introduced semantic relevance estimation techniques to address issues in KGE, ensuring information relevance and reducing spatial complexity. Wang [12] proposed the DKN (Deep Knowledge-aware Network for News Recommendation) model, which uses convolutional neural networks and TransD to generate news embeddings while embedding entity and text representations through separate channels. However, the knowledge representation learning technique of TransD has issues, such as excessive parameters and lack of associations between entity representations, making it difficult to apply to large knowledge graphs. In response, He [13] proposed an improved learning model, Cluster TransD, which reduces the number of entity projections, ensuring associations between entity representations and lowering computational pressure, making it more suitable for large knowledge graphs. Later, Cao [14] proposed the KTUP (Knowledge Towards Understanding Preferences) model, which uses TransH to simultaneously learn user, item, entity, and relationship representations. Although embedding-based methods can capture complex relationships between user–item entities, they fail to capture higher-order relationships between entities. Due to the lack of interpretability, the embedded entities may be inaccurate, which negatively impacts recommendation performance [15].

(2) The core of path-based methods is to reveal the semantic relationships between entities through the definition and analysis of paths in the knowledge graph, utilizing the structural relationships between entities [16]. Path-based methods explore the connectivity between entities in the knowledge graph by using the structured features of entities in the knowledge graph. Wang [17] proposed the KPRN (Knowledge Path Recurrent Network) model, which generates path representations by combining the semantics of entities and relationships. KPRN uses a weighted aggregation operation to distinguish the importance of different paths, thereby capturing user preferences. Sun [18] proposed the RKGE (Recurrent Knowledge Graph Embedding) model, which uses recurrent networks to learn the embeddings of semantic paths between entities, thereby learning entity embeddings and path representations. Hu [19] proposed a collaborative filtering algorithm based on meta-path similarity, Hete-CF, which uses heterogeneous social networks for social recommendations. However, it neglects user-level information. In response, Luo Zhen et al. [20] proposed a recommendation method that integrates user features, improving the path filtering mechanism by combining user-level cross-features with knowledge graph semantic paths to update user representations. Although path-based methods are highly interpretable, breaking down a complex knowledge graph into individual paths for learning may lead to the loss of information. Moreover, these methods rely on manually designed meta-paths, which require considerable effort [21].

(3) The core of propagation-based methods is to use the principles and models of information propagation to construct and update knowledge graphs, fully utilizing the entity information within the knowledge graph [22]. These methods combine the advantages of embedding and path-based approaches, utilizing higher-order information from the knowledge graph, similar to ripple-like iterative propagation, to explore users’ latent interest preferences. Wang [23] proposed the RippleNet (Multiple Ripples Network) model, which provides significant assistance for propagation-based methods. RippleNet obtains the initial entity representations of users through the historical interaction matrix, similar to a ripple set that explores user preferences and learns user embeddings. Later, to explore higher-order collaborative signals, Wang [24] proposed the KGCN (Knowledge Graph Convolutional Networks) model, which uses graph convolutional networks to iteratively aggregate the embeddings of adjacent entities to refine item representations. Both of these methods do not consider the contribution level of different neighbors, leading to insufficient embeddings. Subsequently, Wang [25] proposed the KGAT (Knowledge Graph Attention Network for Recommendation) model, which introduces a collaborative knowledge graph that combines the user–item bipartite graph with the knowledge graph, and recursively propagates on the collaborative knowledge graph through a graph convolution network to complement entity embeddings. Wang [26] proposed the CKAN (Collaborative Knowledge-aware Graph Attention) model, which uses heterogeneous propagation networks to explicitly encode user–item historical interaction information and knowledge graph entity information, and employs a knowledge-aware graph attention network to assign weights to neighbor entities. However, it neglects the feature interaction between items and entities. In response, Huang [27] proposed the CAKR (Cross Attention Knowledge Recommendation) model, which designs a cross-attention module to learn the feature interactions between items and their corresponding entities. However, it does not distinguish the importance of different relationships. To address this, Li [28] proposed the MDAR (Multi-Task DeepAFM Attention Recommendation) model, which combines DeepFM with attention mechanisms to capture the importance of different relationships from various neighbors and learns entity representations through the differing contributions of these neighbors. In terms of enhanced representations, Duan [29] proposed the RFAN (Relation-Fused Attention Network) model, which incorporates entity type information to enhance entity representations, emphasizing the importance of modeling relationships between entities. Guo [30] proposed the KPMER (Knowledge-Graph-Based Personalized Multitask Enhanced Recommendation) model, which uses a lightweight graph convolution network to more effectively aggregate higher-order neighborhood information from the knowledge graph. This method improves the accuracy of neighborhood feature extraction and ensures the acquisition of more appropriate shared information. Along with the feature aggregation in higher-order propagation by the above methods, noise issues have also arisen [31]. However, the above models, while considering users’ deeper interest features and preferences, do not take into account the relationships between users, the issue of random walks selecting noisy entities, and the topological structure of different layers. The influence of entities at different layers should be different, which ultimately affects the accuracy of recommendation results [32].

3. Problem Description

In recommendation models, the core of the recommendation system is to assist users in information filtering, predicting users’ ratings or preferences for items, helping users quickly and accurately select items of interest [33]. The recommendation task refers to the recommendation model suggesting one or more items to the target user that the user has not yet clicked on or shown interest in. The task is defined as follows: a known user set $U=\{u_1,u_2\dots \dots \}$, item set $V=\{v_1,v_2\dots \dots \}$, and user–item interaction matrix $Y=\left\{y_{uv}\right|u\in U,v\in V\}$. The matrix contains users’ implicit feedback. If there is an interaction between user u and item v, then the value $y_{uv}=1$; otherwise, $y_{uv}=0$. A set $A=\{(v,e)|v\in V,e\in \epsilon \}$ is defined, where e represents the entity aligned $(v,e)$ with item v. In knowledge-graph-based recommendation systems, the model input data include the knowledge graph. If the knowledge graph is $G=\{(h,r,t)|h,t\in \epsilon ,r\in R\}$, the final goal of the recommendation model is to learn a prediction function: $y_{uv}=F(u,v;\theta ,G)$, where $y_{uv}$ is the predicted score for the interaction between user u and item v, and typically, a decimal between 0 and 1 and $\theta$ represents the parameters of the recommendation model [34].

4. KGAEUF Recommendation Model Algorithm

This paper proposes a framework for the knowledge-graph-attention-enhanced user feature recommendation method, as shown in Figure 1. It consists of three main parts: the heterogeneous propagation processing layer, the knowledge-aware attention layer, and the prediction layer.

4.1. Heterogeneous Propagation Processing Layer

Most current recommendation methods focus only on the relationship between users and items, ignoring the potential similarities between users. For example, if both user A and user B like pop music, user B’s preferences can provide valuable supplementary information for user A. However, traditional models overlook such collaborative signals between users, resulting in insufficient information in recommendation outcomes. To address this issue, this paper calculates similar user sets through domain-specific collaborative propagation and enhances the initial entity set representation of target users. Specifically, based on the user–item historical interaction matrix, the similarity between the target user and other users is calculated, then the top-k most similar users are selected, and their entity sets are linked to the target user’s initial entity set. There is also the noise problem introduced by the collaborative knowledge graph formed with the knowledge graph, where a random walk algorithm selects a fixed batch size of neighbors, but not all entities are useful, and irrelevant entity information may be selected. For instance, a male user A particularly enjoys war and suspense movies but accidentally clicks on a genre he has no interest in; this noisy data will be retained, negatively impacting the recommendation results. Through the heterogeneous propagation processing layer, the user collaborative propagation enhancement module first links the entities of the top-k most similar users, obtaining the initial user–item entity representation. Neighbor entities are selected and aggregated based on a scoring function, completing data denoising, and higher-order entity information is then aggregated via knowledge graph propagation.

4.1.1. Neighborhood Collaborative Propagation

The enhanced representation of users and items after denoising is obtained through neighborhood collaborative propagation. First, the historical interaction item set $V_u$ of the target user u is obtained, Through the interaction relationship between users and items, the set of users $U_{v_u}$ with similar preferences to the target user in the set $V_u$ is obtained. As shown in Equations (1) and (2):

$$V_u=\left\{v\right|y_{uv}=1\}$$

(1)

$$U_{v_u}=\left\{u\right|y_{uv}=1 \mathrm{and} v\in V_u\}$$

(2)

Then, the interaction matrix is used to obtain the interaction item set $V_v$ for each user in the similar user set. The similarity between each user $u^{\prime }$ in the set $U_{v_u}$ and the target user u is calculated. Based on the similarity results, the top k most similar users are selected. Then, the item sets of these k users are queried as the similar item set, and the project entities are linked to the knowledge graph, forming the initial propagation entity set ${\epsilon }_u^o$ after enhancing the user representation, as shown in Figure 2 and Equations (3)–(5):

$$v_v=\left\{v_u\right|u\in \left\{u\right|y_{uv}=1\} and y_{u{v}_u}=1\}$$

(3)

$$Sim(u,u^{\prime })={\displaystyle \frac{|f_u(v)\cap f_{u^{\prime }}(v)|}{|f_u(v)\cup f_{u^{\prime }}(v)|}}$$

(4)

$${\epsilon }_u^o=\left\{e\right|(v,e)\in A and v\in v|y_{uv}=1\}$$

(5)

where $Sim(u,u^{\prime })$ represents the similarity between the target user u and similar user $u^{\prime }$, and $f_u(v)$ and $f_{u^{\prime }}(v)$ represent the historical interaction items between user u and user $u^{\prime }$, respectively. $|f_u(v)\cap f_{u^{\prime }}(v)|$ represents the number of repeated items between user u and user $u^{\prime }$, and $|f_u(v)\cup f_{u^{\prime }}(v)|$ represents the total number of items between user u and user $u^{\prime }$. By removing the project entities in ${\nu }_v$ that cannot be aligned with the knowledge graph entities, the final initial propagation entity set of the items is obtained, and its definition is in the following Equation (6):

$${\epsilon }_v^0=\left\{e\right|(v_u,e)\in A and v_u\in v_v\}$$

(6)

After obtaining the initial propagation entity set for users and items, the denoising process is applied to the initial entity set. To ensure the accuracy of the initial propagation for users and items, both the user–entity and user–relationship perspectives are comprehensively considered to determine their scores. The user–entity perspective directly reflects the importance of an entity to the user. However, due to differing user preferences, some users may place more importance on the director of the item, while others may prioritize the actor. From the user–relationship perspective, by introducing relationship vectors, the latent connections between user preferences and entity characteristics can be better represented. First, the user–entity and user–relationship weights are calculated separately through dot products. Then, softmax normalization is applied to each, and the sum is taken to obtain the score function. Finally, the top k neighbor entities with the highest scores are selected for aggregation, as shown in Figure 3. The formula is as follows Equations (7)–(12):

$${\omega }_e^{(i)}=e_u^{T}e$$

(7)

$${\omega }_r^{(i)}=e_u^T{e}_r$$

(8)

$${\alpha }_e^{(i)}={\displaystyle \frac{\exp ({\omega }_e^{(i)})}{{\displaystyle {\sum }_{j=1}^n\exp ({\omega }_e^{(j)})}}}$$

(9)

$${\alpha }_r^{(i)}={\displaystyle \frac{\exp ({\omega }_r^{(i)})}{{\displaystyle {\sum }_{j=1}^n\exp ({\omega }_r^{(j)})}}}$$

(10)

$$S_{entity}^i={\alpha }_e^{(i)}+{\alpha }_r^{(i)}$$

(11)

$$e_{N(v)}^u={\displaystyle \sum e},S_{entity}^i\ge S_{entity}^k$$

(12)

where ${\omega }_e^{(i)}$ and ${\omega }_r^{(i)}$ represent the dot product between the user–entity and user–relationship vectors, respectively. ${\alpha }_e^{(i)}$ and ${\alpha }_r^{(i)}$ represent the normalized weights for the user–entity and user–relationship, respectively. $S_{entity}^i$ is the score function, where $S_{entity}^i\ge S_{entity}^k$ represents the top k entities with the highest scores, and $e_{N(v)}^u$ represents the set of top k neighbor entities with the highest scores.

4.1.2. Knowledge Graph Propagation

After obtaining the enhanced and denoised user–item initial propagation entity set through neighborhood collaborative propagation, propagation is carried out along the links in the knowledge graph. This allows for the acquisition of multi-hop ripple sets for user–item interactions, resulting in extended entity sets and triples at different hierarchical levels compared to the initial entity set. A unified placeholder o is used to represent user $u\in U$ or item $v\in V$. The extended entity set ${\epsilon }_o^l$ for user u and item v is recursively formulated as Equations (13) and (14):

$${\epsilon }_o^l=\left\{t\right|(h,r,t)\in G and h\in {\epsilon }_o^{l-1}\},l=1,2\dots \dots ,L$$

(13)

$$S_o^l=\{(h,r,t)|(h,r,t)\in G and h\in {\epsilon }_o^{l-1}\},l=1,2\dots \dots ,L$$

(14)

where l represents the number of hops from the initial entity set, and $S_o^l$ represents the neighbor entities at l-hop distance in the triples. The knowledge graph propagation module forms multi-hop ripple sets for user–item interactions, encoding higher-order interaction information between users and items. This effectively improves the embedded representation of users and items.

4.2. Knowledge-Aware Attention Layer

After the heterogeneous propagation processing layer, the top k neighbor entities with the highest relevance scores are obtained. The knowledge-aware graph attention network assigns weights to the neighbor entities. This typically determines how much information from tail entities can be propagated to the head entities. To comprehensively reveal the relationship between head and tail entities, a knowledge-aware relationship vector is introduced. The head entity vector, relationship vector, and tail entity vector are concatenated and activated using the ReLU function. The formula representation is as follows (Equations (15)–(17)):

$$Z_0=\mathrm{Re}LU(w_0(e_i^h\left|\right|r_i\left|\right|e_i^t)+b_0)$$

(15)

$$\pi (e_i^h,r_i,e_i^t)=\sigma (w_2\mathrm{Re}LU(w_1{z}_0+b_1)+b_2)$$

(16)

$$S(e_i^h,r_i,e_i^t)={\displaystyle \frac{\exp (\pi (e_i^h,r_i,e_i^t))}{{\displaystyle \sum _{(h^{\prime },r^{\prime },t^{\prime })\in S_o^{h(l)}}\exp (\pi (e_i^h,r_i,e_i^t))}}}$$

(17)

where $e_i^h$ and $e_i^t$ represent the head entity embedding vector and the tail entity embedding vector, respectively, $r_i$ is the relationship embedding vector, $w_0,w_1,b_0,b_1,b_2$ is the trained parameter, and $S(e_i^h,r_i,e_i^t)$ is the attention weight coefficient for the relevant entities. The attention weight coefficient determines how much information from the tail entity is propagated to the head entity. Finally, the l-th layer triple representation of the user or item is obtained, as shown in Equations (18) and (19):

$${\alpha }_i=S(e_i^h,r_i,e_i^t)e_i^t$$

(18)

$$e_o^{(l)}={\displaystyle \sum _{i=1}^{\left|S_o^{h(l)}\right|}({\alpha }_i^{(0)})},l=1,2\dots \dots ,L$$

(19)

where $S_o^{h\left(l\right)}$ is the L-th layer triple of the user or item, and $\left|S_o^{h(l)}\right|$ is the number of triples in the set $S_o^{h(l)}$.

Since the entity representations in the initial entity set are the closest to the user’s interest and preference features, and they have a strong connection with the original representations of the user and item, specifically, because item v has directly related entities in its original representation, whereas user u does not. The original representation of item v can strengthen the embedding representation, which is formally defined as follows (Equations (20) and (21)):

$$e_o^{(0)}={\displaystyle \frac{{\displaystyle {\sum }_{e\in {\epsilon }_o^0}e}}{\left|{\epsilon }_o^0\right|}}$$

(20)

$$e_v^{(origin)}={\displaystyle \frac{{\displaystyle \sum _{e\in \left\{e\right|(e,v)\in A\}}e}}{\left|\right\{e|(e,v)\in A\}|}}$$

(21)

Through the knowledge-aware-attention-embedding filtering layer, the representation set of user u and item v is obtained, as shown in Equations (22) and (23):

$$T_u=\{e_u^{(0)},e_u^{(1)},\dots ,e_u^{(L)}\}$$

(22)

$$T_v=\{e_v^{(origin)},e_v^{(0)},e_v^{(1)},\dots ,e_v^{(L)}\}$$

(23)

4.3. Prediction Layer

Most previous models did not consider the topological proximity structure of entities in the ripple set, and they did not account for the weight influence of each layer. The representation of each layer actually emphasizes different high-order connectivity and preference similarity. To address the weight allocation issue of each layer, a distance-aware approach is used to assign weight values to each layer. First, the Euclidean distance between the user–item vector $e_o^0$ and each layer vector representation $e_o^{(l)}$ is calculated. Since the entity representations in the initial entity set are closest to the user’s interest and preference features, they have a strong connection with the original representations of the user and item. The inverse of the Euclidean distance is used to allocate weight values, ensuring that closer distances receive higher weights. Finally, a normalization operation is performed, effectively resolving the entity relationships between multi-hop ripple sets. The formula is defined as follows (Equations (24)–(26)):

$$dist(e_o^0,e_o^l)=\sqrt{{\displaystyle \sum _{l=1}^n{(e_o^0-e_o^l)}^2}}$$

(24)

$${\alpha }_o^{i_n}={\displaystyle \frac{1}{dist(e_o^0,e_o^l)+\epsilon }}$$

(25)

$${\beta }^{i_n}={\displaystyle \frac{\exp ({\alpha }_o^{i_n})}{{\displaystyle \sum _{n\in L}\exp ({\alpha }_o^{i_n})}}}$$

(26)

where $dist(e_o^0,e_o^l)$ represents the Euclidean distance between the entity set representation of each layer $e_o^l$ and the initial entity set $e_o^0$, $\epsilon$ is a small positive number used to avoid the case where the denominator is zero when the distance is zero, ${\alpha }_o^{i_n}$ is the weight assigned to each layer $e_o^{(l)}$, and ${\beta }^{i_n}$ is the normalized weight. Finally, three aggregators—sum, pool, and concat—are used for aggregation. Through experimentation, we ultimately chose the concat aggregator, which will be discussed in the Experimental Section, because the concat aggregator can combine the information features of multiple ripple sets together. Its formulaic definition is as follows (Equation (27)):

$$ag{g}_{concat}^{(o)}=\sigma (w_a(e_o^o||{\beta }^{i_1}{e}_o^{i_1}||{\beta }^{i_2}{e}_o^{i_2}||\dots \dots ||{\beta }^{i_n}{e}_o^{i_n}))$$

(27)

where $e_o^{i_n}\in T_o$. Finally, the inner product of the user embedding representation and the item embedding representation is used to predict the user’s preference score for the item, as shown in Equation (28):

$${\widehat{y}}_{uv}=e_u^T{e}_v$$

(28)

4.4. Loss Function

To balance the number of positive and negative samples, improve the model’s learning efficiency, and ensure the model’s training effectiveness, an equal number of negative samples as positive samples is extracted for each user. The loss function of the model is defined as follows Equation (29):

$$loss={\displaystyle \sum _{u\in U}({{\displaystyle \sum _{v\in \left\{v\right|(u,v)\in P^{+}\}}\varsigma (y_{uv},{\widehat{y}}_{uv})-{\displaystyle \sum _{v\in \left\{v\right|(u,v)\in P^{-}\}}\varsigma (y_{uv},{\widehat{y}}_{uv})+\lambda ||\Theta ||}}}_2^2)}$$

(29)

where $\varsigma (y_{uv},{\widehat{y}}_{uv})$ is the cross-entropy loss, ${\mathrm{P}}^{+}$ represents the set of positive samples, ${\mathrm{P}}^{-}$ represents the set of negative samples, $\Theta =\{E,R,W_i,b_i,{\forall }_i\in \{0,1,2,a\left\}\right\}$ represents the parameters of the model, where E and R represent all entity embeddings and all relation embeddings, respectively, and $\lambda \left|\right|\Theta |{|}_2^2$ is the L2 regularization with parameter $\lambda$.

5. Experiment

In this section, the KGAEUF model will be evaluated on two real-world datasets to address the following questions:

• How does the KGAEUF model perform compared to the state-of-the-art propagation-based recommendation models?
• Does the use of similar user entity set enhancement representation and the neighbor score selection denoising module contribute to improving the accuracy of the recommendation results?
• How do different parameter choices affect the proposed model method?

5.1. Experimental Datasets

To evaluate the effectiveness and generalizability of the KGAEUF model, experiments were conducted on two real-world datasets, Last.FM and Book-Crossing, as shown in

Table 1. Statistical data for Last.FM and Book-Crossing datasets.

Dataset	Users	Items	Interactions	Entities	Relations	Triples
Last.FM	1872	3846	42,346	9366	60	15,518
Book-Crossing	17,860	14,976	139,746	77,903	25	151,500

:

• The Last.FM dataset is provided by the Last.FM online music system and contains information on the social networks, tags, and music artists of over 2000 users.
• The Book-Crossing dataset collects ratings (0–10) from different readers in the Book-Crossing community for various books.

The datasets used in the experiment are the preprocessed Last.FM and Book-Crossing datasets, with each dataset randomly divided into training, validation, and test sets in a 6:2:2 ratio.

5.2. Comparison Models

To evaluate the effectiveness of the model, it was compared with seven propagation-based recommendation methods. Among them, RippleNet, KGCN, and KGAT are classic knowledge graph attention network recommendation models, while KAT, RFAN, MDAR, and KPMER are mainstream knowledge graph attention network recommendation models in recent years, as shown below:

• RippleNet [23] is a classic propagation-based method that enhances user representations by propagating users’ latent preferences in the knowledge graph.
• KGCN [24] is a classic propagation-based method that selectively aggregates neighborhood information using graph convolution, enriching user–item representations.
• KGAT [25] is a classic propagation-based method that forms a collaborative knowledge graph by combining the user–item interaction graph with the knowledge graph, using attention mechanisms to distinguish the importance of different neighbors in the collaborative knowledge graph.
• KAT [6] is a neighbor sampling mechanism is designed, which calculates the maximum node influence by extracting the largest connected subgraph, avoiding the instability in model performance caused by random sampling.
• MDAR [28] combines DeepFM with the attention mechanism, integrating relationships into the attention network of the knowledge graph.
• RFAN [29] emphasizes the importance of modeling relationships between entities in the knowledge graph and extends user preferences by exploring various relationships around entities.
• KPMER [30]: By utilizing a lightweight graph convolutional network to more effectively aggregate higher-order neighborhood information from the knowledge graph, this method improves the accuracy of neighborhood feature extraction and ensures the acquisition of more appropriate shared information.

5.3. Experimental Environment and Parameter Settings

The experimental environment consists of Windows 11, RTX 3060, Anaconda 3, Python 3.9, CUDA 11.5.2, CuDNN 8.3.2, and PyTorch 1.12.0. Each dataset is split into training, validation, and test sets in a 6:2:2 ratio. The model trained on the training set is used to predict the interaction probability of user–item pairs in the test set, with AUC and F1 scores as evaluation metrics. The model is optimized using Adam, with a fixed batch size of 1024. The model parameters are initialized using Xavier, with the learning rate $\delta$ adjusted between $\{{10}^{-3},5\times {10}^{-3},{10}^{-2},5\times {10}^{-3}\}$, L2 regularization coefficient $\lambda$ adjusted between $\{{10}^{-5},{10}^{-4},{10}^{-3},{10}^{-2}\}$, and embedding size d searched within the range of $\{8,16,32,64,128,256\}$. Due to the varying size of the user–item triplet sets, the size of user and item sets is searched within the range of $\{4,8,16,32,64\}$. $\{1,2,3,4\}$ represents the range of ripples, and the hop count L. In the following experiments, the embedding dimension d is set to 64, as lower dimensions may lead to insufficient feature representation, while higher dimensions increase computational complexity. This value is based on the experimental settings of RippleNet and KGAT [23,25]. $\delta$ is set to $5\times {10}^{-3}$, determined through hyperparameter tuning on the validation set. This setting balances convergence speed and optimization effectiveness, as referenced from related literature [26]. $\lambda$ is set to ${10}^{-5}$ to prevent model overfitting, with this value selected based on best practices for similar models in the literature [35].

5.4. Evaluation Metrics

AUC, F1 score, and recall are selected as evaluation metrics. AUC is a metric used to evaluate the performance of binary classification models, typically representing the area under the ROC curve (Receiver Operating Characteristic curve). The ROC curve is plotted with the True Positive Rate (also known as sensitivity) on the vertical axis and the False Positive Rate on the horizontal axis.

The F1 score is calculated using precision and recall.

$$\mathrm{Precision}={\displaystyle \frac{TP}{TP+FP}}$$

(30)

Here, TP represents the number of truly relevant samples, FP represents the number of samples incorrectly labeled as relevant, and FN represents the number of samples incorrectly labeled as irrelevant.

Recall: Recall refers to the proportion of truly relevant samples that are successfully recommended. The calculation formula is as follows:

$$Recall={\displaystyle \frac{TP}{TP+FN}}$$

(31)

F1-score: The F1-score is the harmonic mean of precision and recall, which combines the performance of both. The calculation formula is as follows:

$$\mathrm{F}1={\displaystyle \frac{2\times (Precision\times Recall)}{Precision+Recall}}$$

(32)

5.5. Performance Comparison

The experiment used seven baseline models for comparison, and the AUC and F1 values obtained from two public datasets were compared.

Table 2. Comparison of model performance.

	Last.FM	Last.FM	Book-Crossing	Book-Crossing
Model	AUC	F1	AUC	F1
RippleNet	0.776 (−7.8%)	0.702 (−8.1%)	0.721 (−3.7%)	0.647 (−3.6%)
KGCN	0.802 (−5.2%)	0.708 (−7.5%)	0.684 (−7.4%)	0.631 (−5.2%)
KGAT	0.829 (−2.5%)	0.742 (−4.1%)	0.731 (−2.7%)	0.654 (−2.9%)
KAT	0.810 (−4.4%)	0.724 (−5.9%)	0.716 (−4.2%)	0.648 (−3.5%)
KPMER	0.799 (−5.5%)	0.712 (−7.1%)	0.732 (−2.6%)	0.659 (−2.4%)
RFAN	0.839 (−1.5%)	0.764 (−1.9%)	0.746 (−1.2%)	0.672 (−1.1%)
MDAR	0.842 (−1.2%)	0.768 (−1.5%)	0.753 (−0.5%)	0.675 (−0.8%)
KGAEUF	0.854	0.783	0.758	0.683

shows the comparison of the AUC and F1 values of KGAEUF with the other seven models. The following observations can be made from this Table:

• The AUC value of KGAEUF on the Last.FM dataset reached 0.854, representing a 1.2% improvement over MDAR, and the F1 score reached 0.783, improving by 1.5% over MDAR. This improvement is attributed to the introduction of the user collaborative propagation module, which enhances the initial user entity representation, significantly improving the model’s ability to distinguish between positive and negative samples.
• The AUC value of KGAEUF on the Book-Crossing dataset reached 0.758, representing a 1.2% improvement over RFAN, and the F1 score reached 0.683, improving by 1.1% over RFAN. This indicates that the noise-reduction module effectively mitigates the negative impact of noisy entities on recall and simultaneously improves the model’s precision.
• Compared with the classic RippleNet model, RippleNet generates the initial entity set through historical interactions but does not consider user similarity. KGAEUF’s user collaborative propagation module enhances the initial representation, significantly improving the model’s discriminative ability. Compared with the KGAT model, which uses a fixed-attention mechanism to assign weights to neighboring entities, KGAEUF introduces knowledge-aware relation vectors, making weight assignment more targeted. Compared with RFAN, which ignores the impact of multi-level topological structures during entity-enhanced representation, KGAEUF’s hierarchical weighting mechanism dynamically adjusts layer weights, further optimizing user and item embeddings.
• KGAEUF performs differently on the Last.FM and Book-Crossing datasets, mainly because the Last.FM dataset includes richer social network and music artist information, with concentrated user interests and relatively uniform entity distribution. As a result, the user collaborative propagation module can more effectively leverage user similarity, improving recommendation performance. In contrast, the Book-Crossing dataset exhibits more diverse user interests, and random noise has a greater impact on model performance, resulting in a slightly lower improvement margin. However, the noise-reduction module plays a positive role in reducing the interference of irrelevant entities, ensuring the stability of AUC and F1 scores.

At the same time, we also recorded the top-k curves for the LAST.FM and Book-Crossing datasets. Figure 4 and Figure 5 show the Recall@k line charts for the LAST.FM and Book-Crossing datasets at k = {5, 10, 20, 50}, respectively. The following observations can be made from these Figures:

On the LAST.FM and Book-Crossing datasets, the KGAEUF model significantly outperforms other baseline models in top-K recommendation. When k = {5, 10, 20, 50}, the recall values of the KGAEUF model are higher than those of the advanced models RFAN, KPMER, MDAR, and KAT. This further confirms the effectiveness of the methods that enhance entity set representation by considering similar user relationships, remove irrelevant entities, apply knowledge-aware attention to allocate weights to neighbor entities, and utilize distance-aware embedding in the ripple set layer.

5.6. Ablation Experiment

Through ablation experiments, we verified the impact of the user collaborative propagation and noise-reduction modules on model performance, designing the following two KGAEUF variant methods:

KGAEUF1: This variant method removes the denoising module from KGAEUF to verify whether eliminating irrelevant entities can optimize the recommendation accuracy.

KGAEUF2: This variant method removes the similar user-enhanced linked entity set from KGAEUF to verify whether adding the similar user project set can optimize the recommendation accuracy.

Table 3. Ablation experiments.

	Last.FM	Last.FM	Book-Crossing	Book-Crossing
Model	AUC	F1	AUC	F1
KGAEUF1	0.834	0.770	0.743	0.668
KGAEUF2	0.836	0.773	0.745	0.670
KGAEUF	0.854	0.783	0.758	0.683

shows the recommendation results of KGAEUF and its two variant methods on two datasets. The following observations can be made from this table:

• After removing the KGAEUF2 module, the model’s AUC value on the Last.FM dataset decreased by 1.8%, and the F1 score decreased by 1%. On the Book-Crossing dataset, the AUC value decreased by 1.3%, and the F1 score decreased by 1.3%. This indicates that linking entities of similar users plays a critical role in enhancing embedding representations.
• After removing the KGAEUF1 module, the model’s AUC value on the Last.FM dataset decreased by 2%, and the F1 score decreased by 1.3%. On the Book-Crossing dataset, the AUC value decreased by 1.5%, and the F1 score decreased by 1.5%. This indicates that the noise-reduction module also plays a critical role in enhancing embedding representations.
• Considering the evaluation metrics across both datasets, KGAEUF2 demonstrates better recommendation accuracy than KGAEUF1. The results indicate that addressing both user–relation and user–entity perspectives and setting scoring functions tailored to different user preferences to filter irrelevant entity information play a more crucial role in learning user and item embeddings.

5.7. Aggregator Selection

KGAEUF generates user and item embeddings by aggregating ripple set embeddings.

Table 4. Aggregator experiments.

	Last.FM	Last.FM	Book-Crossing	Book-Crossing
Aggregator	AUC	F1	AUC	F1
pool	0.812	0.753	0.712	0.651
sum	0.814	0.756	0.723	0.663
concat	0.854	0.783	0.758	0.683

compares the results of three aggregators: pool, sum, and concat, on two different datasets. From the table below, we can make the observations that follow:

• The concat aggregator performed best across all metrics, particularly achieving an AUC of 0.854 and an F1 score of 0.783 on the Last.FM dataset. This is because the concat aggregator preserves the information features of all ripple sets, enabling more fine-grained embedding representations. The sum aggregator ranked second in performance, achieving an AUC of 0.723 on the Book-Crossing dataset. However, summation operations may cause feature imbalance (with high-dimensional features dominating), affecting recommendation diversity. The pool aggregator performed the worst, with metrics on all datasets lower than the other two aggregators. This is because pooling operations discard some feature details, making the model unable to fully capture high-order entity relationships.
• The concat aggregator retains the feature information of all ripple sets at different levels through concatenation, effectively avoiding information loss and providing richer contextual information for user and item embeddings. In contrast, the summation method of the sum aggregator may introduce feature weight imbalances, while the pooling method of the pool aggregator directly discards some detailed information, limiting the model’s ability to capture complex relationships.

5.8. Choice of k Value

The neighbor size k was changed from {2, 4, 8, 16}, and the top k neighbors with the highest scores were selected for aggregation to explore the impact on the KGAEUF model.

Table 5. k-value selection.

	Last.FM	Last.FM	Book-Crossing	Book-Crossing
k	AUC	F1	AUC	F1
2	0.822	0.760	0.735	0.664
4	0.836	0.774	0.745	0.670
8	0.854	0.783	0.750	0.675
16	0.848	0.774	0.758	0.683

reflects the results of different k value selections:

• On the Last.FM dataset, the best results are achieved when k = 8, with an AUC of 0.854 and an F1 score of 0.753. On the Book-Crossing dataset, the best results are achieved when k = 16, with an AUC of 0.758 and an F1 score of 0.683. When k is too small, the results are suboptimal because a small k cannot represent sufficient neighbor information to comprehensively capture user interest features, leading to insufficient information in the embeddings. Conversely, if k is too large, the introduction of noisy entities interferes with model performance, especially affecting precision and AUC metrics.
• In the Last.FM dataset, user interests are more concentrated, so a smaller k value is sufficient to capture user preferences. In the Book-Crossing dataset, user interests are more dispersed and diverse, requiring a larger k value to adequately model user behavior.

5.9. Optimal Number of Layers L

This model refines the embedding of the ripple set through distance-aware processing, so the maximum hop count of the ripple set directly affects the embedding representation of users and items. To validate the impact of the hyperparameter L on recommendation performance, the model’s sensitivity to the number of propagation layers L was analyzed in the experiment. The value of L was varied while keeping other hyperparameters fixed. The experimental results are shown in Figure 6 and Figure 7.

• From the experiments, we observe that the model achieves the best recommendation performance on the Last.FM and Book-Crossing datasets when L = 3 and L = 2. When L = 1, considering only direct neighbors, the model cannot capture the associations of high-order entities, resulting in incomplete user embedding representations. When L = 4 or higher, increasing the number of propagation layers may introduce low-relevance high-order neighbors. These noisy entities are irrelevant to user preferences but interfere with embedding representations, reducing the model’s recommendation performance.
• In the Last.FM dataset, user interests are more concentrated, and high-order neighbor information contributes more significantly to user preference modeling, so the best performance is achieved when L = 3. In the Book-Crossing dataset, user interests are more dispersed, and high-order neighbors may introduce more irrelevant information, so the best performance is achieved when L = 2.

5.10. Recommendation Case Analysis

To demonstrate how the model optimizes user embeddings through user collaborative propagation and neighborhood noise-reduction mechanisms, we conducted a case study on a target user A from the Last.FM dataset and simulated its recommendation process [36]. As shown in Figure 8, the initial entity set of target user A is obtained by identifying user A’s interacted items $I_A=\{M_1:Rock,M_2:Pop,M_3:Jazz\}$ via the historical interaction matrix and aligning the entities $E_A=\{e_1:Guitar,e_2:Vocals,e_3:Saxophone\}$ corresponding to each music item in the knowledge graph. Then, the similarity between user A and other users is calculated, showing that users B and C have the highest similarity to the target user $sim(A,B)=0.8,sim(A,C)=0.6$. Therefore, we linked the entity sets of users B and C $\{e_4:Drums,e_5:Bass\}$ to user A’s entity set, generating an expanded entity set $\{e_1,e_2,e_3,e_4,e_5\}$. Finally, noise reduction is applied to the expanded entity set $\{e_1,e_2,e_3,e_4,e_5\}$, calculating relevance scores, user–entity weights, user–relation weights, and overall scores $w(e_1)=0.6,w(e_2)=0.7,w(e_3)=0.5,w(e_4)=0.65,w(e_5)=0.4$, and selecting the most relevant entities. Through the above process, the initial entity set of target user A is optimized from $\{e_1,e_2,e_3\}$ to $\{e_1,e_2,e_4\}$, thereby reducing the impact of noise. Based on the final embedding representation of user A, the model predicts user preferences for non-interacted items, resulting in the recommended items $\{M_4:Rock Album,M_5:Pop \mathrm{Album}\}$. User A’s actual records show high preference scores for M₄ and M₅, verifying the accuracy of the recommendation results.

5.11. Limitations of the Model

Although the KGAEUF model performed well in experiments, it still has the following limitations: (1). Insufficient cross-domain recommendation capability: the model primarily relies on users’ historical interaction records, making it limited in cross-domain recommendations, such as when users switch from books to music. (2). High computational complexity: due to the introduction of user collaborative propagation and noise-reduction mechanisms, the model has lower training efficiency on large-scale datasets, leaving room for further optimization.

6. Conclusions

Knowledge-graph-attention-network-based recommendation models are currently a research hotspot in recommendation systems. Existing knowledge graph recommendation models have not taken into account the relationships between users and the influence that similar users can have on the recommendation results. Additionally, after entity enhancement, the random walk algorithm may select neighbors of fixed size, which introduces noise from selecting low-relevance entities. This paper proposes a personalized recommendation method based on knowledge-graph-enhanced user features, called the KGAEUF model. This method computes the top-K most similar users to the target user and links their project entity sets to the initial entity set. The enhanced-entity set undergoes denoising, where neighbor entities with the highest scores are selected from both the user–relationship and user–entity perspectives to reduce noise. The introduction of relationship-aware attention enables more accurate allocation of neighbor entity weights. Considering the topological structure of each layer’s entities, a distance-aware method is used to assign weight values to each layer, resulting in more accurate user and item embeddings. Extensive experiments on two real-world datasets demonstrate that the proposed KGAEUF model outperforms the state-of-the-art knowledge graph attention network-based recommendation models in recommendation accuracy, thereby improving the precision of the recommendations. To address the model’s limitations, future improvements can be made in the following areas: Multimodal data integration: Incorporating multimodal information such as text, images, or videos into the knowledge graph to capture richer user preference features. For example, combining users’ reading histories and viewing records can improve cross-domain recommendation performance. Improving model efficiency: optimizing the model’s computational complexity by introducing lightweight network structures (e.g., simplified graph neural networks or compression algorithms) to make it suitable for large-scale recommendation scenarios. Exploring temporal dynamics: Incorporating time-aware mechanisms to model the dynamic evolution of user interests over time, thereby improving the model’s performance in long-term recommendation tasks.