Continuous time interaction graph representation method

Abstract

This invention discloses a continuous temporal interaction graph representation method and medium. The method includes: acquiring raw dynamic graph data and preprocessing it to obtain structural data, node features, and edge features; partitioning the data to generate a training set, a test set, and a validation set; training a model based on the training set to obtain an initial graph representation model, and testing and validating the initial graph representation model based on the test set and validation set to obtain a final graph representation model; acquiring the dynamic graph to be processed; and outputting the node representation vectors corresponding to the nodes in the dynamic graph to be processed through the final graph representation model. This method can effectively capture the continuous dynamics of node representations and learn their state trajectories, thereby effectively improving the representation ability of inactive nodes and the prediction effect of long-interval interactions.

Description

Technical Field

[0001] This invention relates to the field of graph representation learning technology, and in particular to a continuous temporal interactive graph representation method and a computer-readable storage medium. Background Technology

[0002] Currently, in dynamic graph representation learning for time-series interaction sequences, commonly used representation learning methods mainly fall into two categories. One is based on incremental update mechanisms, which only updates the node state when an interaction occurs, i.e., keeping the node state unchanged between two interactions. The other is based on message passing mechanisms, which only models the discrete dynamics of node representations, i.e., designing and stacking multiple message passing network layers to aggregate neighboring nodes. However, neither of these methods can effectively capture the continuous dynamic evolution of node state trajectories, which inevitably leads to the loss of important state information of inactive nodes during long-interval interactions. Summary of the Invention

[0003] The present invention aims to at least partially solve one of the technical problems in the aforementioned technologies. To this end, one objective of the present invention is to propose a continuous temporal interaction graph representation method that can effectively capture the continuous dynamics of node representations and learn their state trajectories, thereby effectively improving the representation capability of inactive nodes and the prediction effect of long-interval interactions.

[0004] A second objective of this invention is to provide a computer-readable storage medium.

[0005] To achieve the above objectives, a first aspect of the present invention proposes a continuous temporal interactive graph representation method, comprising the following steps: acquiring raw dynamic graph data and preprocessing the raw dynamic graph data to obtain structural data, node features, and edge features; dividing the structural data, node features, and edge features according to a preset ratio to generate a training set, a test set, and a validation set; training a model based on the training set to obtain an initial graph representation model, and testing and validating the initial graph representation model based on the test set and the validation set to obtain a final graph representation model; acquiring the dynamic graph to be processed, and outputting the node representation vectors corresponding to the nodes in the dynamic graph to be processed through the final graph representation model.

[0006] According to an embodiment of the present invention, a continuous temporal interaction graph representation method first acquires raw dynamic graph data and preprocesses the raw dynamic graph data to obtain structural data, node features, and edge features. Next, the structural data, node features, and edge features are divided according to a preset ratio to generate a training set, a test set, and a validation set. Then, the model is trained based on the training set to obtain an initial graph representation model, and the initial graph representation model is tested and validated based on the test set and the validation set to obtain a final graph representation model. A dynamic graph to be processed is then acquired, and the node representation vectors corresponding to the nodes in the dynamic graph to be processed are output through the final graph representation model. This effectively captures the continuous dynamics of node representations and learns their state trajectories, thereby effectively improving the representation capability of inactive nodes and the prediction effect of long-interval interactions.

[0007] In addition, the continuous temporal interaction graph representation method proposed in the above embodiments of the present invention may also have the following additional technical features:

[0008] Optionally, preprocessing the original dynamic graph data includes: determining whether the time tags and node tags in the original dynamic graph data are abnormal, and processing the abnormality if the determination result is yes; sorting the interactions in the original dynamic graph data according to the time tags, and recoding the nodes and edges in the original dynamic graph data according to the sorting result; and splitting the recoded data to obtain structural data, node features, and edge features.

[0009] Optionally, the final graph representation model includes an encoder, a continuous inference module, a graph attention layer, and a decoder; the encoder projects the features of the node into a shallow space to obtain the initial hidden representation of the node; the continuous inference module generates the state trajectory of the node within a preset time interval based on the structural data, the node features, and the edge features; the graph attention layer aggregates the historical interaction information of the node to predict the future representation of the interacting node; and the decoder decodes the encoded data.

[0010] Optionally, the initial hiding representation is expressed by the following formula:

[0011]

