A commodity recommendation model training method based on transverse federation and multi-element representation

Abstract

This invention relates to a product recommendation model training method based on horizontal federation and multi-dimensional representation. The method includes: a central server running a key generation algorithm to generate its public and private keys, and sending the public key to the clients participating in the current round of federated learning via a secure channel; the central server distributing a global product recommendation model to each client; each client training the global product recommendation model using local user-product interaction data to obtain a local product recommendation model; encrypting the local product recommendation model and performance metrics using the central server's public key and uploading it to the central server; the central server decrypting the encrypted local product recommendation model and performance metrics from each client using its private key, and aggregating the local product recommendation models uploaded by each client based on the performance metrics to obtain the global product recommendation model for the next round of iteration training; repeating the above steps until the global product recommendation model converges or reaches a preset number of iterations, resulting in a trained product recommendation model. This invention can improve the real-time performance and accuracy in recommendation, while also enhancing the model's generalization ability.

Description

Technical Field

[0001] This invention belongs to the field of federated learning and product recommendation, and specifically relates to a training method for a product recommendation model based on horizontal federation and multi-dimensional representation. Background Technology

[0002] In today's digital age, data has become a core resource driving the development of various industries. In the e-commerce sector, massive amounts of user-product interaction data contain a wealth of information, such as user purchasing preferences, browsing habits, and product trends. Accurate product recommendations can not only enhance the user shopping experience and increase user stickiness, but also significantly improve merchants' sales and operational efficiency.

[0003] Traditional product recommendation model training often employs a centralized architecture, which involves collecting user-product interaction data from various data sources and aggregating it to a central server or data center for unified processing and model training. While this approach can build effective recommendation models to some extent, it faces numerous significant challenges in practical applications.

