Incremental graph recommendation method based on streaming data

Abstract

The application discloses a kind of incremental graph recommendation methods based on streaming data, the purpose is to solve the technical problem that existing graph recommendation method cannot efficiently obtain the characteristics of new user and item for recommendation.The application constructs the interaction bipartite graph of user and item by the historical item interaction sequence of user, and extracts the characteristics of user and item by lightweight graph convolutional neural network.For the increased user-item interaction data, sample the corresponding negative sample node in the interaction bipartite graph to construct the triplet, determine the affected node, and update the affected node characteristics by updating module;Finally, the updated node characteristics are used to generate a recommendation list for the user.The method uses advanced lightweight graph convolutional neural network to obtain the characteristics of user and item, and designs an incremental updating method for user and item characteristics.The model has low complexity and good performance, and can effectively solve the problem of low computational efficiency and heavy workload of recommendation methods when facing large-scale data.

Description

Technical Field

[0001] This invention relates to the field of information recommendation technology, and specifically to an incremental graph recommendation method based on streaming data. Background Technology

[0002] With the widespread adoption of the internet and mobile devices, massive amounts of data are generated every moment, making "information overload" a problem that cannot be ignored. Therefore, recommender systems have emerged. Recommendation methods are the core of recommender systems; good methods can help users extract content of interest from massive amounts of information. Collaborative filtering is a widely used concept in recommender methods. In traditional collaborative filtering models, the interaction between users and items is only considered in the objective function trained on the model, leading to underutilization of interaction data. To better utilize user-item interactions and mine higher-order connections, graph machine learning methods have been introduced into recommender methods. Meanwhile, in real-world scenarios, new users and items are constantly increasing; how to efficiently acquire the features of new users and items for recommendation is a crucial issue.

[0003] Most industrial recommender systems are divided into two phases: the recall phase and the ranking phase. The recall phase typically employs multi-path recall strategies, such as using interest tags, collaborative filtering, interest entities, popular tags, and preference-based methods to directly recall relevant items for recommendations. Because the recall layer involves large amounts of data, the models used must not be overly complex. Most existing graph recommender algorithms primarily focus on improving accuracy and recall, resulting in high model complexity that does not meet the requirements of the recall layer, and they rarely consider the efficient acquisition and updating of features as data increases. Summary of the Invention

[0004] The purpose of this invention is to overcome the above-mentioned deficiencies in the prior art and provide an incremental graph recommendation method based on streaming data.

[0005] The objective of this invention can be achieved by adopting the following technical solutions:

[0006] An incremental graph recommendation method based on streaming data, the incremental graph recommendation method includes the following steps:

[0007] S1. Construct a user-item interaction bipartite graph from the user-item interaction data, where nodes are users or items, and edges represent the interaction behaviors between users and items.

[0008] S2. Use a lightweight graph convolutional neural network to learn the features of the nodes in the interactive bipartite graph constructed in step S1, i.e. the features of users or items.

[0009] S3. For each new user-item interaction data, sample an item that the user has not interacted with from all items, and form a triple with the new user and the interacting item.

[0010] S4. Based on the characteristics of users and items in the triples in step S3, calculate the impact of the newly added interaction data on the original interaction bipartite graph, and propagate the impact to its neighborhood in the interaction bipartite graph through the triples.

[0011] S5. Based on the updated user or item features in step S4, calculate the feature similarity between users and items and sort them to generate a list of recommended items for the user.

[0012] Further, in step S2, the lightweight graph convolutional neural network takes randomly initialized node features as input, aggregates the features of K layers of neighboring nodes of a node, and stacks the features of each layer as the final output node features. The lightweight graph convolutional neural network is designed to meet the algorithm efficiency requirements of incremental graphs. It includes:

[0013] Define the initial features of user nodes in the interactive bipartite graph as follows: The initial characteristics of an item node are: The initial features of nodes are randomly initialized, where the subscript indicates the corresponding user node or item node, and the superscript indicates the layer number in the lightweight graph convolutional neural network. We assume the initial features of a node are considered to be at layer 0. Since user and item nodes only possess ID information identifying their identity in the recall layer stage, and lack specific semantic information, the node features are randomly initialized, and the lightweight graph convolutional neural network is trained to acquire higher-order neighborhood information.

[0014] The output of each layer of the lightweight graph convolutional neural network is set as follows:

[0015]

[0016]

[0017] Where, N u N represents the neighbors of a user node. i Represents the neighbors of an item node, |N u | and |N i | These represent the number of neighbors for the user node and the number of neighbors for the item node, respectively. The aggregation parameter is a symmetric normalized parameter ranging from 0 to 1. It not only prevents information overload during feature propagation but also considers the topological information of the nodes at both ends during feature propagation. Specifically, for a node u, if the number of interactions with its connected node i is small, i.e., the number of neighbors |N... iIf the value is smaller, it proves that node u is more important than node i. (Aggregation parameter) The aggregation parameter will be larger if the initial node features are larger, and vice versa. This aligns with our actual situation. By inputting the previously defined initial node features into the above formula, we can iteratively obtain the aggregation features of nodes from k=1 to k=K. These represent the outputs of user nodes at layers k and k+1 of the lightweight graph convolutional neural network, respectively. These represent the outputs of the item nodes in the k-th and k+1-th layers of the lightweight graph convolutional neural network, respectively.

[0018] The final feature of a node is obtained by stacking the features of each layer. Stacking the features of each layer not only fully considers the neighborhood information of different ranges of the node, but also avoids the oversmoothing problem of traditional graph convolutional neural networks. The expression is:

[0019]

[0020]

[0021] Among them, h u and h i These represent the final characteristics of user nodes and item nodes, respectively.

[0022] Furthermore, in step S3, the triple is defined as (h u ,h im ,h in ), where h u h represents the user's final characteristics. im h represents the final characteristic of the item that interacted with the aforementioned user. in This represents the final features of items that the user has not interacted with. This is a triplet based on Bayesian Personalized Ranking, a classic method in recommender systems. The Bayesian Personalized Ranking principle posits that items interacted with by the user should rank higher than those not interacted with. Therefore, we sample items that the user has interacted with and those that haven't to form triples for subsequent training.

[0023] Further, in step S4, the direct impact of the interaction data on the original interaction bipartite graph is represented by the influence of the features of user-interacted and non-interacted items in the triples on the user, and the user's influence on interacted and non-interacted items; the formula for calculating the influence is:

[0024] Δh (0) =α·h,

[0025] Where, Δh (0) Let be the change in the initial characteristics of the affected node, h be the final characteristics of the node exerting the influence, and α be an adaptive parameter for adjusting the intensity of the influence, expressed as:

[0026] α=σ(h u ·h in -h u ·h im ),

[0027] Here, σ is the sigmoid activation function, which maps the influence intensity modulator between 0 and 1. α utilizes the user feature h. u Features of non-interacting items h in and interactive item features h im The similarity difference is used to adjust the influence strength. When the similarity between user features and the features of non-interactive items is higher than the similarity between user features and the features of interactive items, it does not conform to the Bayesian personalized ranking idea. The feature update amount should be increased. At this time, α will be closer to 1. Conversely, α will be closer to 0, which proves that the model converges.

[0028] The influence is passed from the affected node to its neighborhood layer by layer using a breadth-first search. The transmission parameter from the user node to the item node is defined as... This is the same as the definition of the aggregation parameter mentioned above, reflecting the principle of symmetry;

[0029] The influence quantity and its propagated influence quantity are accumulated onto the initial features of the corresponding node to complete one training cycle.

[0030] Furthermore, in step S5, the updated initial features of the nodes are input into a lightweight graph convolutional neural network to obtain the final features of the nodes; the inner product is used to calculate the similarity between users and items and sort them, and a list of recommended items for users is generated based on the sorting results.