[0012] in, This represents the initial hidden representation. This represents the node embedding vector of the current node. This represents the embedding vector of the current node corresponding to the previous interacting node. F represents the information characteristics of the previous interaction. T(Δt) represents the time interval Δt, || represents continuous operation, and f(·) represents the linear projection function, which is expressed by the following formula:

[0013] f(x) = xW + b

[0014] Where W and b represent learnable parameters;

[0015]

[0016] Among them, F T (t) represents the encoded time representation vector at time t. For trainable parameters, d T This represents the dimension of the vector space.

[0017] Optionally, after generating the training set, test set, and validation set, the method further includes: obtaining relevant node information corresponding to the training set, and dividing the test set and the validation set into a transductive test set, a transductive validation set, an inductive test set, and an inductive validation set based on the relevant node information.

[0018] Optionally, the state trajectory is expressed by the following formula:

[0019]

[0020] in, This represents the interaction information between nodes at time t. and These are three gates that respectively control the degree of influence of the three factors;

[0021]

[0022] Among them, W l W n W i and b l ,b n ,b i All of these are trainable parameters, and σ(·) represents the Sigmoid activation function that maps the output range to [0,1].

[0023] Optionally, the future representation is expressed by the following formula:

[0024]

[0025] in, Let k represent the future representation of node u, k represent the number of neighbors, and α represent the future representation of node u. j The attention score represents the influence of neighboring node j on node u.

[0026]

[0027] in,

[0028] d represents the dimension of the node representation vector, and q represents the query in the attention mechanism. t key K t and value V t The definition is as follows:

[0029]

[0030] Among them, W Q W K W V Represents the weight matrix. Let u be the representation vector of node u. The representation vector of the neighboring nodes of node u.

[0031] To achieve the above objectives, a second aspect of the present invention provides a computer-readable storage medium storing a continuous timing interaction graph representation program thereon, which, when executed by a processor, implements the continuous timing interaction graph representation method as described above.

[0032] According to an embodiment of the present invention, a computer-readable storage medium stores a continuous temporal interaction graph representation program, so that when a processor executes the continuous temporal interaction graph representation program, it implements the continuous temporal interaction graph representation method as described above, thereby effectively capturing the continuous dynamics of node representation and learning its state trajectory, thereby effectively improving the representation capability of inactive nodes and the prediction effect of long-interval interactions. Attached Figure Description

[0033] Figure 1 This is a flowchart illustrating a continuous temporal interaction graph representation method according to an embodiment of the present invention;

[0034] Figure 2 This is a schematic diagram of the final representation model according to an embodiment of the present invention. Detailed Implementation

[0035] Embodiments of the present invention are described in detail below, examples of which are illustrated in the accompanying drawings, wherein the same or similar reference numerals denote the same or similar elements or elements having the same or similar functions throughout. The embodiments described below with reference to the accompanying drawings are exemplary and intended to explain the present invention, and should not be construed as limiting the present invention.

[0036] In related technologies, the continuous dynamic evolution of node state trajectories cannot be effectively captured, inevitably leading to the loss of important state information of inactive nodes during long-interval interactions. According to an embodiment of the present invention, a continuous temporal interaction graph representation method first acquires raw dynamic graph data and preprocesses it to obtain structural data, node features, and edge features. Next, the structural data, node features, and edge features are divided according to a preset ratio to generate a training set, a test set, and a validation set. Then, the model is trained based on the training set to obtain an initial graph representation model, and the initial graph representation model is tested and validated based on the test set and the validation set to obtain a final graph representation model. The dynamic graph to be processed is then acquired, and the node representation vectors corresponding to the nodes in the dynamic graph to be processed are output through the final graph representation model. This effectively captures the continuous dynamics of node representations and learns their state trajectories, thereby effectively improving the representation capability of inactive nodes and the prediction effect of long-interval interactions.

[0037] To better understand the above technical solutions, exemplary embodiments of the present invention will be described in more detail below with reference to the accompanying drawings. Although exemplary embodiments of the present invention are shown in the drawings, it should be understood that the present invention can be implemented in various forms and should not be limited to the embodiments set forth herein. Rather, these embodiments are provided to enable a more thorough understanding of the present invention and to fully convey the scope of the invention to those skilled in the art.

[0038] To better understand the above technical solutions, the following will provide a detailed explanation of the technical solutions in conjunction with the accompanying drawings and specific implementation methods.

