Data processing method based on deep learning and related device

Abstract

This disclosure provides a data processing method and related equipment based on deep learning, relating to the field of intelligent recommendation technology. It includes: acquiring graph structure data corresponding to a set of items, and determining a target item node and a set of neighboring item nodes based on multiple item nodes in the graph structure; identifying a subset of feature data from the feature data of the item set that is inconsistent with the neighboring feature data of the target item node; matching digital fingerprints to the feature data in the feature data subset and determining the similarity between the feature data and the digital fingerprints; filtering based on similarity, storing feature data that meets preset conditions in a uniform pool corresponding to the target item node, and aggregating the feature data in the uniform pool to generate updated target feature data for the target item node; and determining user preferences based on the updated target feature data of at least one target item node. This disclosure can reduce computational complexity and improve computational efficiency.

Description

Technical Field

[0001] This disclosure relates to the field of intelligent recommendation technology, and in particular to a data processing method and related equipment based on deep learning. Background Technology

[0002] With the development of Graph Neural Networks (GNNs), some studies have modeled the sequence of items in a conversation as a graph structure to capture complex transition patterns between items using GNNs. Graphs, as a flexible data representation, can well adapt to the complex relationship modeling needs of recommender systems. However, traditional methods based on GNNs mainly rely on sequence order information to extract conversation features, making it difficult to effectively model multi-hop or nonlinear item transition relationships.

[0003] Against this backdrop, a Multi-relational Graph Neural Network for Session-based Target Behavior Prediction (MGNN-SPred) model was proposed to improve modeling capabilities. This model involves complex multi-step computations to aggregate and extract features, including secondary aggregation and multi-stage data analysis, resulting in high overall computational complexity. This not only increases the demand for computing resources but may also lead to timeliness issues in practical applications.

[0004] It should be noted that the information disclosed in the background section above is only used to enhance the understanding of the background of this disclosure, and therefore may include information that does not constitute prior art known to those skilled in the art. Summary of the Invention

[0005] This disclosure provides a data processing method and related device based on deep learning, which aims to reduce the computational complexity of graph neural networks in data processing and improve computational efficiency.

[0006] Other features and advantages of this disclosure will become apparent from the following detailed description, or may be learned in part from practice of this disclosure.

[0007] According to one aspect of this disclosure, a data processing method based on deep learning is provided. The method includes: acquiring graph structure data corresponding to a set of items, and determining a target item node and a set of neighboring item nodes corresponding to the target item node based on multiple item nodes in the graph structure, wherein each item node in the graph structure data has corresponding feature data; identifying a subset of feature data that is inconsistent with the neighboring feature data of the target item node from the feature data of the set of items; matching digital fingerprints to the feature data in the subset of feature data, and determining the similarity between the feature data and the digital fingerprint, wherein the digital fingerprint is used to characterize neighboring feature data substantially associated with the target item node; filtering based on the similarity, storing feature data that meets preset conditions into a uniform pool corresponding to the target item node, and aggregating the feature data in the uniform pool to generate updated target feature data for the target item node; and determining user preferences based on the updated target feature data of at least one target item node.

[0008] In some embodiments, matching feature data in the subset of feature data with digital fingerprints and determining the similarity between the feature data and the digital fingerprints includes: accessing a distributed feature table storing multiple pre-generated digital fingerprints; calculating the Euclidean distance between the feature data and each digital fingerprint in the distributed feature table; matching the feature data to the digital fingerprint with the smallest Euclidean distance, and using the smallest Euclidean distance to characterize the similarity between the feature data and the digital fingerprint.

[0009] In some embodiments, the graph structure data is a multi-relationship item graph, whose edges include edges representing purchase conversion relationships between items and edges representing click conversion relationships between items; the neighbor item node set includes the set of incoming and outgoing neighbors when the target item node is a purchased item, and the set of incoming and outgoing neighbors when it is a clicked item.

[0010] In some embodiments, the digital fingerprint is pre-generated based on historical behavioral feature data stored in a distributed feature table. The historical behavioral feature data represents feature data whose form is different from the original feature data but is essentially the same as the original feature data. Each digital fingerprint corresponds to an abnormal feature pattern defined by the historical behavioral feature data, which is used to characterize that the historical behavioral feature data actually belongs to the neighbor feature set corresponding to the target item node in terms of behavioral relationship.

[0011] In some embodiments, the uniform pool corresponding to the target item node is constructed as follows: other item nodes in the graph structure data besides the target item node are taken as a set of candidate item nodes; the Euclidean distance between the feature data of the target item and the feature data of each item node in the candidate item set is calculated; based on the Euclidean distance, a set of feature data of item nodes is selected from the candidate item set and stored in the uniform pool of the target item node, wherein each set of feature data selected by the uniform pool is the feature data in the candidate item set that has the closest Euclidean distance to the target item node and does not overlap with each other.

[0012] In some embodiments, the method further includes updating the uniform pool corresponding to the target item node; updating the uniform pool corresponding to the target item node includes: calculating the Euclidean distance between the newly generated item node feature data and the target item node feature data; comparing the newly generated feature data with the Euclidean distance from the existing feature data in the uniform pool to the target item node; if the newly generated feature data has a smaller Euclidean distance from the target item node, then replacing the original feature data in the uniform pool with it.

[0013] In some embodiments, determining user preferences based on updated target feature data of at least one target item node includes: extracting a click preference vector and a purchase preference vector based on updated target feature data of at least one target item node; and fusing the click preference vector and the purchase preference vector using a gating mechanism to obtain the user preferences.

[0014] In some embodiments, the user preferences include a set of recommendation data. After determining the user preferences, the method further includes: inputting the set of recommendation data corresponding to the user preferences into a metric learning model to calculate a loss value; filtering the recommendation data in the set of recommendation data according to the loss value; and updating the graph neural network profile features using the filtered recommendation data.

[0015] In some embodiments, the metric learning model employs a neuron-selective transfer method, and the loss function of the metric learning model is determined based on cross-entropy loss and maximum average difference loss.

[0016] In some embodiments, the updated graph neural network profile features are stored in a wide data table.

[0017] According to another aspect of this disclosure, a data processing apparatus based on deep learning is also provided. The apparatus includes: an acquisition module, configured to acquire graph structure data corresponding to a set of items, and determine a target item node and a set of neighboring item nodes corresponding to the target item node based on multiple item nodes in the graph structure, wherein each item node in the graph structure data has corresponding feature data; an identification module, configured to identify a subset of feature data that is inconsistent with the neighboring feature data of the target item node from the feature data of the set of items; a matching module, configured to match digital fingerprints to the feature data in the subset of feature data, and determine the similarity between the feature data and the digital fingerprint, wherein the digital fingerprint is used to characterize neighboring feature data substantially associated with the target item node; a filtering module, configured to filter based on the similarity, store feature data that meets preset conditions into a uniform pool corresponding to the target item node, and aggregate the feature data in the uniform pool to generate updated target feature data of the target item node; and a user preference determination module, configured to determine user preferences based on the updated target feature data of at least one target item node.

[0018] According to another aspect of this disclosure, an electronic device is also provided, comprising: a processor; and a memory for storing executable instructions of the processor; wherein the processor is configured to perform the deep learning-based data processing method described in any one of the preceding claims by executing the executable instructions.

[0019] According to another aspect of this disclosure, a computer-readable storage medium is also provided, on which a computer program is stored, which, when executed by a processor, implements the deep learning-based data processing method described in any one of the preceding claims.