[0031] The present invention has the following advantages and effects compared with the prior art:

[0032] This invention discloses an incremental graph recommendation method based on streaming data. It employs a lightweight recommendation approach for the recall phase of a two-stage recommendation system, utilizing an advanced lightweight graph convolutional neural network to acquire user / item features. By fully leveraging historical interaction data, it achieves high accuracy. For the rapidly growing user interaction data, an efficient feature update method is designed, constructing triples for new interaction data and calculating the impact propagation to locally affected nodes. This not only trains features for new data but also transfers the impact of new data to the original interaction bipartite graph, enabling the model to achieve excellent recall performance without retraining. This method satisfies the efficiency, accuracy, and scalability requirements of recommendation systems while fully utilizing user and item interaction data. Attached Figure Description

[0033] The accompanying drawings, which are included to provide a further understanding of the invention and form part of this application, illustrate exemplary embodiments of the invention and, together with their description, serve to explain the invention and do not constitute an undue limitation thereof. In the drawings:

[0034] Figure 1 This is a schematic diagram of the user-item interaction bipartite graph in an embodiment of the present invention;

[0035] Figure 2 This is a flowchart illustrating the incremental graph recommendation method based on streaming data provided in an embodiment of the present invention.

[0036] Figure 3 This is a schematic diagram illustrating the process of mutual influence and propagation of influence among triples in an embodiment of the present invention;

[0037] Figure 4 This is a schematic diagram of the simulation process dataset evaluation method of the present invention. Detailed Implementation

[0038] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0039] Example 1

[0040] This embodiment uses, as follows Figure 2 The implementation steps shown provide a process for training and recommending the initial interactive bipartite graph. This includes the following steps:

[0041] S1. Construct a user-item interaction bipartite graph from the user-item interaction data, where nodes are users or items, and edges represent the interaction behaviors between users and items.

[0042] The specific implementation of step S1 is as follows: Obtain the interaction data between the user and the item, and perform implicit feedback processing on the data; that is, set the interaction strength to 1 if the user interacts with the item, and 0 otherwise. Then, use the networkx package to store the bipartite graph of user-item interactions. First, create an undirected, unweighted graph using networkx, and then input the user-item interaction data into the graph created by networkx one edge at a time. The final result will be as follows: Figure 1 The interactive bipartite graph shown has user nodes and item nodes, with edges representing interactions between users and items. In this graph, there are no direct edges between users or between items.

[0043] S2. Use a lightweight graph convolutional neural network to learn the features of the nodes in the interactive bipartite graph constructed in step S1, i.e. the features of users or items.

[0044] The specific implementation of step S2 is as follows: For each node in the interactive bipartite graph constructed in step S1, a 128-dimensional node feature is randomly initialized. The features of user nodes and item nodes are denoted as follows: and The subscripts represent user node u and item node i, respectively, and the superscript indicates that the initial characteristics of the node are considered to be at level 0.

[0045] The aggregator of a lightweight graph convolutional neural network is defined as:

[0046]

[0047]

[0048] By aggregating node features three times through an aggregator, a multi-layer feature vector group for the user is obtained. With item multi-layer feature vector group Since the aggregation process does not involve feature dimension mapping, the node multi-layer features in the node multi-layer feature vector group are all 128-dimensional.

[0049] Then, by stacking the features of each layer of the node, the final feature of the node is obtained, expressed as:

[0050]

[0051]

[0052] Among them, h u and h i These represent the final characteristics of user nodes and item nodes, respectively. Since the aggregation process of nodes in the diagram is independent of each other, it can be carried out in parallel. The number of nodes for parallel aggregation can be determined based on the actual equipment and the size of the data to be processed.

[0053] S3. For each new user-item interaction data, sample an item that the user has not interacted with from all items, and form a triple with the new user and the interacting item.