[0039] Figure 1 This is a flowchart illustrating a continuous timing interaction graph representation method according to an embodiment of the present invention, as shown below. Figure 1 As shown, this continuous temporal interaction graph representation method includes the following steps:

[0040] S101: Obtain the original dynamic graph data and preprocess it to obtain structural data, node features, and edge features.

[0041] There are several ways to preprocess the original dynamic graph data.

[0042] In some embodiments, preprocessing the original dynamic graph data includes: determining whether the time labels and node labels in the original dynamic graph data are abnormal, and handling the abnormality when the determination result is yes; sorting the interactions in the original dynamic graph data according to the time labels, and recoding the nodes and edges in the original dynamic graph data according to the sorting result; and splitting the recoded data to obtain structural data, node features, and edge features.

[0043] S102, divide the structural data, node features and edge features according to a preset ratio to generate training set, test set and validation set.

[0044] In some embodiments, after generating the training set, test set, and validation set, the method further includes: obtaining relevant node information corresponding to the training set, and dividing the test set and validation set into a transduced test set, a transduced validation set, an inductive test set, and an inductive validation set based on the relevant node information.

[0045] In other words, after the dataset is partitioned, nodes not present in the training set are set as new nodes. Furthermore, the data in the validation and test sets are divided into two groups based on whether new nodes appear during interactions: a validation set and a test set for transductive learning, and a validation set and a test set for inductive learning. Transduction is the reasoning from observed training instances to observed test instances; in this task, it means that all nodes appearing in the test set have also appeared in the training set. Induction is the reasoning from observed training instances to general rules, which are then applied to test instances; in this task, it means that nodes appearing in the test set that have not appeared in the training set.

[0046] S103. Train the model based on the training set to obtain an initial graph representation model, and test and validate the initial graph representation model based on the test set and validation set to obtain the final graph representation model.

[0047] S104, obtain the dynamic graph to be processed, and output the node representation vectors corresponding to the nodes in the dynamic graph to be processed through the final graph representation model.

[0048] The final diagram can represent the model in various ways.

[0049] In some embodiments, such as Figure 2 As shown, the final graph representation model includes an encoder, a continuous inference module, a graph attention layer, and a decoder. The encoder projects the features of nodes into a shallow space to obtain the initial hidden representation of the nodes. The continuous inference module generates the state trajectory of nodes within a preset time interval based on structural data, node features, and edge features. The graph attention layer aggregates the historical interaction information of nodes to predict the future representation of interactive nodes. The decoder decodes the encoded data.

[0050] In some embodiments, the initial hiding representation is expressed by the following formula:

[0051]

[0052] in, This represents the initial hidden representation. This represents the node embedding vector of the current node. This represents the embedding vector of the current node corresponding to the previous interacting node. F represents the information characteristics of the previous interaction. T (Δt) represents the time interval Δt, || represents continuous operation, and f(·) represents the linear projection function, which is expressed by the following formula:

[0053] f(x) = xW + b

[0054] Where W and b represent learnable parameters;

[0055]

[0056] Among them, F T (t) represents the encoded time representation vector at time t. For trainable parameters, d T This represents the dimension of the vector space.

[0057] Specifically, an encoder-decoder architecture is adopted. For each interaction, the encoder module first projects the relevant features of the interaction node into a shallow space to generate the initial hidden representation of the node. This representation is then fed into the model to learn the node representation, and finally fed into the decoder to complete different downstream tasks. Before entering the encoder, the previous interaction node r of all nodes v∈V is first initialized. v and the interaction time τ v

[0058] In the encoder module, to extract the temporal features of each interaction, the timestamps of the interactions are projected onto a continuous temporal space. A time encoding function is used to obtain a time-domain representation of the interaction. T Continuous mapping function F in a dimensional vector space T :

[0059]

[0060] in, All of these are trainable parameters. In order to learn t p A node representation with structural information at every moment, and a node embedding vector connecting each node. The embedding vector of its last interaction node Features of the last interaction The time representation of F with time interval Δt T(Δt), as the new node feature, is used here because this paper mainly focuses on the time interval from the last interaction to the current interaction. Therefore, the embedding vector of the time interval Δt is learned as the time feature representation of the current interaction. A fully connected layer is used as the encoder, and the new node feature is input into the encoder. The resulting hidden representation is defined as follows:

[0061]