[0020] According to another aspect of this disclosure, a computer program product is also provided, comprising: a computer program or instructions that, when executed by a processor, implement the deep learning-based data processing method of any one of the above.

[0021] An embodiment of this disclosure provides a data processing method based on deep learning, comprising: acquiring graph structure data corresponding to a set of items, and determining a target item node and a set of neighboring item nodes corresponding to the target item node based on multiple item nodes in the graph structure, wherein each item node in the graph structure data has corresponding feature data; identifying a subset of feature data that is inconsistent with the neighboring feature data of the target item node from the feature data of the set of items; matching digital fingerprints to the feature data in the feature data subset and determining the similarity between the feature data and the digital fingerprint, wherein the digital fingerprint is used to characterize the neighboring feature data that is substantially associated with the target item node; filtering based on similarity, storing feature data that meets preset conditions into a uniform pool corresponding to the target item node, and aggregating the feature data in the uniform pool to generate updated target feature data for the target item node; and determining user preferences based on the updated target feature data of at least one target item node. This disclosure introduces a uniform pooling strategy and a digital fingerprint matching mechanism. By matching pre-generated digital fingerprints with data that do not conform to the characteristics of the current target item and its neighboring items, and storing them in a uniform pool of the target item, subsequent feature aggregation calculations can be minimized within the uniform pool. This reduces the range of unrelated data aggregation, accelerates the calculation speed, significantly reduces computational resource consumption, lowers the computational complexity of graph neural networks in data processing, and improves computational efficiency. In turn, it solves the computational complexity bottleneck faced by graph neural networks in recommendation systems and improves the timeliness of recommendation systems.

[0022] It should be understood that the above general description and the following detailed description are exemplary and explanatory only, and are not intended to limit this disclosure. Attached Figure Description

[0023] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with this disclosure and, together with the description, serve to explain the principles of this disclosure. It is obvious that the drawings described below are merely some embodiments of this disclosure, and those skilled in the art can obtain other drawings based on these drawings without any inventive effort.

[0024] Figure 1 A schematic diagram of the model structure of an MGNN-SPred algorithm in an embodiment of this disclosure is shown; Figure 2 This diagram illustrates an exemplary application system architecture of a deep learning-based data processing method according to an embodiment of the present disclosure. Figure 3 A flowchart illustrating a data processing method based on deep learning in an embodiment of this disclosure is shown. Figure 4This diagram illustrates a method for updating graph neural network profile features according to an embodiment of the present disclosure. Figure 5 A schematic diagram of a metric learning model based on a knowledge distillation network is shown in an embodiment of this disclosure; Figure 6 This diagram illustrates a method for generating a profile analysis using a wide data table, as described in an embodiment of this disclosure. Figure 7 This diagram illustrates a structural block diagram of a deep learning-based data processing apparatus according to an embodiment of the present disclosure. Figure 8 A structural block diagram of an electronic device according to an embodiment of the present disclosure is shown. Detailed Implementation

[0025] Exemplary embodiments will now be described more fully with reference to the accompanying drawings. However, these exemplary embodiments can be implemented in many forms and should not be construed as limited to the examples set forth herein; rather, they are provided so that this disclosure will be more comprehensive and complete, and will fully convey the concept of the exemplary embodiments to those skilled in the art. The described features, structures, or characteristics may be combined in any suitable manner in one or more embodiments.

[0026] Furthermore, the accompanying drawings are merely illustrative of this disclosure and are not necessarily drawn to scale. The same reference numerals in the drawings denote the same or similar parts, and therefore repeated descriptions of them will be omitted. Some block diagrams shown in the drawings are functional entities and do not necessarily correspond to physically or logically independent entities. These functional entities may be implemented in software, in one or more hardware modules or integrated circuits, or in different network and / or processor devices and / or microcontroller devices.

[0027] See Figure 1As shown, a multi-relational graph neural network model for session-based target behavior prediction (MGNN-SPred) is constructed. By acquiring user sessions, the click and purchase sequences within the sessions are used as inputs to the GNN. MGNN-SPred then constructs a multi-relational item graph (MRIG) and performs message passing on this graph to obtain richer node representations. Click preferences and purchase preferences are then output and input to a gating module for fusion to obtain the final user preference representation. Based on this user preference representation, a recommendation sequence is derived, which includes the item j to be predicted. Specifically, in MGNN-SPred, a multi-relational item graph containing item transition information from all sessions is first constructed. Each node in the graph corresponds to an item in the item set. The graph contains two types of edges: purchase-purchase edges and click-click edges. A purchase-purchase edge represents a user purchasing one item and then purchasing another. A click-click edge represents a user clicking one item and then clicking another.

[0028] After inputting the click sequence and purchase sequence into the GNN, MGNN-SPred uses average pooling to aggregate the features of each set of neighbors during the information transmission process of the GNN. This includes the inbound / outbound neighbors when the node is the purchased item and the inbound / outbound neighbors when the node is the clicked item.

[0029] However, computational complexity limits the application scope of graph neural networks. Specifically, in existing technologies, the MGNN-SPred algorithm aggregates and extracts features from user purchase data through average pooling operations. This process involves secondary aggregation and data analysis, resulting in high computational complexity, which in turn leads to problems such as limited computing resources and poor timeliness.

[0030] In view of this, embodiments of this disclosure introduce a uniform pooling strategy and a digital fingerprint matching mechanism. By matching pre-generated digital fingerprints with data that do not conform to the characteristics of the current target item and its neighboring items, and storing these fingerprints in a uniform pool of a target item node, subsequent feature aggregation calculations can be performed within the uniform pool with minimal effort. This narrows the range of unrelated data aggregation, accelerates computation, and significantly reduces computational resource consumption, thereby effectively solving the computational complexity bottleneck faced by graph neural networks in recommendation systems and improving the timeliness of user preference profile construction and recommendation.

[0031] To facilitate understanding, before introducing the embodiments of this disclosure, the following explanations are provided for several terms involved in the embodiments of this disclosure: The specific implementation methods of the embodiments of this disclosure will now be described in detail with reference to the accompanying drawings.

[0032] Figure 2 A schematic diagram of an exemplary application system architecture to which the deep learning-based data processing methods of the embodiments of this disclosure can be applied is shown. Figure 2 As shown, the system architecture may include terminal device 101, network 102 and server 103.

[0033] Network 102 is a medium used to provide a communication link between terminal device 101 and server 103, and can be a wired network or a wireless network.

[0034] Optionally, the aforementioned wireless or wired networks use standard communication technologies and / or protocols. The network is typically the Internet, but can also be any network, including but not limited to Local Area Networks (LANs), Metropolitan Area Networks (MANs), Wide Area Networks (WANs), mobile, wired or wireless networks, private networks, or any combination of virtual private networks. In some embodiments, technologies and / or formats, including Hyper Text Markup Language (HTML), Extensible Markup Language (XML), etc., are used to represent data exchanged over the network. Furthermore, conventional encryption technologies such as Secure Socket Layer (SSL), Transport Layer Security (TLS), Virtual Private Networks (VPNs), and Internet Protocol Security (IPSec) can be used to encrypt all or some links. In other embodiments, custom and / or dedicated data communication technologies can be used to replace or supplement the aforementioned data communication technologies.

[0035] Terminal device 101 can be various electronic devices, including but not limited to smartphones, tablets, laptops, desktop computers, smart speakers, smartwatches, wearable devices, augmented reality devices, virtual reality devices, etc.