[0004] On the one hand, data privacy protection has become a prominent issue. With increasing public awareness of personal privacy and the introduction of relevant laws and regulations (such as the EU's GDPR), data holders (such as different business units of e-commerce platforms, third-party applications with user data, etc.) have become extremely cautious about sharing their user data. This is because data breaches could lead to the misuse of user information, triggering a crisis of user trust and causing significant reputational damage and legal risks for businesses.

[0005] On the other hand, data silos are prevalent. Due to business barriers, competition, and other factors, data from different enterprises or departments is often stored independently, making effective integration and circulation difficult. This makes it difficult for centralized model training to obtain comprehensive and rich data, limiting the model's accuracy and generalization ability. For example, the mobile and web applications of an e-commerce platform may be handled by different teams with different data storage and management methods, making seamless integration difficult. Summary of the Invention

[0006] To address the problems existing in the background technology, this invention proposes a product recommendation model training method based on horizontal federation and multi-dimensional representation, specifically including the following steps:

[0007] S1: The central server runs a key generation algorithm to generate its public and private keys, and sends the public key to the clients participating in this round of federated learning through a secure channel;

[0008] S2: The central server distributes the global product recommendation model to each client;

[0009] S3: Each client uses local user-product interaction data to train the global product recommendation model to obtain a local product recommendation model; and uploads the local product recommendation model and performance metrics to the central server after encrypting them with the central server's public key;

[0010] S4: The central server uses the private key to decrypt the local product recommendation model and performance metrics encrypted by the client, and aggregates the local product recommendation models uploaded by each client according to the performance metrics to obtain the global product recommendation model for the next round of iteration training;

[0011] S5: Repeat steps S2 to S5 until the global product recommendation model converges or reaches the preset number of iterations to obtain the trained product recommendation model.

[0012] The present invention has at least the following beneficial effects

[0013] Through encrypted transmission and a federated learning architecture, the client's original user-product interaction data does not need to leave its local machine, avoiding the risk of privacy leaks during data transmission and centralized storage. The central server can only access the encrypted local model and performance metrics, and cannot directly access sensitive data, ensuring data privacy. Training using the rich local data from each client captures a wider range of user behavior patterns and product features compared to models trained from a single data source, thereby improving the accuracy and generalization ability of the product recommendation model and providing users with more precise product recommendation services. Clients train their local models in parallel, while the central server handles model aggregation. This distributed architecture fully utilizes the computing resources of each client, improving training efficiency. The central server sends its public key through a secure channel; clients use the public key to encrypt data, and the central server uses its private key to decrypt it. This encryption mechanism ensures data security during transmission, preventing data theft or tampering. Attached Figure Description

[0014] Figure 1 This is a schematic diagram of the method flow of the present invention. Detailed Implementation

[0015] 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, and 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.

[0016] Please see Figure 1 This invention provides a method for training a product recommendation model based on horizontal federation and multi-dimensional representation, comprising:

[0017] S1: The central server runs a key generation algorithm to generate its public and private keys, and sends the public key to the clients participating in this round of federated learning through a secure channel;

[0018] Preferably, the central server runs a key generation algorithm to generate its public and private keys, including:

[0019] S11: Randomly generate two large prime numbers p and q;

[0020] S12: Calculate the common modulus n and Euler's totient function.

[0021] S13: Select a value less than And with Coprime integers as public key P k ; Calculate public key P k In the model The inverse d of the subscript d makes d is used as the private key S k .

[0022] In this embodiment, the client uses a public key to encrypt the local product recommendation model and performance indicators. Only the central server holding the private key can decrypt them, thereby ensuring the security of the data during transmission and preventing the data from being stolen or tampered with.

[0023] S2: The central server distributes the global product recommendation model to each client;

[0024] S3: Each client uses local user-product interaction data to train the global product recommendation model to obtain a local product recommendation model; and uploads the local product recommendation model and performance metrics to the central server after encrypting them with the central server's public key;

[0025] Preferably, the user-product interaction data is represented as follows: It is a continuous time graph. This represents the set of all nodes, including user node v. u and product node v p , This represents the interaction relationship between user nodes and product nodes at different points in time. Represents the feature set of all nodes. This represents the set of interaction tags between user nodes and product nodes. User v u With product v p There is interaction at time point t. User v u With product v p There was no interaction at time point t.

[0026] In this embodiment, the interaction between the user node and the product node at different points in time includes: purchasing, browsing, and liking. When the user node purchases a product node at time t1, there exists an edge from the user node to the product node, denoted as (v u v p , t1) represents the interaction relationship between the user node and the product node at t1; for user node v u Its characteristics may include age, gender, region, etc., and can be represented as Represents user node v u Features; for product node v p Features may include product category, price, and brand, and can be represented as... Represents product node v p Its characteristics.

[0027] Preferably, the product recommendation model adopts the DA-TGN model; the step of training the global product recommendation model using local user-product interaction data includes:

[0028] S31: Generate the initial state vector for each user node and product node according to the feature sets of user nodes and product nodes in the user-product interaction data;

[0029] In this embodiment, when generating the initial state vector, these features may be converted into vector form according to a preset mapping rule, and an appropriate encoding method may be adopted: numerical features are standardized or normalized, label features are encoded using one-hot encoding, and text features are embedded using word embedding. Then, the label features are converted into vectors through an embedding layer and concatenated with other numerical features to form the initial state vectors of users and products.

[0030] S32: Calculate the messages received by the user node and the product node when an interaction event occurs, based on the interaction events between the user node and the product node;

[0031] Preferably, the messages received by the user node and the product node when an interaction event occurs include:

[0032] m i (t)=s j (t - )||s i (t - )||Δt||e ij (t))

[0033] m j (t)=s i (t -)||s j (t - )||Δt||e ij (t))

[0034] Where, m i (t) represents the message received by user node i at time t; m j (t) represents the message received by product node j at time t; s j (t - ) represents the state vector of product node j before time t; s i (t - ) represents the state vector of the user node before time t; Δt represents the time interval from time t to the last interaction event between user node i and product node j; e ij (t) represents the relevant information of the edge between user node i and product node j at time t; t represents the time when this interaction event occurred.