[0062] Where || denotes the join operation, and f(·) denotes a linear projection function:

[0063] f(x) = xW + b#

[0064] Here, W and b are both learnable parameters. The final encoding yields the hidden representation.

[0065] The decoder is designed with different network layers for different tasks. For time link prediction and time node recommendation tasks, the decoder is a 2-layer MLP; for node classification tasks, the decoder is a 3-layer MLP.

[0066] In some embodiments, the state trajectory is expressed by the following formula:

[0067]

[0068] in, This represents the interaction information between nodes at time t. and These are three gates that respectively control the degree of influence of the three factors;

[0069]

[0070] Among them, W l W n W i and b l ,b n ,b i All of these are trainable parameters, and σ(·) represents the Sigmoid activation function that maps the output range to [0,1].

[0071] Specifically, in the continuous inference module, to capture the continuous dynamics of node representations, the algorithm introduces three factors—the most recent interaction information, neighbor characteristics, and the node's inherent attributes—to define a differential equation. A Neural ODE solver is then used to solve this equation, generating the node's state trajectory over the time interval [0, Δt]. In this way, the algorithm in this chapter can estimate the approximate direction of change in the node's state trajectory, especially for inactive nodes.

[0072] The main objective of this module is to track the latest state changes of nodes. Therefore, for each node u in the temporal interaction graph G, the algorithm selects u and the node r with which it most recently interacted. u It is divided into an interaction set ε p And generate an adjacency matrix S p ∈R |V|×|V| To describe the relationships between nodes, the adjacency matrix S p The definition is as follows:

[0073]

[0074] The degree of each node in the graph is different. To avoid affecting the subsequent training process, this paper normalizes the adjacency matrix to... in, It is the adjacency matrix S p The degree matrix. The learning process involves the eigenvalue decomposition of the normalized adjacency matrix, and the eigenvalues ​​are typically in the range [-1, 1]. To obtain positive eigenvalues ​​and make the algorithm more stable during training, the following regularization matrix A is used. p Describe the graph structure:

[0075]

[0076] Where β∈(0,1) is a hyperparameter, I N ∈R |V|×|V| Since it is an identity matrix, the normalized adjacency matrix A is... p The eigenvalues ​​of the adjacency matrix (hereinafter referred to as the adjacency matrix) range from [0, β].

[0077] Then, to capture the complex nonlinear dynamic changes in node embedding vectors, we assume three factors may influence node state changes: 1) the most recent interaction information revealing the node's latest state; 2) features of neighbors that have interacted with the node directly or indirectly; and 3) the inherent characteristics of the node that determine the influence of the above two factors on the node state. Based on these considerations, this paper integrates these three factors in the interaction set ε. p An ordinary differential equation is defined to solve for the changing trajectory of the node embedding vector. Here, this chapter will present the output of the encoder module. As the initial value of ODE Right now Then, a differential equation is defined to learn the continuous node representations between two interaction intervals, and this differential equation is defined as follows:

[0078]

[0079] in, This indicates the node's most recent interaction information. This indicates the influence of neighbors on the current node's state. This represents the inherent characteristics of a node. Furthermore, this state-aware differential equation can also be viewed as a continuous version of the propagation of node states in diffusion-based methods (such as PageRank).

[0080] Considering that nodes are influenced by different factors to varying degrees at different times—for example, during periods of frequent interaction, nodes are more significantly affected by recent interactions and relatively less affected by neighbor characteristics and inherent attributes, while the opposite is true during periods of sparse interaction—this paper adaptively integrates these three factors. Based on a gating mechanism, three gates are set to learn the importance of each of the three factors, and the influence of these three factors on the node state is controlled according to their importance, resulting in a state-aware differential equation:

[0081]

[0082] Here, ⊙ represents the element-wise multiplication operation at the corresponding position. and The three gates, representing the degree of influence of the three factors, are calculated as follows:

[0083]