[0036] Optionally, the client of the application installed on different terminal devices 101 may be the same, or the client of the same type of application based on different operating systems. Depending on the terminal platform, the specific form of the application client may also be different; for example, the application client may be a mobile client, a PC client, etc.

[0037] Server 103 can be a server that provides various services, such as a backend management server that supports the device operated by the user using terminal device 101. The backend management server can analyze and process received requests and other data, and feed the processing results back to the terminal device.

[0038] Optionally, the server can be a standalone physical server, a server cluster or distributed system consisting of multiple physical servers, or a cloud server that provides basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communication, middleware services, domain name services, security services, CDN (Content Delivery Network), and big data and artificial intelligence platforms.

[0039] Those skilled in the art will know that Figure 2 The number of terminal devices, networks, and servers shown is merely illustrative; any number of terminal devices, networks, and servers can be included depending on actual needs. This disclosure does not limit the scope of the embodiments.

[0040] Under the above system architecture, this disclosure provides a data processing method based on deep learning, which can be executed by any electronic device with computing capabilities.

[0041] In some embodiments, the deep learning-based data processing method provided in this disclosure can be executed by a terminal device of the system architecture described above; in other embodiments, the deep learning-based data processing method provided in this disclosure can be executed by a server in the system architecture described above; in still other embodiments, the deep learning-based data processing method provided in this disclosure can be implemented by the terminal device and the server in the system architecture described above through interaction.

[0042] Figure 3 A flowchart illustrating a deep learning-based data processing method according to an embodiment of this disclosure is shown. Figure 3 As shown in the embodiments of this disclosure, the data processing method based on deep learning includes the following steps: S302, obtain the graph structure data corresponding to the item set, and based on multiple item nodes in the graph structure, determine the target item node and the set of neighboring item nodes corresponding to the target item node, wherein each item node in the graph structure data has corresponding feature data.

[0043] In this embodiment, the graph structure data is a multi-relationship item graph, whose edges include edges representing purchase conversion relationships between items and edges representing click conversion relationships between items; the neighbor item node set includes the set of incoming and outgoing neighbors when the target item node is a purchased item, and the set of incoming and outgoing neighbors when it is a clicked item.

[0044] Specifically, the target item node refers to any item node in a multi-relationship item graph, and the set of neighboring item nodes corresponding to the target item node refers to the set of all item nodes in the graph structure that are directly connected to the target item node through edges of different types. The target item node has the characteristic data of the target item, and the neighboring item nodes have the characteristic data of their neighboring items.

[0045] The set of neighboring item nodes specifically includes: the set of neighboring items connected to the target item node through the purchase conversion edge when the target item node is the purchased item. This includes incoming neighbors, which are other items purchased by the user who purchased the target item; and outgoing neighbors, which are other items that the user may purchase after purchasing the target item.

[0046] Click-related neighbor set: When the target item node is the clicked item, the set of neighboring item nodes connected to it through the click transformation edge, including incoming edge neighbors, that is, other items clicked by the user who clicked the item, and outgoing edge neighbors, that is, other items that the user may click after clicking the item.

[0047] For example, in a multi-relationship item graph, for each target item node Each node has four types of neighbor item node sets: the set of incoming edge nodes when the node is the purchased item. and the set of outgoing edge nodes And the set of incoming edge nodes when the item is the clicked item. and the set of outgoing edge nodes Specifically, it is expressed as follows:

[0048] in, Indicates the target item node, This represents the neighboring item nodes corresponding to the target item node. "purchase" indicates that the type of this edge is a purchase action, and "click" indicates that the type of this edge is a click action.

[0049] The above set of neighboring item nodes is used for subsequent graph neural network calculations. By aggregating the feature information of neighboring item nodes, the representation learning of the target item node is enhanced, thereby improving the performance of the recommendation system.

[0050] S304, Identify a subset of feature data from the feature data of the set of item nodes that is inconsistent with the feature data of the neighbors of the target item node.

[0051] In this embodiment, the feature data of each item node in the item node set is traversed. For each subset of feature data, it is compared one by one with the neighbor feature data of the target item node. During the comparison, attribute values ​​or the entire feature subset that differ from the neighbor feature data of the target item node are recorded. If the value of an attribute is different, the attribute and its corresponding value are marked as the difference; if the entire feature subset clearly does not conform to the feature pattern of the target node's neighbors, this subset is marked as an inconsistent feature data subset. All identified inconsistent feature data subsets are then organized, and duplicates are removed.

[0052] In some embodiments, these inconsistent feature data subsets can be output in a predetermined order (e.g., the size of the feature subset, or based on the order in which the first differential feature appears).

[0053] S306, Match digital fingerprints to feature data in the feature data subset and determine the similarity between the feature data and the digital fingerprint, wherein the digital fingerprint is used to characterize neighbor feature data that is substantially associated with the target item node.

[0054] In this embodiment, matching digital fingerprints to feature data in a subset of feature data and calculating their similarity may include: accessing a distributed feature table storing multiple pre-generated digital fingerprints; calculating the Euclidean distance between the feature data and each digital fingerprint in the distributed feature table; matching the feature data to the digital fingerprint with the smallest Euclidean distance, and using the smallest Euclidean distance to represent the similarity.

[0055] The digital fingerprint is pre-generated based on historical behavioral feature data stored in a distributed feature table. Each digital fingerprint corresponds to an abnormal feature pattern defined by the historical behavioral feature data, used to characterize feature data that substantially belongs to a specific set of neighboring features in terms of behavioral relationships. It should be noted that the distributed feature table specifically stores the data features of all user purchase behaviors.

[0056] S308: Based on similarity, filter the feature data that meets the preset conditions and store it in the uniform pool corresponding to the target item node. Then, aggregate the feature data in the uniform pool to generate the updated target feature data of the target item node.

[0057] In this embodiment, based on the calculated similarity, feature data that meets the preset similarity conditions, such as a distance less than a certain threshold, is stored in a uniform pool pre-built for the target item node. Finally, the feature data stored in the uniform pool is aggregated to generate the updated target feature data of the target item node.

[0058] Specifically, the aggregated feature representation of the target item node is as follows:

[0059] in, These represent the characteristics of four different neighbors. Layer aggregation features Indicates the first In the layer, the target item node Through its positive neighbors (i.e., pointing to) The node receives the information and updates the feature representation. Represents a node The set of positive neighbors, Indicates the first Neighboring item nodes in the layer Feature representation, It represents the number of positive neighbors. Indicates the first In the layer, nodes Through its reverse neighbor (i.e. from) The information received by the node being pointed to and the updated feature representation. Represents a node The set of reverse neighbors. Indicates the first In the layer, nodes Through its positive addition neighbor (i.e., pointing to) The nodes (but using addition instead of averaging) receive information and update the feature representation. Represents a node The positive addition neighbor set. Indicates the first In the layer, nodes The feature representation is updated by using information received from its reverse addition neighbors. Represents a node The reverse addition neighbor set.

[0060] These four sets of aggregated features are then aggregated a second time by addition, and then added to the (k-1)th layer features of node v to obtain the features of node v after the k-th iteration through the GNN:

[0061] Finally, MGNN-SPred uses the node features obtained from the last iteration as the updated target feature data representation for the target item:

[0062] in, This indicates that node features are obtained by using GNN on MRIG, which aggregates information from multiple neighbors.