[0035] In this embodiment, various information from user nodes and product nodes during interaction events is integrated into a message vector. These messages contain the state vectors of the nodes, time intervals, and edge information, providing a foundation for subsequent message aggregation and state updates. By recording the time intervals of interactions between user nodes and product nodes, the model can better understand how user behavior patterns change over time. The edge information incorporates the specific details of user-product interactions, such as different interaction types (purchase, browsing, favorites, etc.) and detailed interaction information (amount, duration, etc.). This integration of information in the messages helps the model update and learn differently based on different interaction details, improving the model's ability to distinguish and understand different interaction behaviors, and providing more detailed information for personalized recommendations.

[0036] S33: Calculate the aggregated message for each user node or product node based on all messages received by each user node or product node;

[0037] Preferably, the aggregated message of the user node or product node includes:

[0038]

[0039] in, This represents the aggregated message of user node i at time t; This represents the aggregated message of product node j at time t; m i (t b ) indicates that user node i is in t b Messages received at any time; m j (t b ) indicates that product node j is in tb The message received at time t; Δt represents the time interval from time t to the last interaction between user node i and product node j; t1 represents the time when user node i and product node j first interacted; agg represents the averaging function.

[0040] In this embodiment, message aggregation integrates messages received by user nodes or product nodes at different times, avoiding the limitations of considering messages from only a single moment. By using an averaging function, the information received by nodes at different times is smoothed, reducing the noise impact of individual messages and making node information updates more stable and comprehensive. Considering all messages from the first interaction to the current moment helps the model process the time-series information of users and products. This aggregation method helps the model capture the changing trends of user or product interaction information at different times, rather than focusing only on interactions at a single moment, enabling the model to better understand the dynamic behavioral patterns of user or product nodes over time. As time progresses and new interactions occur, the aggregated messages of nodes are continuously updated, allowing the model to continuously learn new user and product behaviors and characteristics. This dynamic update mechanism enables the model to adjust its internal state based on the latest user and product behaviors, improving its adaptability to user preferences and product characteristics, providing more accurate and dynamic information support for the recommendation system, and thus achieving better recommendation results.

[0041] S34: Update the state vectors of the user node and the product node respectively based on the aggregated messages of the user node and the product node;

[0042] Preferably, updating the state vectors of user nodes and product nodes includes:

[0043]

[0044] Among them, s i (t) represents the updated state vector of user node i at time t; s j (t) represents the updated state vector of product node j at time t; s j (t - ) represents the state vector of product node j before time t; s i (t - ) represents the state vector of user node i before time t; GRU represents gated cyclic unit.

[0045] In this embodiment, when a user interacts with a product at different times, the GRU can adjust the node state based on new aggregated messages to reflect the latest information about the user or product, rather than simply replacing old information. This allows the model to better learn the long-term dynamic behavior of users and products. By continuously updating the state vector, the DA-TGN model can better handle the time-series interaction behavior of users and products. For user and product interaction data with complex time-series characteristics, this update mechanism allows the model to learn information such as the trend of user behavior changes and the evolution of preferences, thereby improving the model's ability to predict user and product interactions at different times, and ultimately improving the accuracy and adaptability of product recommendations.

[0046] S35: Based on the updated state vector of the user node and the state vectors of the user node's neighboring nodes, the final representation vector of the user node is obtained through an attention mechanism;

[0047] Preferably, the final representation vector of the computed user node includes:

[0048]

[0049] Among them, z i (t) = emb(i, t) represents the final representation vector of user node i at time t. Represents the set of k-hop neighbors of user node i within the time interval [0, t]; || represents the concatenation operation; e ij (t) represents the relevant information of the edge between user node i and product node j at time t; attn(·) represents the attention weight.