[0084] Among them, W l W n W i and b l ,b n ,b i All parameters are trainable, and σ(·) represents the Sigmoid activation function that maps the output range to [0,1]. This gated fusion mechanism calculates three gates controlling the importance of each of the three factors using the initial value of the ODE, thereby adaptively fusing the three factors according to their importance. Furthermore, this paper uses the previous interaction information to update the embedding vector of the node at the time of the current interaction, and saves the information of the current interaction for learning the node representation when the next node appears. This update method conforms to the temporal logic of the interaction, i.e., the update module begins at the time of the previous interaction and ends at the time of the current interaction; on the other hand, it allows the update module to directly participate in the loss calculation, thus enabling timely updates of the module parameters through backpropagation. Simultaneously, since the temporal information is encoded in the initial value, the temporal pattern of the node state can also be captured. In summary, based on the differential equation defined above, this paper captures the continuous dynamic changes of the node representation through the joint use of the above three factors, and then uses Neural ODE to solve the state trajectory of the node in the interval [0,Δt], thus obtaining the state at the end of the solver:

[0085]

[0086] in, The state-aware differential equation is defined by formula (7).

[0087] Finally, use the state at the end of the Neural ODE. To update the embedding vector of the current interaction node u, Updated to

[0088] In some embodiments, the future is represented by the following formula:

[0089]

[0090] in, Let k represent the future representation of node u, and k represent the number of its neighbors. j The attention score represents the influence of neighboring node j on node u.

[0091]

[0092] in,

[0093] d represents the dimension of the node representation vector, and q represents the query in the attention mechanism. t key K t and value V t The definition is as follows:

[0094]

[0095] Among them, W Q W K W V Represents the weight matrix. Let u be the representation vector of node u. The representation vector of the neighboring nodes of node u.

[0096] Specifically, in the continuous inference module, the model uses the interaction data closest to the current interaction to capture the continuous dynamics of the node representation and obtain the latest information of the node. However, it ignores the influence of historical interaction information on the node state. Therefore, this paper sets up a transfer module after the update module, which uses a self-attention mechanism to selectively aggregate the historical interaction information of the node and transfer the historical interaction features observed by the node to the future to generate future representations. On the one hand, this realizes the prediction of future states based on historical states and current states. On the other hand, it solves the problem of state trajectory deviation caused by the update module only using the most recent interaction information and ignoring historical interaction information.

[0097] In the transfer module, for the interaction e generated by nodes u and i at time t, the temporal neighbors of the interacting nodes u and i and the interaction information (interaction features and interaction time) between them and their temporal neighbors are selected as inputs. Then, the self-attention mechanism is introduced to differentially aggregate different temporal neighbors for u and i respectively to predict the future representations of u and i, which takes into account both the structural information and the time information of the temporal interaction graph. The neighbors of node u at time t, N(u,t) = {i0,…,i k-1}, are defined as the set of nodes that have interacted with node u before time t. For example, i j ∈N(u,t) is a node that has interacted with node u at time t j , where t j <t. Based on the above definitions, first, k temporal neighbors of node u are sampled, and the sampling process of the temporal neighbors of node i is the same as that of u. Then, the node representation with time t encoded and the neighbor information j with time difference t - t encoded are used as inputs to the attention mechanism. Here, the time difference corresponds to the current interaction time t of node u and the interaction time t j of node u and its historical neighbor node i j , that is, t - t j . In the attention mechanism, query Q t , key K t and value V t are obtained through three different linear projection operations, and the specific formulas are as follows:

[0098] [[ID=�0]]

[0099] where W Q , W K , W V are weight matrices. Then, the attention score α j is calculated as follows:

[0100]

[0101] Here, in the topological structure with interaction time information, the attention score α j reflects the influence degree of the temporal neighbor i j of node u on u. Therefore, the output of this layer is the time-aware representation of node u at time t, and it also represents the future representation of the node generated by the historically observed interactions, that is:

[0102]

[0103] Furthermore, to stabilize the learning process and improve model performance, the model extends its attention mechanism to a multi-head attention mechanism. Specifically, it uses M different projection operations to learn node representations in parallel, and then concatenates the learned results:

[0104]

[0105] Among them, V t (m) This represents the projection result of the attention of the m-th head. This represents the attention score calculated for different queries and keys in the m-th head attention.

[0106] Finally, by calculating for each node in the interaction set To generate future representations of nodes And the most recent interaction node r between nodes u and i u and r i Update them to i and u respectively, and update the interaction time to t for both. p .

[0107] By minimizing a time-sensitive binary cross-entropy loss function, the backpropagation algorithm is used to learn the model's parameters. For each node, nodes that interact with it are treated as positive samples, and nodes that do not interact with it are negative samples. The learning objective is to shorten the distance between positive samples and widen the distance between negative samples. The loss function is defined as follows:

[0108]

[0109] The accumulation operation occurs in the interactive sequence (u p i p ,t p set, i q For the corresponding u p Negative samples generated by negative sampling This indicates the number of interactions for negative sampling. It is the distribution that negative sampling follows in the node space.

[0110] In addition, it should be noted that after the node representation vector is output by the trained final graph representation model, different downstream tasks can be completed: for example, (1) the essence of the time link prediction task is a binary classification problem, that is, given two nodes and a certain time, determine whether the two interact at that time; (2) the essence of the time node recommendation task is a ranking problem, that is, given a node and a certain time, predict the most likely k neighbors of the current node at that time; (3) the essence of the dynamic node classification task is also a classification problem, that is, given two interacting nodes and their interaction time, predict the state label of an interacting node at the current time.

[0111] In summary, the continuous temporal interaction graph representation method according to embodiments of the present invention firstly acquires original dynamic graph data and preprocesses the original dynamic graph data to obtain structural data, node features, and edge features; then, the structural data, node features, and edge features are divided according to a preset ratio to generate a training set, a test set, and a validation set; then, the model is trained based on the training set to obtain an initial graph representation model, and the initial graph representation model is tested and validated based on the test set and the validation set to obtain a final graph representation model, acquiring the dynamic graph to be processed, and outputting the node representation vectors corresponding to the nodes in the dynamic graph to be processed through the final graph representation model; thereby effectively capturing the continuous dynamics of node representations and learning their state trajectories, thus effectively improving the representation ability of inactive nodes and the prediction effect of long-interval interactions.

[0112] To implement the above embodiments, this invention proposes a computer-readable storage medium storing a continuous timing interaction graph representation program thereon, which, when executed by a processor, implements the continuous timing interaction graph representation method as described above.

[0113] According to an embodiment of the present invention, a computer-readable storage medium stores a continuous temporal interaction graph representation program, so that when a processor executes the continuous temporal interaction graph representation program, it implements the continuous temporal interaction graph representation method as described above, thereby effectively capturing the continuous dynamics of node representation and learning its state trajectory, thereby effectively improving the representation capability of inactive nodes and the prediction effect of long-interval interactions.

[0114] Those skilled in the art will understand that embodiments of the present invention can be provided as methods, systems, or computer program products. Therefore, the present invention can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present invention can take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0115] This invention is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart illustrations and / or block diagrams. Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0116] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0117] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0118] It should be noted that any reference signs placed between parentheses in the claims should not be construed as limiting the claims. The word "comprising" does not exclude the presence of components or steps not listed in the claims. The word "a" or "an" preceding a component does not exclude the presence of a plurality of such components. The invention can be implemented by means of hardware comprising several different components and by means of a suitably programmed computer. In a unit claim enumerating several means, several of these means may be embodied by the same item of hardware. The use of the words first, second, and third, etc., does not indicate any order. These words can be interpreted as names.

[0119] Although preferred embodiments of the invention have been described, those skilled in the art, upon learning the basic inventive concept, can make other changes and modifications to these embodiments. Therefore, the appended claims are intended to be interpreted as including both the preferred embodiments and all changes and modifications falling within the scope of the invention.

[0120] Obviously, those skilled in the art can make various modifications and variations to this invention without departing from its spirit and scope. Therefore, if these modifications and variations fall within the scope of the claims of this invention and their equivalents, this invention also intends to include these modifications and variations.

[0121] In the description of this invention, it should be understood that the terms "first" and "second" are used for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the number of indicated technical features. Therefore, a feature defined as "first" or "second" may explicitly or implicitly include one or more of that feature. In the description of this invention, "a plurality of" means two or more, unless otherwise explicitly specified.

[0122] In this invention, unless otherwise explicitly specified and limited, the terms "installation," "connection," "linking," and "fixing," etc., should be interpreted broadly. For example, they can refer to a fixed connection, a detachable connection, or an integral part; they can refer to a mechanical connection or an electrical connection; they can refer to a direct connection or an indirect connection through an intermediate medium; they can refer to the internal communication of two components or the interaction between two components. Those skilled in the art can understand the specific meaning of the above terms in this invention according to the specific circumstances.