[0063] In some embodiments, the uniform pool corresponding to the target item node is constructed as follows: other item nodes in the graph structure data besides the target item node are taken as a set of candidate item nodes; the Euclidean distance between the feature data of the target item and the feature data of each item node in the candidate item set is calculated; based on the Euclidean distance, a set of feature data of item nodes is selected from the candidate item set and stored in the uniform pool of the target item node, wherein each set of feature data selected for the uniform pool is the feature data in the candidate item set that is closest to the target item node in terms of Euclidean distance and does not overlap with each other.

[0064] Specifically, the construction of the uniform pool can be described by the following algorithm. The algorithm first calculates the Euclidean distance between the target item node and the feature data of each candidate item node, and stores the distance values ​​in matrix B. B is then sorted to obtain the distance matrix Bdist corresponding to the sorted index matrix newB. Subsequently, duplicate candidate nodes are cyclically removed to ensure the uniqueness of the feature data finally selected into the uniform pool. The algorithm's output includes the set of indices U of the nodes in the uniform pool, and the set of distances Ud between the target item node and each node in the uniform pool. Here, U stores the indices corresponding to the feature data of the closest and non-repeating candidate item node to the target item node, and Ud records the corresponding Euclidean distance values.

[0065] For example, the meaning of the code related to uniform pooling is as follows: Input: P represents the set of feature data of candidate item nodes; z represents the feature data of the target item node. Output: U represents the set of indices of the feature data of nodes in the uniform pool; Ud represents the set of Euclidean distances from the target item node to the feature data of each node in the uniform pool.

[0066] In some embodiments, the method further includes updating the uniform pool corresponding to the target item node; updating the uniform pool corresponding to the target item node includes: calculating the Euclidean distance between the newly generated item node feature data and the target item node feature data; comparing the newly generated feature data with the Euclidean distance from the existing feature data in the uniform pool to the target item node; if the newly generated feature data has a smaller Euclidean distance from the target item node, then replacing the original feature data in the uniform pool with it.

[0067] Specifically, during the algorithm iteration process, the feature data in the uniform pool is continuously updated and participates in subsequent calculations with the same probability as other feature data. When updating the uniform pool, the Euclidean distance between the newly generated item node feature data and the feature data of each target item node is first calculated, and the nearest feature data corresponding to each target item node is determined using the uniform pool generation algorithm. Subsequently, the calculated distance values ​​are sorted and stored in matrix Bdist, and their corresponding indices are stored in matrix B. Next, the distance set Ud corresponding to the existing feature data in the uniform pool is compared with Bdist, and the nearest feature data for each target item node is judged one by one. For the i-th item node, if the distance Bdist(i, 1) corresponding to the newly generated feature data is less than Ud(t), then Ud(t) is replaced with Bdist(i, 1), and the corresponding index value is updated, thereby realizing the update of the feature data corresponding to the target item node in the uniform pool.

[0068] For example, the meaning of the code related to uniform pooling is as follows: Input: osP represents the child feature dataset; Z represents the set of new target item nodes; Ut represents the set of indices of the node feature data in the t-th generation uniform pool; Udt represents the set of Euclidean distances from the target item node to the feature data of each node in the uniform pool in the t-th generation. Output: Ut+1 represents the set of indices of the node feature data in the (t+1)-th generation uniform pool; Ud t+1 Let represent the set of Euclidean distances from the target item node in generation t+1 to the feature data of each node in the uniform pool.

[0069] S310, determine user preferences based on updated target feature data of at least one target item node.

[0070] In some embodiments, determining user preferences based on updated target feature data of at least one target item node includes: extracting click preference vectors and purchase preference vectors based on updated target feature data of at least one target item node; and fusing the click preference vectors and purchase preference vectors using a gating mechanism to obtain user preferences.

[0071] Specifically, for a click sequence in a session and purchase sequence Click preferences can be obtained based on the updated target feature data of at least one target item node. and purchasing preferences Click preferences and purchasing preferences It can be calculated using the following formula:

[0072] in, This indicates that the i-th item node in the sequence has been clicked; This represents the final feature of the i-th item node in the click sequence, which is the feature obtained through iterative aggregation using GNN mentioned earlier. This includes the neighbor association characteristics of the item; This represents the sum of the final characteristics of all items in the click sequence; This indicates the total number of items in the clicked sequence.

[0073] in, This represents the i-th item node in the purchase sequence; This represents the final characteristic of the i-th item node in the purchase sequence; This represents the sum of the final characteristics of all items in the purchase sequence; This indicates the total number of items in the purchased sequence.

[0074] In some embodiments, considering that users may have different preferences for different behaviors, MGNN-SPred further uses a fully connected layer to obtain weights representing relative importance. :

[0075] in, It is the sigmoid activation function. This represents the column concatenation of the click preference vector C and the purchase preference vector P. These are the parameters to be learned in the fully connected layer.

[0076] Ultimately, MGNN-SPred uses a gating mechanism to obtain the final user preferences. ,

[0077] in, This represents the dimensional constraint of the final preference vector o.

[0078] Regarding user preferences Each item to be predicted MGNN-Spred further uses a bilinear method to obtain the final predicted score and applies a softmax function to obtain the probability distribution. :

[0079] in, Represents the original preference score. The feature vector representing the target item; These are the parameters to be learned; It is a model of items The predicted value, It is a model of items The predicted probability.

[0080] In some embodiments, after completing user preference estimation, MGNN-Spred can further update the training module. Specifically, the following cross-entropy loss function can be used. Train the entire model:

[0081] Where s represents a single session and j represents a single item. This represents the actual label of item j in session s. This represents the summation of the set of all items J. This represents summing over the set S of all user sessions. The predicted label of item j in session s is given if and only if the item... It is a conversation When the next real-world interactive item is... otherwise, .