[0054] The specific implementation of step S3 is as follows: Since the interaction bipartite graph was constructed through the aforementioned step S1 and has not yet been trained, all edges are considered as newly added interaction data. Triples (h...) are constructed for all users in the interaction bipartite graph. u ,h im ,h in ), where h uThis represents the user's final characteristics. im The final characteristics of the items that have interacted with the aforementioned user are represented by node im, which is randomly sampled from the items that have interacted with user u. in The final characteristics of items that have not been interacted with by the aforementioned user are represented by node in, which is randomly sampled from all items except those interacted with by user u.

[0055] S4. Based on the characteristics of users and items in the triples from step S3, calculate the impact of the newly added interaction data on the original interaction bipartite graph, and propagate the impact to its neighborhood in the interaction bipartite graph through the triples. The specific process is as follows: Figure 3 As shown;

[0056] The specific implementation of step S4 is as follows: The direct impact of interactive data on the original interactive bipartite graph is represented by the influence of the characteristics of user-interacted and non-interacted items in the triplet on the user, and the user's influence on interacted and non-interacted items. The formula for calculating the influence is:

[0057] Δh (0) =α·h,

[0058] Where, Δh (0) Let be the change in the initial characteristics of the affected node, h be the final characteristics of the node exerting the influence, and α be an adaptive parameter for adjusting the intensity of the influence, expressed as:

[0059] α=σ(h u ·h in -h u ·h im ),

[0060] Here, σ is the sigmoid activation function, which maps the influence intensity modulator between 0 and 1. α utilizes the user feature h. u Features of non-interacting items h in and interactive item features h im The similarity difference is used to adjust the influence strength. When the similarity between user features and the features of non-interactive items is higher than the similarity between user features and the features of interactive items, it does not conform to the Bayesian personalized ranking idea. The feature update amount should be increased. At this time, α will be closer to 1. Conversely, α will be closer to 0, which proves that the model converges.

[0061] The influence is passed from the affected node to its neighborhood layer by layer using a breadth-first search. The transmission parameter from the user node to the item node is defined as...

[0062] The influence quantity and its propagated influence quantity are accumulated onto the initial features of the corresponding node to complete one training cycle.

[0063] Repeat step S4 until the adaptive parameter α approaches 0, proving that the lightweight graph convolutional neural network has converged and completing the training.

[0064] S5. Based on the updated user or item features in step S4, calculate the feature similarity between users and items and sort them to generate a list of recommended items for the user.

[0065] The specific implementation of step S5 is as follows: using the updated initial features of the nodes, inputting them into a lightweight graph convolutional neural network to obtain the final features of the nodes; and using the inner product to calculate the similarity between users and items and sorting them, generating a list of recommended items for users based on the sorting results.

[0066] This embodiment provides a recommendation method that constructs an original interactive bipartite graph from interaction data and trains it. By introducing a lightweight graph convolutional neural network into the recommendation system, different graph convolutional layers can acquire low-order and high-order features of nodes, helping the recommendation method better understand the relationship between users and items, theoretically improving the effectiveness of prediction results. At the same time, the lightweight network better meets the efficiency requirements of practical recommendation systems.

[0067] Example 2

[0068] To address the training process of streaming data, a graph recommendation method for incremental data is provided. This embodiment builds upon the foundation of node features of the original interactive bipartite graph already trained using a lightweight graph convolutional neural network. For incremental data, there is no need to retrain the network; instead, the impact of the new data is propagated across the interactive bipartite graph.

[0069] First, we also perform initial feature randomization on the newly added nodes, and then refer to step S2 in Example 1 to obtain the final features of the newly added nodes using the following formula.

[0070]

[0071]

[0072]

[0073]

[0074] Among them, the neighbors of the newly added node are: N u or N i Node features or It was already trained on the original interactive bipartite graph.

[0075] Then, referring to step S3 in Example 1, construct triples (h) for the users in the newly added node. u ,h im ,hin Meanwhile, referring to step S4 in Example 1, the impact of the newly added node on the original interactive bipartite graph is transferred to the affected node using the following formula:

[0076] Δh (0) =α·h,

[0077] α=σ(h u ·h in -h u ·h im ).