[0050] In this embodiment, by combining the updated state vector of the user node with the state vectors and edge information of its neighbors, and utilizing an attention mechanism, the final representation vector integrates information from both the user node itself and its neighbors. This approach allows the model to more comprehensively consider the environmental information of the user node, rather than relying solely on the user node's own information. For example, a user node's neighbors might be products that the user has previously purchased or browsed; incorporating information from these product nodes can more accurately reflect the user's preferences and behavioral patterns. As time progresses and user behavior changes, the state vectors and edge information of the neighbors change, and the attention weights are adjusted accordingly, resulting in a dynamically updated final representation vector. This helps the model capture dynamic changes in user behavior and preferences, better adapting to different preferences and behavioral patterns at different points in time, thereby improving the accuracy and adaptability of the recommendation system. For instance, as a user purchases or browses different products, their neighbor node information is updated, and the final representation vector is also updated, making the recommendations more aligned with the user's latest behavior.

[0051] S36: Predict the probability score of user node and product node interaction using the inner product of the final representation vectors of user node and product node:

[0052] Preferably, the probability score of interaction between the user node and the product node includes:

[0053]

[0054] Among them, z u (t) represents the final representation vector of user node u, z p (t) represents the final representation vector of the product node p. represents the probability score of user node u interacting with product node p, where e represents the natural base.

[0055] In this embodiment, the information is transformed into a concise probability through the inner product and the sigmoid function. This comprehensively considers various features and relationships between users and items, allowing the recommendation system to recommend the most likely items for user interaction based on this probability. The sigmoid function converts the inner product result into a probability, making the result between 0 and 1, with a clear probabilistic interpretation. Simultaneously, the sigmoid function introduces non-linearity, enabling the model to handle more complex relationships and avoiding the linear limitations that might result from directly using the inner product result. This improves the model's ability to distinguish between different combinations of users and items, thereby enhancing the accuracy and flexibility of the recommendation system. For example, even if the inner product scores of two user nodes and item nodes are small, the non-linear transformation by the sigmoid function may result in a more significant difference in the final probability scores, which is more conducive to recommendation ranking.

[0056] S37: Construct a cross-entropy loss function based on the predicted probability scores of user nodes and product nodes interacting, and the interaction labels between user nodes and product nodes:

[0057] Preferably, the cross-entropy loss function includes:

[0058]

[0059] Among them, y u，p This represents the actual interaction label between user node u and product node p. This represents the smoothed interactive label, where ∈ is a small smoothing parameter with a value between [0, 1]. This represents the predicted probability score of user nodes and product nodes interacting.

[0060] In this embodiment, a smoothing parameter ∈ is introduced to smooth the actual interaction labels, which can prevent the model from overconfident in extreme cases. When the sample size is small or the sample size is imbalanced, this helps to prevent the model from overfitting to some samples and improves the model's generalization ability.

[0061] S38: Based on the constructed loss function, the parameters of the global product recommendation model are tuned using the Adam optimizer to obtain the trained local product recommendation model.

[0062] S4: The central server uses the private key to decrypt the local product recommendation model and performance metrics encrypted by the client, and aggregates the local product recommendation models uploaded by each client according to the performance metrics to obtain the global product recommendation model for the next round of iteration training;

[0063] Preferably, the performance metrics include the number of training set samples for the client, the average error of the client's local product recommendation model on the validation set, and the convergence speed of the client's local product recommendation model on the training set; the aggregation of local product recommendation models uploaded by each client based on the performance metrics includes:

[0064]

[0065] Where G represents the global product recommendation model trained in the next iteration, and D... i g represents the number of training set samples for client i. i This represents the local product recommendation model uploaded by the i-th client. ε represents the weight of the i-th client. i η represents the average error of the local product recommendation model uploaded by the i-th client on the validation set. i Let μ represent the convergence speed of the local product recommendation model uploaded by the i-th client on the training set. μ and θ are constants, 0 < μ, θ < 1, and α and β are hyperparameters, α > 1, 0 < β < 1.