[0082] The following is one example of pseudocode for implementing the above method provided in this disclosure: import numpy as np import tensorflow as tf class MGNN SPred : def build model(self): # Define the latent feature matrix of items witht.variable.scope( 'Graph', reuse tf, AUTO REUSE, eqularizer =self.12_logs('all) ) as self.graph scope: self.embedding_ matrix tf. get variable( name = init_ embedding',shape s [ self. num nodes, self. dim]) withtif.variable_ scope( 'Network', reuse-tf. AUno RESt, regularizer-self. 12_los('all'); pos=tf.expand dims(self. pos, -1) pos_neg =tf. concat( [ pos, self. neg] , -1) # [ BS, num_ neg + 1] pos_neg_label= tf.concat( [ tf. ones_ like( pos, dtype - tf. int32) ,tf. zeros like (self. neg, dtype= tf. int32) ] , -1) # [ BS, M + 1] #Input: Historical clicked item sequence, Output: Click characteristics click_seq_mask =tf.not_equal( self. click seg, 0)click seg mask tf.cast( click_seg_mask, tf.float32) auxiliary_emb = self. gnn( self. click_ seg, method = graphsAGE") auxiliary_emb = self. mask_mean( auxiliary emb, click_seg_mask) #Input: Historical purchase item sequence, Output: Purchase characteristics: buy seg mask tf.not equal(self.buy seg, o) buy_seg_mask= tf. cast( buy seg mask, tf. float32) target_seq_emb=self.gnn(self.buy_seg, method="graphSAGE") # Use a gate to fuse click features and purchase features target_ seq_emb=self. mask_mean( target_seq_emb, buy_seg_mask) final_seg_emb = self.gat (auxiliary_emb, target_seg_emb,'merge_buy _and_click_seg') final_seq_emb=tf.layers.dense( final_seg_emb, self.dim, name='dense_W',use_bias=False) al1_ item_ score = tf.matmul( final_seg_emb, self.embedding_matrix,transpose_b=True) topk = tf.math.top_k( all_item_score, k=500) self.topkv =topk.values self.topki =topk.indices pos_neg_embs= tf.nn.embedding_lookup(self. embedding matrix, pos_neg)#[BS,M+1,k] pos_neg_score= tf.reduce_ sum( tf. expand_dims( final_seg_emb, 1) pos_neg embs,-1) seg loss = tf. losses. softmax_cross_entropy (pos neg label, pos_neg_score) self.loss= seg_loss # L2 regularization self.loss t= tf.losses.get_regularization_loss() opt = tf.train. AdamOptimizer( learning rate=self.Ir) self.minimizer= opt.minimize(self.loss) The following is a second example of pseudocode for implementing the above method according to an embodiment of this disclosure: def gnn(self, input_ seg, method) if method == graphsAGE" batch size = tf.shape(input_seg)[o] For each input item sequence, extract its multi-order neighbors on the graph. `item_neighbors, item_masks - self.gain_neighbors_from(input_seq, batch_size)` # Use graphsAGE to aggregate features from multi-order neighbors. gnn_ emb = self. graphsAGE( item_ neighbors= item_ neighbors, batchsize=batch ze, item_ masks - item_masks) return gnn emb def graphsaGE( self, item_ neighbors, batch size, item masks): #Use a non-recursive approach to aggregate multi-order neighbor features, aggregating from the highest-order node to the lowest-order nodes, ultimately obtaining a new representation of the center node. entity_ embs = [ tf. nn. embedding_ lookup( self. embedding matrix,i) for i in item neighbors] for n_ hop in range( self. gnn depth)entity_embs_next_iter=[shape [batch_ size, -1, self. adj len, self. dim]mask_ shape [ batch size, -1, self.adj len]indicator self = o indicator neigh 1 for hop in range( self. gnndepth - n hop): for i in range( 4 hop): vector self. mean agg( self emb= entity embs indicator self]neighbor_emb_ 0= tf. reshape( entity_ embs[ indicator_ neigh] , shape= shape) ,neighbor _ emb _ 1 tf. reshape( entity embs[ indicator neigh t 1] , shape=shape) , neighbor _ emb2= tf. reshape (entity embs[ indicator neigh 2] ,shape= shape) , neighbor emb 3= tf. reshape( entity embs [ indicator neigh t3] , shape= shape) , masko= tf. reshape( item masks[ indicator neigh -1]shape= mask shape) , mask1= tf. reshape( item masks[ indicator neigh t 1 -1] ,shape=mask shape) , mask2= tf. reshape( item masks[ indicator neigh 2 -1] ,shape= mask _ shape) , mask3 tf. reshape( item masks[ indicator neigh 3-1] ,shape= mask _ shape) , batch size= batch size) indicator self + 1 indicator neigh + 4 entity embs next iter. append(vector) entity embs entity embs next iter new_ seq_ emb tf. reshape( entity_ embs[ o] , batch size, self. seq_length, self. dim]) return new seg emb def mean_ agg( self, self_ emb, neighbor emb o, neighbor emb_ 1,neighbor_ emb_ 2, neighbor emb_ 3, masko. mask1 mask2, mask3, batch size) neighbor_ emb_ mean_ 0= self. mask mean( neighbor_ emb_ 0, masko) neighbor_ emb_ mean1 self. mask mean( neighbor_ emb_ 1, mask1)neighbor_ emb_ mean 2 self. mask mean( neighbor_ emb_ 2, mask2)neighbor_ emb_mean 3= self mask mean( neighbor_ emb_ 3, mask3) neighbor_ embmean 0= tf. reshape neighbor_ emb_ mean_ 0, batch-size,1, self dim]) neighbor_ emb_ mean 1= tf, reshape( neighbor emb_ mean , iatcn-120,-1,self dim]) In this embodiment, for neighboring item data that does not conform to the characteristics of the target item and its associated items, a digital fingerprint is generated using a distributed feature table. When the feature data matches the digital fingerprint, it is stored in a uniform pool, thereby minimizing and restricting the data range of the aggregation calculation to the uniform pool, significantly reducing the aggregation range of irrelevant data, improving the calculation speed, and reducing the computational resource overhead.

[0083] Figure 4 This invention discloses a flowchart illustrating a method for updating graph neural network profile features according to an embodiment of the present disclosure. Figure 4 As shown, in this embodiment of the disclosure, after obtaining user preferences, it may further include: S402, input the set of recommendation data corresponding to user preferences into a metric learning model and calculate the loss value.

[0084] In this embodiment, see Figure 5 As shown, the metric learning model is built upon a knowledge distillation network. The metric learning model provided in this embodiment consists of a teacher network, a student network, and corresponding embedding and dense layers for each network. The batch-processed recommendation data set corresponding to user preferences is simultaneously input into two parallel branches of the teacher and student networks. After feature extraction and encoding by the teacher network, embedded teacher features are output; after feature extraction and encoding by the student network, embedded student features are output. Based on the embedded teacher and student features, a similarity transfer loss is calculated to achieve feature knowledge transfer and distribution alignment from the teacher network to the student network. Simultaneously, the features output by the student network are input into the dense layer. Based on the mapping output of the dense layer, validation & tri-state loss and classification loss are calculated respectively. The similarity transfer loss, validation & tri-state loss, and classification loss are weighted and fused to obtain the total loss value corresponding to this metric learning model. Metric learning is widely used in tasks such as clustering. The knowledge distillation technique used in this embodiment is Neuron Selectivity Transfer. In the feature map, each channel represents the selective knowledge of a neuron. Maximum Mean Discrepancy (MMD) is a distance metric used to measure the distributional differences between sampled data.

[0085] Specifically, before proceeding to distillation and metric learning, batch data processing is first performed. Batch data processing normalizes, structures, and encapsulates the original user behavior, graph structure data, and interaction data in batches, outputting standardized batch data. At the same time, user preferences are calculated based on the original data, and a set of recommendation data corresponding to user preferences is generated based on user preference matching. This part of the data is the input data for all subsequent networks.

[0086] After batch processing, the recommended dataset is input into the upper-level teacher network. The teacher network performs deep feature extraction on graph structure, user interaction, and item features. After multi-layer network encoding, it outputs embedded teacher features, which are the highly robust and expressive user / item embedding representations generated by the teacher network. These are the distilled standard answer features.

[0087] The same set of recommendation data is simultaneously input into the lower-level student network. The student network performs feature encoding in sync and outputs embedded student features, which are lightweight embedded representations learned by the student network. This is the distilled learning answer feature.

[0088] The similarity transfer loss is calculated by aligning the embedded teacher and embedded student features. This similarity transfer loss forces the student network to learn the feature distribution and similarity relationship of the teacher network, allowing the lightweight student network to fit the high-quality features of the teacher network, thus achieving knowledge distillation. It is the first constraint on feature consistency in metric learning.

[0089] In addition to outputting embedded student features, the student network also inputs its own encoded features into the dense layer. After the dense layer outputs, two types of supervised losses are calculated, forming the second and third constraints of metric learning: Validation & Tri-state Loss: Used to constrain the distance between sample pairs / triples in metric learning, increasing the distance between negative samples and decreasing the distance between positive samples to optimize the discriminativeness of embedded features. It is the core metric loss for user profiling and recommendation matching. Classification Loss: Provides supervised constraints for user preference classification and recommendation tag classification, ensuring the accuracy of feature classification and the matching degree of recommendation intent. It is a task-oriented supervised loss.