[0078] The impact is then passed from the affected node to its neighborhood layer by layer using a breadth-first search. The transmission parameter from the user node to the item node is defined as... Finally, the influence quantity and its propagated influence quantity are accumulated onto the initial features of the corresponding nodes to complete one incremental training.

[0079] Iterate through the above steps until the adaptive parameter α approaches 0, and the incremental training of the node is complete.

[0080] The process of generating the user recommendation list is the same as step S5 in Example 1, and will not be repeated here.

[0081] The beneficial effects of this embodiment are as follows:

[0082] Compared to typical graph recommendation methods, this approach addresses incremental data processing, directly considering the impact of incremental data on the original interaction bipartite graph and updating only the features of affected nodes. Unlike typical recommendation methods that require model retraining, this method is more efficient. Furthermore, while retraining the model results in the loss of temporal information, this method allows node features to focus more on recent interactions, thereby improving recommendation performance.

[0083] The following provides experimental data comparing our method, referred to here as IPM, with existing lightweight recommendation models LightGCN and existing incremental graph methods GloDyNE, FILDNE, and DeepWalk:

[0084] (1) Simulation data settings:

[0085] The datasets used are MovieLens-1M and LastFM, real-world datasets. MovieLens-1M contains ratings from multiple users for various movie projects; here, we selected a dataset containing 6040 users, 3706 movie projects, and a total of 1000209 interactions, with a sparsity of approximately 4.47%. Ratings are considered implicit feedback within the interactions. LastFM is a real-world music recommendation dataset containing track and artist information. We considered recommending artists to users and, following the 20-core processing of the MovieLens-1M dataset, ensured at least 20 interactions per user. The processed dataset contains 983 users and 35432 artists, with a total of 18138847 interactions and a sparsity of approximately 52.08%.

[0086] (2) Performance indicator settings:

[0087] To better simulate the arrival of the data stream, we divided the dataset into two parts chronologically: (i) approximately the first 60% of the data was used to build the initial graph and train the original model; (ii) the remaining 40% of the data was called the candidate test set, used to simulate the streaming setup. It's important to note that we determined the split point based on the number of days rather than the amount of data. We further divided the candidate test set into 10 parts chronologically, with each part representing 4% of the total number of days, such as... Figure 4 As shown.

[0088] The first part of the candidate test set, i.e., 60% to 64%, is used as the test set for the original model. This data is then fed into the original model for incremental training, and the next part, i.e., 64% to 68%, is used as the test set.

[0089] Repeat this process until 96%–100% of the tests are completed.

[0090] For each user in the test set, we treat all items the user hasn't interacted with as a list of candidate items to recall, and then output a preference score for these items for each method. Typically, we only recommend the top K items to the user. To evaluate the effectiveness of these preference score rankings, we use widely used metrics: Precision@K, Recall@K, and NDCG@K. In our simulation, we fix K at 20.

[0091] (3) Simulation parameter settings:

[0092] Simulations were performed using Python. The feature dimension was set to 128 for all methods. For LightGCN, DeepWalk, and GloDyNE, we used the parameter settings recommended in their respective papers to train the models. For FILDNE, we used the hyperparameter search method provided in the open-source code to obtain the hyperparameters before training. For this method, the number of sampled triples in the initial graph was set to 5 times the number of interactions in the initial graph, and the number of propagation layers was set to 3 hops.

[0093] All methods were run 5 times on the same device, and the mean and standard deviation are shown in Tables 1 and 2. Precision, Recall, and NDCG are converted to percentages, and the running time is in seconds.

[0094] Table 1. Comparison of results of different recommendation methods on MovieLens-1M

[0095]

[0096] Table 2. Comparison of results of different recommendation methods on LastFM

[0097]

[0098] As shown in Tables 1 and 2, the IPM method achieves optimal performance across all recommendation metrics on both datasets. This demonstrates that IPM improves recommendation accuracy compared to existing models; furthermore, IPM significantly enhances runtime efficiency compared to existing models.