[0123] In this invention, unless otherwise explicitly specified and limited, "above" or "below" the second feature can mean that the first feature is in direct contact with the second feature, or that the first feature is in indirect contact with the second feature through an intermediate medium. Furthermore, "above," "over," and "on top" of the second feature can mean that the first feature is directly above or diagonally above the second feature, or simply that the first feature is at a higher horizontal level than the second feature. "Below," "below," and "beneath" of the second feature can mean that the first feature is directly below or diagonally below the second feature, or simply that the first feature is at a lower horizontal level than the second feature.

[0124] In the description of this specification, the references to terms such as "one embodiment," "some embodiments," "example," "specific example," or "some examples," etc., indicate that a specific feature, structure, material, or characteristic described in connection with that embodiment or example is included in at least one embodiment or example of the present invention. In this specification, the illustrative expressions of the above terms should not be construed as necessarily referring to the same embodiment or example. Furthermore, the specific features, structures, materials, or characteristics described may be combined in any suitable manner in one or more embodiments or examples. Moreover, without contradiction, those skilled in the art can combine and integrate the different embodiments or examples described in this specification, as well as the features of different embodiments or examples.

[0125] Although embodiments of the present invention have been shown and described above, it is understood that the above embodiments are exemplary and should not be construed as limiting the present invention. Those skilled in the art can make changes, modifications, substitutions and variations to the above embodiments within the scope of the present invention.

Claims

1. A method of representing a continuous-time interaction graph, characterized by, The method comprises the following steps: obtaining original dynamic graph data and preprocessing the original dynamic graph data to obtain structure data, node features and edge features; dividing the structure data, the node features and the edge features according to a preset ratio to generate a training set, a test set and a validation set; training a model according to the training set to obtain an initial graph representation model, and testing and verifying the initial graph representation model according to the test set and the validation set to obtain a final graph representation model; obtaining a dynamic graph to be processed and outputting a node representation vector corresponding to a node in the dynamic graph to be processed through the final graph representation model; The final graph representation model comprises an encoder, a continuous inference module, a graph attention layer and a decoder. The encoder is configured to project features of the node to a shallow space to obtain an initial hidden representation of the node. The continuous inference module is configured to generate a state trajectory of the node within a preset time interval according to the structure data, the node features and the edge features. The graph attention layer is configured to aggregate historical interaction information of the node to predict a future representation of an interaction node. The decoder is configured to decode encoded data. The state trajectory is expressed by the following formula: wherein, represents the interaction information of the node at time, and respectively represent three gates that control the influence degree of the three factors; wherein, and are trainable parameters, denotes a Sigmoid activation function mapping the range of the output to . The future representation is expressed by the following formula: wherein, representing a node future representations of, representing a number of neighbors, representing a neighbor node of a reacting node attention score of a node influencing; wherein, denotes the dimension of the node representation vector, query , key and value are defined as follows: wherein, denotes a weight matrix, denotes a node a representation vector of a node, denotes a representation vector of a neighbor node of a node a representation vector of a neighbor node of a node 2. The continuous-time interaction graph representation method of claim 1, wherein, The preprocessing of the original dynamic graph data comprises: determining whether the time label and the node label in the original dynamic graph data are abnormal, and processing the abnormality when the determination result is yes; sorting the interactions in the original dynamic graph data according to the time label, and re-encoding the nodes and edges in the original dynamic graph data according to the sorting result; splitting the re-encoded data to obtain structure data, node features and edge features.

3. The continuous-time interaction graph representation method of claim 1, wherein, The initial hidden representation is expressed by the following formula: wherein, denotes an initial hidden representation, denotes a node embedding vector of the current node, denotes an embedding vector of the current node corresponding to the last interaction node, denotes information features of the last interaction, is a time interval denotes a time representation, denotes a sequential operation, denotes a linear projection function, which is formulated by the following equation: wherein, and denote learnable parameters; wherein, denotes a time representation vector of the encoded t-time, are trainable parameters, denotes the dimension of the vector space.

4. The continuous-time interaction graph representation method of claim 1, wherein, After generating the training set, the test set and the validation set, the method further comprises: obtaining relevant node information corresponding to the training set, and dividing the test set and the validation set into a transduction test set, a transduction validation set, an induction test set and an induction validation set according to the relevant node information.

5. A computer readable storage medium, characterized in that, A continuous time sequential interaction graph representation program is stored thereon, and the continuous time sequential interaction graph representation program is executed by a processor to implement the continuous time sequential interaction graph representation method according to any one of claims 1-4.

Images