[0090] The calculated loss value is the weighted sum of similarity transfer loss, verification & three-state loss, and classification loss, which is the total loss of the entire dual-network distillation + metric learning architecture.

[0091] An example loss function for Neuron Selectivity Transfer The expression is as follows:

[0092] in, This is the cross-entropy loss. To combine parameters The square maximum mean discrepancy loss, where, The weight parameters represent the student network. Indicates the true label, This represents the output probability distribution of the student network. Represents the balance coefficient. This represents the output characteristics of the teacher network. This represents the output characteristics of the student network. Note that, to ensure... Meaningful, teacher network needs to be ensured With student network The output feature vectors have the same length.

[0093] Specifically, for the feature maps output by the intermediate layers of the network, the feature vector of spatial size HW in each channel is regarded as a sample of distribution X. By specification, it is necessary to ensure that the feature maps corresponding to the Teacher network and the Student network have the same size in spatial dimension. If the sizes are inconsistent, interpolation methods can be used for adjustment.

[0094] The expression for Maximum Mean Discrepancy Loss (MMD Loss) is as follows:

[0095] in, This indicates the number of behavior categories for the current user in the session (e.g., the number of behavior types such as "click", "add to cart", and "purchase" in the current user session). This represents the number of behavior categories of users in historical sessions (the number of behavior types contained in the historical user group). This represents the sample index within the same behavior category. Let f represent the profile feature vector corresponding to the i-th type of behavior in the current session user (e.g., the feature vector of product, time, etc. corresponding to "current user purchase behavior"), and let f represent the profile feature vector corresponding to the i-th type of behavior in the historical session users (e.g., the feature vector of product, time, etc. corresponding to "historical user purchase behavior"). This represents the similarity of the same type of behavioral features between the current user and historical users after normalization (using thousands to quantify the matching degree of the two types of user behavior distributions). It should be noted that when i represents "a certain type of behavior of the current session user (e.g., purchasing behavior)," k corresponds to the k-th sample under that category (e.g., the feature of the k-th item purchased by the current user); when i represents "a certain type of behavior of historical session users," k corresponds to the k-th historical sample under that category (e.g., the feature of the k-th item purchased by a historical user). L-regularization is applied to each channel in the formula.

[0096] In this embodiment, after obtaining the set of user preference recommendation data obtained by the MGNN-SPred algorithm in the GNN network, it is substituted into the metric learning model to calculate the metric value, which ranges from 0% to 100%.

[0097] S404 filters the recommended data based on the loss value and uses the filtered data to update the graph neural network profile features.

[0098] In this embodiment, a truly effective deep learning-based data processing dataset is obtained through loss value filtering, and the updated graph neural network profile features of MGNN-SPred are updated accordingly, serving as the initial feature set for the next deep learning-based data processing. Finally, the data information associated with the graph neural network profile features is stored in a wide table format, thereby providing a query basis for subsequent profile matching and retrieval, and improving the timeliness of profile data acquisition.

[0099] See Figure 6 The diagram shown illustrates the generation of a user profile. When performing user profile analysis, the graph neural network profile information is obtained through the analysis configuration module. The graph neural network profile information is stored in the demouser profile crowd data table. Table 1 is a representation of a demouser profile crowd provided in this embodiment of the present disclosure.

[0100] Table 1

[0101] The `calculate labels` field records the list of profile labels to be analyzed in the form of a JSON array, and `userprofile_date` represents the user profile date. The analysis engine is used to analyze the profile information based on the graph neural network to obtain the analysis results. The profile analysis results are output through the analysis results module and stored in the data table demo userprofile crowd overview. Table 2 is a schematic table of demo userprofile crowd overview provided by the embodiments of this disclosure.

[0102] Table 2

[0103] The overview.result field stores the profile analysis results of the association graph neural network profile tags, and the userprofile date field records the date of the data used for profile analysis.

[0104] In some embodiments, a wide profile table and a result table collected through big data are also included. Table 3 is a profile wide profile table provided by an embodiment of this disclosure.

[0105] Table 3

[0106] In this embodiment, the calculate labels can specifically be gender; province, such as AA province, BB province; and p_date, the user profile date, such as 2022-08-26.

[0107] Table 4 is a schematic diagram of a portrait width provided in the embodiments of this disclosure.

[0108] Table 4

[0109] In this embodiment, after filtering out the loss function, a recommendation data set containing truly effective user preferences is obtained, and the graph neural network profile features are updated as the initial feature set for the next new deep learning-based data processing, thereby improving the accuracy of recommendations. Finally, the data information associated with the graph neural network profile features is stored in the form of a wide data table, providing an initial query range for the next profile matching retrieval and improving the timeliness of profile data retrieval.

[0110] Based on the same inventive concept, this disclosure also provides a data processing device based on deep learning, as shown in the following embodiments. Since the principle by which this device embodiment solves the problem is similar to that of the above-described method embodiments, the implementation of this device embodiment can refer to the implementation of the above-described method embodiments, and repeated details will not be described again.

[0111] Figure 7 This illustration shows a schematic diagram of a deep learning-based data processing apparatus according to an embodiment of the present disclosure, such as... Figure 7 As shown, the device includes: an acquisition module 71, configured to acquire graph structure data corresponding to an item set, and determine a target item node and a set of neighboring item nodes corresponding to the target item node based on multiple item nodes in the graph structure, wherein each item node in the graph structure data has corresponding feature data; an identification module 72, configured to identify a subset of feature data that is inconsistent with the neighboring feature data of the target item node from the feature data of the item set; a matching module 73, configured to match digital fingerprints to the feature data in the subset of feature data, and determine the similarity between the feature data and the digital fingerprint, wherein the digital fingerprint is used to characterize neighboring feature data substantially associated with the target item node; a filtering module 74, configured to filter based on the similarity, store feature data that meets preset conditions into a uniform pool corresponding to the target item node, and aggregate the feature data in the uniform pool to generate updated target feature data of the target item node; and a user preference determination module 75, configured to determine user preferences based on the updated target feature data of at least one target item node.

[0112] In some embodiments, the matching module 73 is specifically configured to: access a distributed feature table storing multiple pre-generated digital fingerprints; calculate the Euclidean distance between the feature data and each digital fingerprint in the distributed feature table; match the feature data to the digital fingerprint with the smallest Euclidean distance, and characterize the similarity between the feature data and the digital fingerprint with the smallest Euclidean distance.

[0113] In some embodiments, the graph structure data is a multi-relationship item graph, whose edges include edges representing purchase conversion relationships between items and edges representing click conversion relationships between items; the neighbor item node set includes the set of incoming and outgoing neighbors when the target item node is a purchased item, and the set of incoming and outgoing neighbors when it is a clicked item.

[0114] In some embodiments, the digital fingerprint is pre-generated based on historical behavioral feature data stored in a distributed feature table. The historical behavioral feature data represents feature data whose form is different from the original feature data but is essentially the same as the original feature data. Each digital fingerprint corresponds to an abnormal feature pattern defined by the historical behavioral feature data, which is used to characterize that the historical behavioral feature data actually belongs to the neighbor feature set corresponding to the target item node in terms of behavioral relationship.

[0115] In some embodiments, the uniform pool corresponding to the target item node is constructed as follows: other item nodes in the graph structure data besides the target item node are taken as a set of candidate item nodes; the Euclidean distance between the feature data of the target item and the feature data of each item node in the candidate item set is calculated; based on the Euclidean distance, a set of feature data of item nodes is selected from the candidate item set and stored in the uniform pool of the target item node, wherein each set of feature data selected by the uniform pool is the feature data in the candidate item set that has the closest Euclidean distance to the target item node and does not overlap with each other.