[0066] In this embodiment, the performance metrics include the number of training set samples for each client. In federated learning, the amount of data from different clients can vary significantly. By including these clients in the weight calculation, clients with larger amounts of data will receive relatively higher weights in the global model aggregation. For example, if a client has abundant training data, it means it contains more diverse user-product interaction information, and its local model may contribute more to the global model. This helps the global model better capture the behavioral patterns and product features of different user groups, thereby improving the model's generalization ability and recommendation accuracy for various users. The average error of the local product recommendation model on the validation set is an important indicator of model accuracy. In the weight calculation, it is in the denominator and appears exponentially, which makes clients with smaller average errors have relatively higher weights. For example, if a client's model shows a low error on the validation set, it indicates that the model has a strong fitting and predictive ability to the data and is closer to the real user-product interaction relationship. By giving these clients higher weights, the global model can absorb more accurate model information during aggregation, which helps improve the prediction accuracy of the global model and reduce recommendation errors. The convergence speed of the local product recommendation model on the training set reflects the efficiency and stability of model training. Models with faster convergence speeds are more likely to utilize data more effectively during training and reach better performance more quickly. While convergence speed has a relatively small impact on weights, it still plays a role in weight calculation. This encourages clients to optimize their models during training to improve efficiency, while also ensuring that the global model does not overly rely on convergence speed and ignore other important factors during aggregation, thus ensuring a balance between accuracy and training efficiency. By comprehensively considering three performance metrics—the number of training set samples, the average error of the validation set, and the convergence speed of the training set—to calculate weights, and then aggregating the local models of each client to obtain the global model, the advantages of different clients can be fully integrated. For example, one client may have a small sample size but high model accuracy and fast convergence speed; another client may have a large sample size but slightly lower accuracy. This weight calculation method can reasonably balance the contributions of each client, allowing the global model to utilize rich data information while ensuring a certain level of accuracy and training efficiency, thereby continuously optimizing the global model and improving the overall performance of the product recommendation system.

[0067] S5: Repeat steps S2 to S5 until the global product recommendation model converges or reaches the preset number of iterations to obtain the trained product recommendation model.

[0068] In summary, this invention, while ensuring data privacy, promotes effective collaboration between clients and a central server through its performance metric-based aggregation method. Clients upload encrypted models and performance metrics, which the central server decrypts and aggregates using a private key. The introduction of performance metrics makes the collaboration process more scientific and rational. Clients can contribute to the global model based on their own data characteristics and model performance, while the central server, by aggregating these models, gradually optimizes the global model without exposing the original data, achieving the dual goals of privacy protection and model optimization.

[0069] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit it. Although the present invention has been described in detail with reference to preferred embodiments, those skilled in the art should understand that modifications or equivalent substitutions can be made to the technical solutions of the present invention without departing from the spirit and scope of the present invention, and all such modifications or substitutions should be covered within the scope of the claims of the present invention.

Claims

1. A training method for a product recommendation model based on horizontal federation and multi-dimensional representation, characterized in that, include: S1: The central server runs a key generation algorithm to generate its public and private keys, and sends the public key to the clients participating in this round of federated learning through a secure channel; S2: The central server distributes the global product recommendation model to each client; S3: Each client uses local user-product interaction data to train the global product recommendation model to obtain a local product recommendation model; and uploads the local product recommendation model and performance metrics to the central server after encrypting them with the central server's public key; The step of training the global product recommendation model using local user-product interaction data includes: S31: Generate the initial state vector for each user node and product node according to the feature sets of user nodes and product nodes in the user-product interaction data; S32: Calculate the messages received by the user node and the product node when an interaction event occurs, based on the interaction events between the user node and the product node; S33: Calculate the aggregated message for each user node or product node based on all messages received by each user node or product node; S34: Update the state vectors of the user node and the product node respectively based on the aggregated messages of the user node and the product node; S35: Based on the updated state vector of the user node and the state vectors of the user node's neighboring nodes, the final representation vector of the user node is obtained through an attention mechanism; S26: Predict the probability score of user node and product node interaction using the inner product of the final representation vectors of user node and product node: S37: Construct a cross-entropy loss function based on the predicted probability scores of user nodes and product nodes interacting, and the interaction labels between user nodes and product nodes: S38: Based on the constructed loss function, the parameters of the global product recommendation model are tuned using the Adam optimizer to obtain the trained local product recommendation model; S4: The central server uses the private key to decrypt the local product recommendation model and performance metrics encrypted by the client, and aggregates the local product recommendation models uploaded by each client according to the performance metrics to obtain the global product recommendation model for the next round of iteration training; S5: Repeat steps S2 to S5 until the global product recommendation model converges or reaches the preset number of iterations to obtain the trained product recommendation model.