[0099] The above embodiments are preferred embodiments of the present invention, but the embodiments of the present invention are not limited to the above embodiments. Any changes, modifications, substitutions, combinations, or simplifications made without departing from the spirit and principle of the present invention shall be considered equivalent substitutions and shall be included within the protection scope of the present invention.

Claims

1. An incremental graph recommendation method based on streaming data, characterized in that, The incremental graph recommendation method includes the following steps: S1. Construct a user-item interaction bipartite graph from the user-item interaction data, where nodes are users or items, and edges represent the interaction behaviors between users and items. S2. Use a lightweight graph convolutional neural network to learn the features of the nodes in the interactive bipartite graph constructed in step S1, i.e. the features of users or items. S3. For each newly added user-item interaction data, sample one item that the user has not interacted with from all items, and form a triple with the newly added user and the interacting item; where, the triple is defined as (h u ,h im ,h in ), where h u h represents the user's final characteristics. im h represents the final characteristic of the item that interacted with the aforementioned user. in This represents the final characteristics of items that have not been interacted with by the aforementioned user; S4. Based on the characteristics of users and items in the triples from step S3, calculate the impact of the newly added interaction data on the original interaction bipartite graph, and propagate the impact to its neighborhood in the interaction bipartite graph through the triples; in step S4, the direct impact of the interaction data on the original interaction bipartite graph is represented by the impact of the characteristics of user interaction and non-interactive items in the triples on the user, and the impact of the user on interactive and non-interactive items; the formula for calculating the impact is: Δh (0) =α·h, Where, Δh (0) Let be the change in the initial characteristics of the affected node, h be the final characteristics of the node exerting the influence, and α be an adaptive parameter for adjusting the intensity of the influence, expressed as: α=σ(h u ·h in -h u ·h im ), Where σ is the sigmoid activation function; The influence is passed from the affected node to its neighborhood layer by layer using a breadth-first search. The passed parameters are the same as the aggregation parameters; that is, the passed parameters from the user node to the item node are defined as follows: Where, N u N represents the neighbors of a user node. i Represents the neighbors of an item node, |N u | and |N i | These represent the number of neighbors for the user node and the number of neighbors for the item node, respectively. Indicates the aggregation parameter; The influence quantity and its propagated influence quantity are accumulated onto the initial features of the corresponding node to complete one training cycle; S5. Based on the updated user or item features in step S4, calculate the feature similarity between users and items and sort them to generate a list of recommended items for the user.

2. The incremental graph recommendation method based on streaming data according to claim 1, characterized in that, In step S2, the lightweight graph convolutional neural network takes randomly initialized node features as input, aggregates the features of the K layers of neighboring nodes of a node, and stacks the features of each layer as the final output node features, including: Define the initial features of user nodes in the interactive bipartite graph as follows: The initial characteristics of an item node are: The initial features of the nodes are randomly initialized, where the subscript indicates the corresponding user node or item node, and the superscript indicates the layer number in the lightweight graph convolutional neural network. Let's assume the initial features of the nodes are considered to be at layer 0: The output of each layer of the lightweight graph convolutional neural network is set as follows: By inputting the initial node features defined above, the aggregated features of nodes from k=1 to k=K are obtained iteratively. These represent the outputs of user nodes at layers k and k+1 of the lightweight graph convolutional neural network, respectively. These represent the outputs of the item nodes in the k-th and k+1-th layers of the lightweight graph convolutional neural network, respectively. The final feature of a node is obtained from the features of each layer of stacked nodes, expressed as: Among them, h u and h i These represent the final characteristics of user nodes and item nodes, respectively.

3. The incremental graph recommendation method based on streaming data according to claim 1, characterized in that, In step S5, the updated initial features of the nodes are input into a lightweight graph convolutional neural network to obtain the final features of the nodes; the inner product is used to calculate the similarity between users and items and sort them, and a list of recommended items for users is generated based on the sorting results.

Images