[0116] In some embodiments, the method further includes updating the uniform pool corresponding to the target item node; updating the uniform pool corresponding to the target item node includes: calculating the Euclidean distance between the newly generated item node feature data and the target item node feature data; comparing the newly generated feature data with the Euclidean distance from the existing feature data in the uniform pool to the target item node; if the newly generated feature data has a smaller Euclidean distance from the target item node, then replacing the original feature data in the uniform pool with it.

[0117] In some embodiments, the user preference determination module 75 is specifically used to: extract a click preference vector and a purchase preference vector based on updated target feature data of at least one target item node; and fuse the click preference vector and the purchase preference vector using a gating mechanism to obtain the user preference.

[0118] In some embodiments, the user preferences include a set of recommendation data. After determining the user preferences, the method further includes: inputting the set of recommendation data corresponding to the user preferences into a metric learning model to calculate a loss value; filtering the recommendation data in the set of recommendation data according to the loss value; and updating the graph neural network profile features using the filtered recommendation data.

[0119] In some embodiments, the metric learning model employs a neuron-selective transfer method, and the loss function of the metric learning model is determined based on cross-entropy loss and maximum average difference loss.

[0120] In some embodiments, the updated graph neural network profile features are stored in a wide data table.

[0121] It should be noted that the examples and application scenarios implemented by the modules in the above device embodiments and the corresponding steps in the method embodiments are the same, but are not limited to the content disclosed in the above method embodiments. It should also be noted that the above modules, as part of the device, can be executed in a computer system such as a set of computer-executable instructions.

[0122] Those skilled in the art will understand that various aspects of this disclosure can be implemented in the following forms: a completely hardware implementation, a completely software implementation (including firmware, microcode, etc.), or a combination of hardware and software implementations, which can be collectively referred to herein as a "circuit", "module" or "system".

[0123] Based on the same inventive concept, this disclosure also provides an electronic device, which includes: a processor; and a memory for storing executable instructions of the processor; wherein the processor is configured to execute any of the above-described deep learning-based data processing methods by executing the executable instructions. Since the principle by which this electronic device solves the problem is similar to that of the above-described method embodiments, the implementation of this electronic device embodiment can refer to the implementation of the above-described method embodiments, and repeated details will not be described again.

[0124] The following reference Figure 8 To describe an electronic device 800 according to such an embodiment of the present disclosure. Figure 8 The electronic device 800 shown is merely an example and should not impose any limitation on the functionality and scope of use of the embodiments disclosed herein.

[0125] like Figure 8 As shown, the electronic device 800 is manifested in the form of a general-purpose computing device. The components of the electronic device 800 may include, but are not limited to: at least one processing unit 810, at least one storage unit 820, and a bus 830 connecting different system components (including storage unit 820 and processing unit 810).

[0126] The storage unit stores program code that can be executed by the processing unit 810, causing the processing unit 810 to perform the steps described in the "Exemplary Methods" section of this specification according to various exemplary embodiments of this disclosure. For example, the processing unit 810 can perform the following steps of the above method embodiments: obtaining graph structure data corresponding to an item set, and determining a target item node and a set of neighboring item nodes corresponding to the target item node based on multiple item nodes in the graph structure, wherein each item node in the graph structure data has corresponding feature data; identifying a subset of feature data that is inconsistent with the neighboring feature data of the target item node from the feature data of the item set; matching digital fingerprints to the feature data in the feature data subset and determining the similarity between the feature data and the digital fingerprint, wherein the digital fingerprint is used to characterize the neighboring feature data substantially associated with the target item node; filtering based on similarity, storing feature data that meets preset conditions into a uniform pool corresponding to the target item node, and aggregating the feature data in the uniform pool to generate updated target feature data for the target item node; and determining user preferences based on the updated target feature data of at least one target item node.

[0127] Storage unit 820 may include a readable medium in the form of a volatile storage unit, such as random access memory (RAM) 8201 and / or cache memory 8202, and may further include a read-only memory (ROM) 8203.

[0128] The storage unit 820 may also include a program / utility 8204 having a set (at least one) of program modules 8205, such program modules 8205 including but not limited to: an operating system, one or more application programs, other program modules, and program data, each or some combination of these examples may include an implementation of a network environment.

[0129] Bus 830 can represent one or more of several types of bus structures, including a memory cell bus or memory cell controller, a peripheral bus, a graphics acceleration port, a processing unit, or a local bus using any of the various bus structures.

[0130] Electronic device 800 can also communicate with one or more external devices 840 (e.g., keyboard, pointing device, Bluetooth device, etc.), and with one or more devices that enable a user to interact with electronic device 800, and / or with any device that enables electronic device 800 to communicate with one or more other computing devices (e.g., router, modem, etc.). This communication can be performed via input / output (I / O) interface 850. Furthermore, electronic device 800 can also communicate with one or more networks (e.g., local area network (LAN), wide area network (WAN), and / or public networks, such as the Internet) via network adapter 860. As shown, network adapter 860 communicates with other modules of electronic device 800 via bus 830. It should be understood that, although not shown in the figures, other hardware and / or software modules can be used in conjunction with electronic device 800, including but not limited to: microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, and data backup storage systems.

[0131] From the above description of the embodiments, those skilled in the art will readily understand that the exemplary embodiments described herein can be implemented by software or by combining software with necessary hardware. Therefore, the technical solutions according to the embodiments of this disclosure can be embodied in the form of a software product, which can be stored in a non-volatile storage medium (such as a CD-ROM, USB flash drive, external hard drive, etc.) or on a network, including several instructions to cause a computing device (such as a personal computer, server, terminal device, or network device, etc.) to execute the methods according to the embodiments of this disclosure.

[0132] Based on the same inventive concept, this disclosure also provides a computer-readable storage medium storing a computer program that, when executed by a processor, implements any of the above-described deep learning-based data processing methods. Since the principle by which this computer-readable storage medium solves the problem is similar to that of the above-described method embodiments, the implementation of this computer-readable storage medium embodiment can refer to the implementation of the above-described method embodiments, and repeated details will not be elaborated further.

[0133] More specific examples of computer-readable storage media in this disclosure may include, but are not limited to: electrical connections having one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0134] In this disclosure, a computer-readable storage medium may include a data signal propagated in baseband or as part of a carrier wave, carrying readable program code. Such propagated data signals may take various forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. A readable signal medium may also be any readable medium other than a readable storage medium, capable of transmitting, propagating, or transmitting a program for use by or in connection with an instruction execution system, apparatus, or device.

[0135] Optionally, the program code contained on the computer-readable storage medium may be transmitted using any suitable medium, including but not limited to wireless, wired, optical fiber, RF, etc., or any suitable combination thereof.

[0136] In practical implementation, program code for performing the operations of this disclosure can be written in any combination of one or more programming languages, including object-oriented programming languages ​​such as Java and C++, and conventional procedural programming languages ​​such as C or similar languages. The program code can execute entirely on the user's computing device, partially on the user's device, as a standalone software package, partially on the user's computing device and partially on a remote computing device, or entirely on a remote computing device or server. In cases involving remote computing devices, the remote computing device can be connected to the user's computing device via any type of network, including a local area network (LAN) or a wide area network (WAN), or it can be connected to an external computing device (e.g., via the Internet using an Internet service provider).