2. The method for training a product recommendation model based on horizontal federation and multi-dimensional representation as described in claim 1, characterized in that, The user-product interaction data is represented as follows: , It is a continuous time graph. This indicates that the set of all nodes includes user nodes. and product nodes , This represents the interaction relationship between user nodes and product nodes at different points in time. Represents the feature set of all nodes. This represents the set of interaction tags between user nodes and product nodes. , Indicates user With goods At the point of time It is interactive. Indicates user With goods At the point of time There is no interaction.

3. The method for training a product recommendation model based on horizontal federation and multi-dimensional representation as described in claim 1, characterized in that, The messages received by the user node and the product node when an interaction event occurs include: in, Represents user node exist Messages received in real time; Represents product nodes exist Messages received in real time; Represents product nodes exist The state vector before time step; Indicates that the user node is The state vector before time step; express Time until the last user node and product nodes The time interval between interactive events; Represents user node and product nodes In time Information related to the edges; This indicates the time when the interaction event occurred.

4. The product recommendation model training method based on horizontal federation and multi-dimensional representation according to claim 1, characterized in that, The aggregated messages from the user node or product node include: in, Represents user node exist Moment-based aggregated messages; Represents product nodes exist Moment-based aggregated messages; Represents user node exist Messages received in real time; Represents product nodes exist Messages received in real time; express Time until the last user node and product nodes The time interval between interactive events Represents user node and product nodes The time when the first interaction event occurred; This represents the function for taking the average value.

5. The method for training a product recommendation model based on horizontal federation and multi-dimensional representation as described in claim 1, characterized in that, The update of the state vectors of user nodes and product nodes includes: in, Represents user node exist The updated state vector at each time step; Represents product nodes exist The updated state vector at each time step; Represents product nodes exist The state vector before time step; Represents user node exist The state vector before the time step; GRU represents a gated recurrent unit.

6. The method for training a product recommendation model based on horizontal federation and multi-dimensional representation as described in claim 1, characterized in that, The final representation vector of the computed user node includes: in, Represents user node In time The final representation vector, Indicates the time interval Internal user nodes of The set of skip neighbor nodes; Indicates a splicing operation; Represents user node and product nodes In time Information related to the edges; This represents the attention weight.

7. The method for training a product recommendation model based on horizontal federation and multi-dimensional representation as described in claim 1, characterized in that, The probability score of interaction between user nodes and product nodes includes: in, Represents user node The final representation vector, Represents product nodes The final representation vector, Represents user node With product nodes The probability score of an interaction occurring. Represents the natural base.

8. The method for training a product recommendation model based on horizontal federation and multi-dimensional representation as described in claim 1, characterized in that, The cross-entropy loss function includes: in, Indicates the use of user nodes With product nodes The actual interactive labels, This indicates the smoothed-out interactive label. It is a small smoothing parameter, taking values ​​between [0,1]. This represents the predicted probability score of user nodes and product nodes interacting.

9. The method for training a product recommendation model based on horizontal federation and multi-dimensional representation according to claim 1, characterized in that, The performance metrics include the number of training set samples on the client, the average error of the client's local product recommendation model on the validation set, and the convergence speed of the client's local product recommendation model on the training set. The local product recommendation model that aggregates uploads from various clients based on performance metrics includes: in, This represents the global product recommendation model to be trained in the next iteration. Indicates client The number of training set samples, Indicates the first Local product recommendation models uploaded by each client. Indicates the first The weight of each client, Indicates the first The average error of the local product recommendation model uploaded by each client on the validation set. Indicates the first The convergence speed of the local product recommendation model uploaded by each client on the training set. and It is a constant, 0 < <1, and It's a hyperparameter. >1, 0< <1.

Images