[0137] Based on the same inventive concept, this disclosure also provides a computer program product, comprising: a computer program or instructions, wherein the computer program or instructions, when executed by a processor, implement the deep learning-based data processing method of any one of the above method embodiments. Since the principle by which this computer program product embodiment solves the problem is similar to that of the above method embodiments, the implementation of this computer program product embodiment can refer to the implementation of the above method embodiments, and repeated details will not be elaborated further.

[0138] It should be noted that although several modules or units for the device used to perform actions have been mentioned in the detailed description above, this division is not mandatory. In fact, according to embodiments of this disclosure, the features and functions of two or more modules or units described above can be embodied in one module or unit. Conversely, the features and functions of one module or unit described above can be further divided and embodied by multiple modules or units.

[0139] Furthermore, although the steps of the method in this disclosure are described in a specific order in the accompanying drawings, this does not require or imply that the steps must be performed in that specific order, or that all the steps shown must be performed to achieve the desired result. Additional or alternative steps may be omitted, multiple steps may be combined into one step, and / or a step may be broken down into multiple steps.

[0140] From the above description of the embodiments, those skilled in the art will readily understand that the exemplary embodiments described herein can be implemented by software or by combining software with necessary hardware. Therefore, the technical solutions according to the embodiments of this disclosure can be embodied in the form of a software product, which can be stored in a non-volatile storage medium (such as a CD-ROM, USB flash drive, external hard drive, etc.) or on a network, including several instructions to cause a computing device (such as a personal computer, server, mobile terminal, or network device, etc.) to execute the methods according to the embodiments of this disclosure.

[0141] Other embodiments of this disclosure will readily occur to those skilled in the art upon consideration of the specification and practice of the invention disclosed herein. This disclosure is intended to cover any variations, uses, or adaptations of this disclosure that follow the general principles of this disclosure and include common knowledge or customary techniques in the art not disclosed herein. The specification and examples are to be considered exemplary only, and the true scope and spirit of this disclosure are indicated by the appended claims.

Claims

1. A data processing method based on deep learning, characterized in that, The method includes: Obtain the graph structure data corresponding to the item set, and based on multiple item nodes in the graph structure, determine the target item node and the set of neighboring item nodes corresponding to the target item node, wherein each item node in the graph structure data has corresponding feature data; From the feature data of the item set, identify a subset of feature data that is inconsistent with the neighbor feature data of the target item node; Match digital fingerprints to feature data in the subset of feature data and determine the similarity between the feature data and the digital fingerprint, wherein the digital fingerprint is used to characterize neighbor feature data that is substantially associated with the target item node; Based on the similarity, the feature data that meets the preset conditions is stored in the uniform pool corresponding to the target item node, and the feature data in the uniform pool is aggregated to generate the updated target feature data of the target item node. User preferences are determined based on updated target feature data from at least one target item node.

2. The data processing method based on deep learning according to claim 1, characterized in that, The step of matching digital fingerprints with feature data in the subset of feature data and determining the similarity between the feature data and the digital fingerprint includes: Access a distributed feature table containing multiple pre-generated digital fingerprints; Calculate the Euclidean distance between the feature data and each digital fingerprint in the distributed feature table; The feature data is matched to the digital fingerprint with the smallest Euclidean distance, and the similarity between the feature data and the digital fingerprint is represented by the smallest Euclidean distance.

3. The data processing method based on deep learning according to claim 1, characterized in that, The graph structure data is a multi-relationship item graph, whose edges include edges representing purchase conversion relationships between items and edges representing click conversion relationships between items; The set of neighboring item nodes includes the set of incoming and outgoing neighbors when the target item node is a purchased item, and the set of incoming and outgoing neighbors when it is a clicked item.

4. The data processing method based on deep learning according to claim 1, characterized in that, The digital fingerprint is pre-generated based on historical behavioral feature data stored in a distributed feature table. The historical behavioral feature data represents feature data whose form is different from the original feature data but is essentially the same as the original feature data. Each digital fingerprint corresponds to an abnormal feature pattern defined by the historical behavioral feature data, which is used to characterize that the historical behavioral feature data actually belongs to the neighbor feature set corresponding to the target item node in terms of behavioral relationship.

5. The data processing method based on deep learning according to claim 1, characterized in that, The uniform pool corresponding to the target item node is constructed in the following manner: The other item nodes in the graph structure data, excluding the target item node, are used as a set of candidate item nodes; Calculate the Euclidean distance between the feature data of the target item and the feature data of each item node in the candidate item set; Based on the Euclidean distance, a set of feature data of item nodes is selected from the candidate item set and stored in the uniform pool of the target item node. Each set of feature data selected for the uniform pool is the feature data of the candidate item set that is closest to the target item node in terms of Euclidean distance and that do not overlap with each other.

6. The data processing method based on deep learning according to claim 5, characterized in that, It also includes updating the uniform pool corresponding to the target item node; The process of updating the uniform pool corresponding to the target item node includes: Calculate the Euclidean distance between the newly generated item node feature data and the target item node feature data; The newly generated feature data is compared with the Euclidean distance from the existing feature data in the uniform pool to the target item node; If the newly generated feature data has a smaller Euclidean distance to the target item node, then it replaces the original feature data in the uniform pool.

7. The data processing method based on deep learning according to claim 1, characterized in that, The determination of user preferences based on updated target feature data of at least one target item node includes: Based on the updated target feature data of at least one target item node, extract the click preference vector and purchase preference vector; The user preference is obtained by fusing the click preference vector and the purchase preference vector using a gating mechanism.

8. The data processing method based on deep learning according to claim 1, characterized in that, The user preferences include a recommendation dataset, and after determining the user preferences, it also includes: The recommended data set corresponding to the user preferences is input into a metric learning model to calculate the loss value; The recommended data in the recommended data set is filtered according to the loss value, and the filtered recommended data is used to update the graph neural network profile features.

9. The data processing method based on deep learning according to claim 8, characterized in that, The metric learning model employs a neuron selective transmission method, and its loss function is determined based on cross-entropy loss and maximum average difference loss.

10. The data processing method based on deep learning according to claim 8, characterized in that, The updated graph neural network profile features are stored in a wide data table.

11. A data processing device based on deep learning, characterized in that, The device includes: The acquisition module is used to acquire the graph structure data corresponding to the item set, and based on multiple item nodes in the graph structure, determine the target item node and the set of neighboring item nodes corresponding to the target item node, wherein each item node in the graph structure data has corresponding feature data; The identification module is used to identify a subset of feature data that is inconsistent with the neighbor feature data of the target item node from the feature data of the item set; A matching module is used to match digital fingerprints to feature data in the subset of feature data and determine the similarity between the feature data and the digital fingerprint, wherein the digital fingerprint is used to characterize neighbor feature data that is substantially associated with the target item node; The filtering module is used to filter based on the similarity, store feature data that meets the preset conditions into a uniform pool corresponding to the target item node, and aggregate the feature data in the uniform pool to generate updated target feature data of the target item node. The user preference determination module is used to determine user preferences based on updated target feature data of at least one target item node.

12. An electronic device, characterized in that, include: processor; as well as Memory for storing the executable instructions of the processor; The processor is configured to execute the deep learning-based data processing method according to any one of claims 1 to 10 by executing the executable instructions.

13. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by the processor, it implements the deep learning-based data processing method according to any one of claims 1 to 10.

14. A computer program product comprising: A computer program or instruction, characterized in that, when executed by a processor, the computer program or instruction implements the data processing method based on deep learning as described in any one of claims 1 to 10.

Images