Twin node-based graph data time series processing method, device, equipment and medium

Abstract

The application is suitable for the technical field of graph data processing, and particularly relates to a graph data time sequence processing method and device based on twin nodes, equipment and a medium. The application obtains an insurance graph database, traverses nodes in the insurance graph database, obtains n event nodes connected with one static node through original relationship edges, replicates the n event nodes to generate n twin event nodes, replicates the static node A to generate n twin static nodes, constructs relationship edges according to certain relationships, and only expands a limited number of nodes through the twin nodes, effectively expands the data storage amount of different time sequence time points, the time sequence of each node is clear, and in the case of hundreds of millions of massive data, the efficiency of traversing popular nodes in a specific time period is improved, and the service response delay is reduced.

Description

Technical Field

[0001] This invention relates to the field of graph data processing technology, and in particular to a method, apparatus, device, and medium for time-series processing of graph data based on twin nodes. Background Technology

[0002] In recent years, with the continuous improvement of the digitalization, online presence, and intelligence of the insurance business, insurance operations are increasingly reliant on graph databases and related algorithm engines in sales, operations, and risk control. For example, applying knowledge graphs to process data such as insured's browsing behavior and order records can create a comprehensive, three-dimensional profile of the insured during the marketing process, thereby improving the coverage and conversion rate of online precision marketing. Furthermore, in the claims process, to combat organized fraud, in addition to traditional manual fraud verification methods, the introduction of graph analytics and other technologies in the era of big data can uncover hidden criminal groups and tools, thus reducing unnecessary claims costs for insurance companies.

[0003] To achieve the aforementioned business functions and intelligent algorithms, an essential step is to transform and store the existing business data, stored in a table-like format in the core insurance system or other peripheral systems, into a graph format using a graph database component. The general approach for this step is as follows: 1) Design the graph database schema in advance based on the business scenario, standardizing the node types, relationship types, and attribute fields stored in the graph database; 2) Clean and transform the original table-like data using data warehouse technology (Extract-Transform-Load, ETL) tools and import it into the graph database; 3) Design the relevant application functions, such as graph query, association analysis, and community discovery, and build application programming interface (API) services based on the graph database.

[0004] like Figure 1 The image shows an existing claims graph data structure. In this graph database, a policy corresponds to a "policy" node, and a case corresponds to a "case" node. There may be an "occurrence" relationship between policy and case nodes. However, this graph data does not reflect temporal relationships. To reflect temporal relationships, a common practice is to add a time attribute to the nodes or relationships, such as... Figure 2 The image shown is a schematic diagram of the graph data before processing. However, given the rapid expansion of insurance business data volume, this graph data structure results in a large number of popular nodes in the graph database (such as long-term cooperating agencies, claims adjusters, or group policies with a high number of claims, i.e., Figure 2Node A in the example has a huge number of associated edges and nodes, and the time order is disordered, which leads to low query efficiency and large service response delay for popular nodes during a certain period of time. Summary of the Invention

[0005] Therefore, it is necessary to provide a method, apparatus, device, and medium for time-series processing of graph data based on twin nodes to address the above-mentioned technical problems, so as to solve the problem that the time sequence of graph data is disordered when using existing technologies for time-series processing, resulting in low query efficiency of popular nodes and large service response delays within a specific time period.

[0006] In a first aspect, embodiments of the present invention provide a graph data time-series processing method based on twin nodes, the graph data time-series processing method comprising:

[0007] Step 1: Obtain the insurance graph database, which includes: M static nodes, M≥1, and at least one event node associated with each static node, wherein the static nodes and the event nodes are connected by original relation edges;

[0008] Step 2: Randomly select one of the static nodes A, and obtain n event nodes B1, B2, ..., Bn that are connected to the static node A through the original relation edge, where n ≥ 1. The event nodes are arranged in the order of the events occurring.

[0009] Step 3: Copy the n event nodes to generate n twin event nodes B1t, B2t, ..., Bnt, where n≥1;

[0010] Step 4: Copy the static node A to generate n twin static nodes A1, A2, ..., An, where n≥1;

[0011] Step 5: If two adjacent event nodes meet preset conditions, construct a first relation edge between the two twin static nodes corresponding to the two adjacent event nodes to represent the change information of the static node; construct a second relation edge between the twin static node An, n≥1 and the twin event node B(n+1)t, n≥1 to represent the association relationship; construct a third relation edge between the twin static node An, n≥1 and the event node Bn, n≥1 to represent the information flow.

[0012] Step 6: Traverse the remaining M-1 static nodes and repeat steps 2 to 5 to obtain the target graph database.

[0013] Secondly, embodiments of the present invention provide a graph data time-series processing apparatus based on twin nodes, the graph data time-series processing apparatus comprising:

[0014] The graph database acquisition module is used to acquire an insurance graph database, which includes: M static nodes, M≥1, and event nodes associated with each static node, wherein the static nodes and the event nodes are connected by original relation edges;

[0015] The node traversal module is used to arbitrarily select one of the static nodes A and obtain n event nodes B1, B2, ..., Bn that are connected to the static node A through the original relation edge, where n≥1. The event nodes are arranged in the order of the events occurring.

[0016] The event node replication module is used to replicate the n event nodes to generate n twin event nodes B1t, B2t, ..., Bnt, where n≥1;

[0017] The static node copying module is used to copy the static node A to generate n twin static nodes A1, A2, ..., An, where n≥1;

[0018] The relation edge construction module is used to determine whether two adjacent event nodes meet preset conditions, and to construct a first relation edge between the two twin static nodes corresponding to the two adjacent event nodes to represent the change information of the static nodes; to construct a second relation edge between the twin static node An, n≥1 and the twin event node B(n+1)t, n≥1 for the association relationship; and to construct a third relation edge between the twin static node An, n≥1 and the event node Bn, n≥1 for the information flow.

[0019] The target database generation module is used to traverse the remaining M-1 static nodes and repeat steps 2 to 5 to obtain the target graph database.

[0020] Thirdly, embodiments of the present invention provide a computer device, the computer device including a processor, a memory, and a computer program stored in the memory and executable on the processor, wherein when the processor executes the computer program, it implements the graph data timing processing method based on twin nodes as described in the first aspect.

[0021] Fourthly, embodiments of the present invention provide a computer-readable storage medium storing a computer program that, when executed by a processor, implements the graph data timing processing method based on twin nodes as described in the first aspect.

[0022] The beneficial effects of this invention compared with the prior art are as follows: This invention replicates static nodes and event nodes to generate twin nodes arranged in chronological order, constructs relational edges according to certain relationships, and expands only a limited number of nodes through twin nodes, effectively expanding the data storage capacity at different time points. The time sequence of each node is clear, and in the case of massive data of hundreds of millions, it improves the efficiency of traversing popular nodes within a specific time period and reduces service response latency. Attached Figure Description

[0023] To more clearly illustrate the technical solutions in the embodiments of the present invention, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0024] Figure 1 It is a schematic diagram of a graph data structure in existing technology;

[0025] Figure 2 It is a schematic diagram of a graph data structure in existing technology;

[0026] Figure 3 This is a schematic diagram of the application environment of a graph data time-series processing method based on twin nodes provided in Embodiment 1 of the present invention;

[0027] Figure 4 This is a flowchart illustrating a graph data time-series processing method based on twin nodes provided in Embodiment 1 of the present invention;

[0028] Figure 5 This is a schematic diagram of a processed graph data structure provided in Embodiment 1 of the present invention;

[0029] Figure 6 This is a schematic diagram of the structure of a graph data time-series processing device based on twin nodes provided in Embodiment 2 of the present invention;

[0030] Figure 7 This is a schematic diagram of the structure of a computer device provided in Embodiment 3 of the present invention. Detailed Implementation

[0031] In the following description, specific details such as particular system architectures and techniques are set forth for illustrative purposes and not for limitation, in order to provide a thorough understanding of the embodiments of the invention. However, those skilled in the art will understand that the invention can be implemented in other embodiments without these specific details. In other instances, detailed descriptions of well-known systems, apparatuses, circuits, and methods are omitted so as not to obscure the description of the invention with unnecessary detail.

[0032] It should be understood that, when used in this specification and the appended claims, the term "comprising" indicates the presence of the described features, integrals, steps, operations, elements and / or components, but does not exclude the presence or addition of one or more other features, integrals, steps, operations, elements, components and / or collections thereof.

[0033] It should also be understood that the term “and / or” as used in this specification and the appended claims refers to any combination of one or more of the associated listed items and all possible combinations, and includes such combinations.

[0034] As used in this specification and the appended claims, the term "if" may be interpreted, depending on the context, as "when," "once," "in response to determination," or "in response to detection." Similarly, the phrase "if determined" or "if [described condition or event] is detected" may be interpreted, depending on the context, as meaning "once determined," "in response to determination," "once [described condition or event] is detected," or "in response to detection of [described condition or event]."

[0035] Furthermore, in the description of this invention and the appended claims, the terms "first," "second," "third," etc., are used only to distinguish descriptions and should not be construed as indicating or implying relative importance.

[0036] References to "one embodiment" or "some embodiments" as described in this specification mean that one or more embodiments of the invention include a specific feature, structure, or characteristic described in connection with that embodiment. Therefore, the phrases "in one embodiment," "in some embodiments," "in other embodiments," "in still other embodiments," etc., appearing in different parts of this specification do not necessarily refer to the same embodiment, but rather mean "one or more, but not all, embodiments," unless otherwise specifically emphasized. The terms "comprising," "including," "having," and variations thereof mean "including but not limited to," unless otherwise specifically emphasized.

[0037] It should be understood that the sequence number of each step in the following embodiments does not imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of the present invention.

[0038] To illustrate the technical solution of the present invention, specific embodiments are described below.

[0039] The first embodiment of this invention provides a graph data time-series processing method based on twin nodes, which can be applied to, for example... Figure 3In this application environment, the client communicates with the server. Clients include, but are not limited to, handheld computers, desktop computers, laptops, ultra-mobile personal computers (UMPCs), netbooks, cloud computing devices, and personal digital assistants (PDAs). The server can be implemented using a standalone server or a server cluster consisting of multiple servers.

[0040] See Figure 4 This is a flowchart illustrating a graph data time-series processing method based on twin nodes provided in Embodiment 1 of the present invention. The aforementioned graph data time-series processing method based on twin nodes can be applied to… Figure 3 The client, corresponding to a computer device, connects to the server via the internet and uses a pre-defined Application Programming Interface (API) to access the server's original insurance chart database and retrieve data from it. For example... Figure 4 As shown, the graph data time-series processing method based on twin nodes may include the following steps:

[0041] Step 1: Obtain the insurance graph database, which includes: M static nodes, M≥1, and at least one event node associated with each static node. The static nodes and the event nodes are connected by original relation edges.

[0042] In this invention, the first step is to obtain the original insurance graph database from the server. This insurance graph database stores M static nodes, M≥1, and several event nodes. The static nodes include policy nodes, person nodes, and vehicle nodes, while the dynamic nodes include case nodes. For dynamic nodes and static nodes that have an accident relationship, they are connected through the original relationship edge to obtain the insurance graph database, that is, to obtain the insurance graph data network relationship.

[0043] For example, such as Figure 1 The diagram shows an existing graph data structure storing an insurance relationship network. This graph data contains static nodes and event nodes. Nodes A and B represent static nodes, i.e., person nodes, while Case 1 and Case 2 represent event nodes. Static nodes A and B have claims relationships with Case 1 and Case 2, respectively, connected by claims relationship edges. These relationship edges represent the circumstances of the case occurrence. However, this insurance relationship network graph data cannot reflect temporal relationships. Obtaining an insurance graph database means obtaining M graphs storing similar... Figure 1 Insurance graph data of the insurance relationship network.

[0044] Step 2: Select any one of the static nodes A, and obtain n event nodes B1, B2, ..., Bn that are connected to the static node A through the original relation edge, where n ≥ 1. The event nodes are arranged in the order of the events occurring.

[0045] The insurance graph database is obtained through step 1. This insurance graph database contains M static nodes. Traverse the M static nodes in the graph database, select one static node A, and traverse the n event nodes B1, B2, ..., Bn connected to the static node A through the original relation edge, where n≥1. The original relation edge indicates that the connected event nodes B1, B2, ..., Bn have an event relationship with the static node A.

[0046] For example, such as Figure 5 The graph data structure shown represents event nodes connected to static node A through original relation edges. Static node A can be a car insurance policy node, representing a car insurance policy. B1, B2, and B3 are case nodes that have had an accident relationship with car insurance node A. The case nodes B1, B2, and B3 are arranged from top to bottom in the order of the occurrence of the cases. t1 represents the time point when case B1 occurred, t2 represents the time point when case B2 occurred, and t3 represents the time point when case B3 occurred.

[0047] Step 3: Copy the n event nodes to generate n twin event nodes B1t, B2t, ..., Bnt, where n≥1.

[0048] Step 2 above iterates through n event nodes B1, B2, ..., Bn that have had an accident relationship with static node A. The n event nodes B1, B2, ..., Bn are copied to generate n twin event nodes B1t, B2t, ..., Bnt corresponding to the n event nodes. The n twin event nodes are distributed in parallel with their respective event nodes, corresponding to the time points when the event nodes occurred.

[0049] For example, such as Figure 5 The graph data structure shown generates a twin case node B1t after copying case node B1, a twin case node B2t after copying case node B2, and a twin case node B3t after copying case node B3. The twin case nodes B1t, B2t, and B3t correspond to the case nodes B1, B2, and B3 and are distributed in parallel with the case nodes.

[0050] In this invention, for the replicated twin event node, the attributes of the corresponding time node are retained. These attributes include the time when the event node occurred, the location of the event corresponding to the event node, the personnel involved in the case, etc. The information contained in the replicated twin event node is the same as that contained in the event node, which can be understood as a complete copy of the event node.

[0051] For example, such as Figure 5 The graph data structure shown indicates that the case represented by case node B1 occurred on January 1, 2022, in Shanghai, and involved Zhang San and Li Si. The twin case node B1t generated by copying case node B1 also contains the above information, that is, the twin case node B1t represents the case occurring in Shanghai, and involves Zhang San and Li Si.

[0052] Step 4: Copy the static node A to generate n twin static nodes A1, A2, ..., An, where n ≥ 1.

[0053] Step 2 above iterates through and obtains n event nodes B1, B2, ..., Bn that have had an accident relationship with static node A. For each of the n event nodes B1, B2, ..., Bn, there is a corresponding twin static node. The twin static nodes A1, A2, ..., An are copied from static node A, and twin static node A1 corresponds to event node B1, twin static node A2 corresponds to event node B2, and twin static node An corresponds to event node Bn.

[0054] In this invention, after replicating the static node A to generate n twin static nodes A1, A2, ..., An, where n≥1, the graph data time-series processing method further includes the following steps:

[0055] Import the timestamps and attribute data of the case occurrence times corresponding to the twin event nodes B1t, B2t, ..., Bnt into the twin static nodes A1, A2, ..., An corresponding to the twin event nodes B1t, B2t, ..., Bnt. The attribute data includes the remaining policy validity period and the policyholder's age at the case occurrence times corresponding to different twin event nodes B1t, B2t, ..., Bnt.

[0056] For example, such as Figure 5The graph data structure shown has the following relationships: twin static node A1 represents the car insurance policy and event node B1 represents the accident occurrence, with the time of event B1 being t1; twin static node A2 represents the car insurance policy and event node B2 represents the accident occurrence, with the time of event B2 being t2; twin static node A3 represents the car insurance policy and event node B3 represents the accident occurrence, with the time of event B3 being t3. Therefore, the time t1 of event B1 needs to be set to the twin static node time of twin static node A1, the time t2 of event B2 needs to be set to the twin static node time of twin static node A2, and the time t3 of event B3 needs to be set to the twin static node time of twin static node A3.

[0057] In this invention, after copying the static node A to generate n twin static nodes A1, A2, ..., An, where n≥1, the following steps are also included:

[0058] Import the attribute data of the twin event nodes B1t, B2t, ..., Bnt corresponding to the twin static nodes A1, A2, ..., An into the node attributes of the twin static nodes A1, A2, ..., An. The attribute data includes the remaining validity period of the policy and the age of the policyholder on the corresponding twin event nodes.

[0059] The above steps replicate static node A to obtain static twin nodes A1, A2, ..., An. When the twin event nodes B1t, B2t, ..., Bnt corresponding to the twin static nodes A1, A2, ..., An occur, the remaining validity period of the car insurance policy represented by the static nodes A1, A2, ..., An is imported into the corresponding static nodes A1, A2, ..., An.

[0060] For example, such as Figure 5 In the graph data structure shown, when the twin event node B1t represents a case, the remaining validity period of the car insurance policy represented by the corresponding static twin node A1 is 89 days, so the remaining validity period of the car insurance policy of 89 days is written into static node A1; when the twin event node B2t represents a case, the remaining validity period of the car insurance policy represented by the corresponding static twin node A3 is 43 days, so the remaining validity period of the car insurance policy of 43 days is written into static node A2; when the twin event node B3t represents a case, the remaining validity period of the car insurance policy represented by the corresponding static twin node A3 is 11 days, so the remaining validity period of the car insurance policy of 11 days is written into static node A3; when the event represented by the twin event node occurs, the age of the policyholder of the car insurance policy represented by the corresponding static twin node is also written into the twin static node.

[0061] Step 5: If two adjacent event nodes meet the preset conditions, construct a first relation edge between the two twin static nodes corresponding to the two adjacent event nodes to represent the change information of the static nodes; construct a second relation edge between the twin static node An, n≥1 and the twin event node B(n+1)t, n≥1 to represent the association relationship; and construct a third relation edge between the twin static node An, n≥1 and the event node Bn, n≥1 to represent the information flow.

[0062] The above steps replicate one of the M static nodes in the obtained insurance graph database, as well as the event node connected to this static node through the accident relationship edge, to obtain their respective twin nodes.

[0063] In this invention, new relational edges need to be constructed for the aforementioned replicated twin static nodes, event nodes, and twin event nodes. For twin static nodes A1, A2, ..., An, where n≥1, a first relational edge, namely the X edge, is constructed. The specific construction method is as follows:

[0064] Obtain the occurrence time of events corresponding to two adjacent twin event nodes, calculate the time difference between the occurrence of events corresponding to two adjacent twin event nodes, and if the time difference between the occurrence of events corresponding to two adjacent twin event nodes is less than a set threshold, construct a first relation edge between the two twin static nodes corresponding to the two adjacent event nodes.

[0065] In this invention, to reduce the number of relationships between twin static nodes, the maximum value of the time window between two adjacent twin static nodes can be set according to actual needs, i.e., a threshold is set. Then, the time of the event represented by the twin event node Bnt, n≥1 is obtained, and the time of the event represented by the twin event node B(n+1)t, n≥1 is obtained. The time of the event represented by the twin event node B(n+1)t, n≥1 is subtracted from the time of the event represented by the twin event node Bnt, n≥1 to obtain the time difference between the two adjacent twin event nodes. If the time difference is less than the set threshold, a first relationship edge, i.e., the X edge, is constructed between the twin static node An, n≥1 and the twin static node An+1, n≥1.

[0066] In this invention, the first relation edge can also be constructed using the following method:

[0067] Obtain the remaining policy validity period corresponding to the twin static node An, n≥1, and obtain the remaining policy validity period corresponding to the twin static node An+1, n≥1. Subtract the remaining policy validity period corresponding to the twin static node An, n≥1 from the remaining policy validity period corresponding to the twin static node An+1, n≥1 to obtain the difference between the remaining policy validity periods of two adjacent twin static nodes. If the difference is less than a set threshold, construct the first relation edge, i.e., the X edge, between the twin static node An, n≥1 and the twin static node An+1, n≥1.

[0068] In this invention, a second relation edge is constructed between the twin static node An, n≥1 and the twin event node B(n+1)t, n≥1. The second relation edge is used to associate the relationship between the twin static node An, n≥1 and the twin event node B(n+1)t, n≥1. A third relation edge is constructed between the twin static node An, n≥1 and the event node Bn, n≥1. The third relation edge is used for information flow between the twin static node An, n≥1 and the event node Bn, n≥1.

[0069] In this invention, the first relation edge is a one-way relation, which is from the twin static node An to the twin static node An+1, where n≥1; the dynamic information change between twin static nodes is controlled by the X relation edge and the time window, that is, the dynamic change information can be represented on the X relation edge.

[0070] In this invention, the second relation edge is a one-way relation, which is a direct link from the twin static node An to the twin event node B(n+1)t, where n≥1.

[0071] In this invention, the third relation edge is a bidirectional relation, which is from the twin static node An to the event node Bn, and from the event node Bn to the twin static node An, where n≥1.

[0072] For example, such as Figure 5 The graph data structure shown has twin static nodes A1, A2, and A3 connected by a unidirectional X edge, twin static nodes connected to their corresponding twin event nodes connected by a unidirectional Y edge, and twin static nodes connected to their corresponding event nodes connected by a bidirectional Z edge. The dynamic change information from car insurance policy A1 to car insurance policy A2 is represented on the X relationship edge between car insurance policy A1 and car insurance policy A2. The temporal sequence of each node in this graph data structure is very clear.

[0073] The dynamic information changes of the twin static node An are controlled by the X relation edge and its time window. Meanwhile, the twin static node An and event node Bn at the same time point are connected by a bidirectional relation Z, ensuring the free flow of information from various twin static nodes. Furthermore, when we need to model the occurrence of the twin event node Bnt using graph deep learning or association analysis, we only need to consider its relationship Y with the twin static node A(n-1) at the previous time point, and the information of its preceding nodes, without considering its association information with An. This method can isolate effective training data and prediction labels for the graph deep learning model.

[0074] Step 6: Traverse the remaining M-1 static nodes and repeat steps 2 to 5 to obtain the target graph database.

[0075] The above steps are for the time-series processing of static node A among the M static nodes in the graph database. For the remaining M-1 static nodes, it is only necessary to repeat steps 2 to 5 above to obtain the target graph database containing M static nodes.

[0076] In this invention, after obtaining the target graph database, the graph data time-series processing method further includes the following steps:

[0077] Obtain the number of twin static nodes in each group within a preset time period. If the number exceeds the preset hot node threshold, the static node corresponding to that group of twin static nodes is determined to be a hot node. Store all hot nodes to obtain a hot node database.

[0078] After obtaining the target graph database through the above steps, a popular node query can be performed. First, obtain the value of the twin static node n, and compare the obtained value of n with the preset popular node threshold. If the value of n is greater than the preset popular node threshold, the static node corresponding to the twin static node is determined to be a popular node. The popular node threshold can be adjusted according to the actual situation. Store all static nodes that meet the above conditions to generate a popular node database. When traversing popular nodes, it is only necessary to traverse the popular node database, which improves the traversal efficiency of popular nodes.

[0079] The graph data time-series processing method based on twin nodes in this invention has the following advantages:

[0080] This invention replicates static nodes and event nodes to generate twin nodes arranged in chronological order. Relationship edges are constructed according to certain relationships. By expanding only a limited number of nodes through twin nodes, the data storage capacity at different time points is effectively expanded. The time sequence of each node is clear, and even with massive amounts of data, it can quickly generate a popular node graph database. Traversing popular nodes can be performed only in the popular node graph database, effectively improving the efficiency of traversing popular nodes within a specific time period and reducing service response latency.

[0081] Regarding the graph data time-series processing method based on twin nodes in the above embodiments, Figure 6 A structural block diagram of the graph data time-series processing device based on twin nodes provided in Embodiment 2 of the present invention is shown. This device is applied to a computer device, which connects to a server via the Internet and accesses the original insurance graph database on the server side through a preset Application Programming Interface (API) to obtain the original insurance graph database data. For ease of explanation, only the parts relevant to the embodiments of the present invention are shown.

[0082] See Figure 6 The graph data time-series processing device based on twin nodes includes:

[0083] Graph database acquisition module 61 is used to acquire an insurance graph database, which includes: M static nodes, M≥1, and at least one event node associated with each static node. Static nodes and event nodes are connected by original relation edges.

[0084] The node traversal module 62 is used to arbitrarily select one of the static nodes A and obtain n event nodes B1, B2, ..., Bn connected to the static node A through the original relation edge, where n≥1, and the event nodes are arranged in the order of the events occurring.

[0085] Event node replication module 63 is used to replicate n event nodes to generate n twin event nodes B1t, B2t, ..., Bnt, where n≥1;

[0086] The static node copying module 64 is used to copy the static node A to generate n twin static nodes A1, A2, ..., An, where n≥1;

[0087] The relation edge construction module 65 is used to determine whether two adjacent event nodes meet preset conditions, and to construct a first relation edge between the two twin static nodes corresponding to the two adjacent event nodes to represent the change information of the static nodes; to construct a second relation edge between the twin static node An, n≥1 and the twin event node B(n+1)t, n≥1 to represent the association relationship; and to construct a third relation edge between the twin static node An, n≥1 and the event node Bn, n≥1 to represent the information flow.

[0088] The target database generation module 66 is used to traverse the remaining M-1 static nodes and repeat steps 2 to 5 to obtain the target graph database.

[0089] Optionally, the static node replication module 64 mentioned above includes:

[0090] The static node attribute import unit is used to import the timestamps and attribute data of the case occurrence time points corresponding to the twin event nodes B1t, B2t, ..., Bnt into the twin static nodes A1, A2, ..., An corresponding to the twin event nodes B1t, B2t, ..., Bnt. The attribute data includes the remaining validity period of the policy and the age of the policyholder at the case occurrence time points corresponding to different twin event nodes B1t, B2t, ..., Bnt.

[0091] Optionally, the aforementioned relation edge construction module 65 includes:

[0092] The first relation edge construction unit is used for

[0093] Obtain the time of occurrence of the events corresponding to two adjacent twin event nodes, calculate the time difference of occurrence of the events corresponding to two adjacent twin event nodes, and if the time difference of occurrence of the events corresponding to two adjacent twin event nodes is less than a set threshold, construct a first relation edge between the two twin static nodes corresponding to the two adjacent event nodes.

[0094] The second relation edge construction unit is used to construct a second relation edge for association between twin static nodes An, n≥1 and twin event nodes B(n+1)t, n≥1.

[0095] The third relation edge construction unit is used to establish a bidirectional relationship between a twin static node An, n≥1 and an event node Bn, where the relationship is from twin static node An to event node Bn, and from event node Bn to twin static node An, n≥1.

[0096] Optionally, the above-mentioned graph data time-series processing device based on twin nodes further includes:

[0097] The popular node generation module is used to obtain the value of n among all twin static nodes within a preset time period. If the value of n is greater than the preset popular node threshold, the static node corresponding to the twin static node is determined to be a popular node. All popular nodes are stored to obtain the popular node database.

[0098] It should be noted that the information interaction and execution process between the above modules are based on the same concept as the method embodiments of the present invention. For details on their specific functions and technical effects, please refer to the method embodiments section, which will not be repeated here.

[0099] Figure 7 This is a schematic diagram of the structure of a computer device provided in Embodiment 4 of the present invention. Figure 7 As shown, the computer device of this embodiment includes: at least one processor ( Figure 7 Only one is shown in the diagram), a memory, and a computer program stored in the memory and executable on at least one processor. When the processor executes the computer program, it implements the steps in any of the above embodiments of the graph data timing processing method based on twin nodes.

[0100] This computer device may include, but is not limited to, a processor and memory. Those skilled in the art will understand that... Figure 7 The examples of computer devices are merely examples and do not constitute a limitation on computer devices. Computer devices may include more or fewer components than shown in the illustration, or combinations of certain components, or different components, such as network interfaces, displays, and input devices.

[0101] The processor referred to can be a CPU, but it can also be other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. A general-purpose processor can be a microprocessor or any conventional processor.

[0102] Memory includes readable storage media, internal memory, etc., wherein internal memory can be the RAM of a computer device, providing an environment for the operation of the operating system and computer-readable instructions stored in the readable storage media. The readable storage media can be the hard drive of a computer device, or in other embodiments, it can be an external storage device of the computer device, such as a plug-in hard drive, Smart Media Card (SMC), Secure Digital (SD) card, or Flash Card. Furthermore, memory can include both internal storage units and external storage devices of a computer device. Memory is used to store the operating system, applications, bootloader, data, and other programs, such as program code for computer programs. Memory can also be used to temporarily store data that has been output or will be output.

[0103] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the above-described division of functional units and modules is used as an example. In practical applications, the above functions can be assigned to different functional units and modules as needed, that is, the internal structure of the device can be divided into different functional units or modules to complete all or part of the functions described above.

[0104] The functional units and modules in the embodiments can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit. In addition, the specific names of each functional unit and module are only for easy distinction and are not intended to limit the scope of protection of the present invention.

[0105] The specific working processes of the units and modules in the above-described device can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here. If the integrated unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, all or part of the processes in the above-described embodiments of the present invention can be implemented by a computer program instructing related hardware. The computer program can be stored in a computer-readable storage medium, and when executed by a processor, it can implement the steps of the above-described embodiments of the graph data timing processing method based on twin nodes.

[0106] Computer programs include computer program code, which can be in the form of source code, object code, executable files, or certain intermediate forms. Computer-readable media can include at least: any entity or device capable of carrying computer program code, recording media, computer memory, read-only memory (ROM), random access memory (RAM), electrical carrier signals, telecommunication signals, and software distribution media. Examples include USB flash drives, portable hard drives, magnetic disks, or optical discs. In some jurisdictions, according to legislation and patent practice, computer-readable media cannot be electrical carrier signals or telecommunication signals.

[0107] The present invention can implement all or part of the processes in the above embodiments of the method, or it can be accomplished by a computer program product. When the computer program product is run on a computer device, the computer device executes the steps in the above embodiments of the graph data timing processing method based on twin nodes.

[0108] In the above embodiments, the descriptions of each embodiment have different focuses. For parts that are not described in detail or recorded in a certain embodiment, please refer to the relevant descriptions of other embodiments.

[0109] Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementations should not be considered beyond the scope of this invention.

[0110] In the embodiments provided by this invention, it should be understood that the disclosed apparatus / computer devices and methods can be implemented in other ways. For example, the apparatus / computer device embodiments described above are merely illustrative. For instance, the division of modules or units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the mutual coupling or direct coupling or communication connection shown or discussed may be through some interfaces; the indirect coupling or communication connection between apparatuses or units may be electrical, mechanical, or other forms.

[0111] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0112] The above-described embodiments are only used to illustrate the technical solutions of the present invention, and are not intended to limit it. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention, and should all be included within the protection scope of the present invention.

Claims

1. A method for time-series processing of graph data based on twin nodes, characterized in that, include: Step 1: Obtain the insurance graph database, which includes: M static nodes, M≥1, and at least one event node associated with each static node. The static nodes and the event nodes are connected by original relation edges. The static nodes include policy nodes, person nodes, and vehicle nodes. The event nodes include case nodes. For event nodes and static nodes that have an accident relationship, they are connected by the original relation edges. Step 2: Randomly select one of the static nodes A, and obtain n event nodes B1, B2, ..., Bn that are connected to the static node A through the original relation edge, where n ≥ 1. The event nodes are arranged in the order of the events occurring. Step 3: Copy the n event nodes to generate n twin event nodes B1t, B2t, ..., Bnt, where n≥1; the information contained in the copied twin event nodes is the same as the information contained in the corresponding event nodes; Step 4: Copy the static node A to generate n twin static nodes A1, A2, ..., An, where n≥1. The twin static nodes A1, A2, ..., An correspond sequentially to the event nodes B1, B2, ..., Bn. Import the timing information of the twin event nodes into the corresponding twin static nodes. Step 5: If two adjacent event nodes meet preset conditions, construct a first relation edge between the two twin static nodes corresponding to the two adjacent event nodes to represent the attribute change information of the twin static nodes; construct a second relation edge between the twin static node An, n≥1 and the twin event node B(n+1)t, n≥1 to establish an association relationship; construct a third relation edge between the twin static node An, n≥1 and the event node Bn, n≥1 to establish information flow; the dynamic information change of the twin static node An is controlled by the first relation edge and its time window; the twin static node An and the event node Bn at the same time point are connected by the third relation edge to ensure the free flow of various types of twin static node information; through the second relation edge of the twin static node An at the previous time point and its preceding node information, perform graph deep learning or association analysis modeling on the occurrence of the twin event node B(n+1)t. Step 6: Traverse the remaining M-1 static nodes and repeat steps 2 to 5 to obtain the target graph database.

2. The graph data time-series processing method based on twin nodes according to claim 1, characterized in that, After replicating the static node A to generate n twin static nodes A1, A2, ..., An, the graph data time-series processing method further includes: The timestamps and attribute data of the case occurrence times corresponding to the twin event nodes B1t, B2t, ..., Bnt are imported into the twin static nodes A1, A2, ..., An corresponding to the twin event nodes B1t, B2t, ..., Bnt. The attribute data includes the remaining policy validity period and the policyholder's age at the case occurrence times corresponding to different twin event nodes B1t, B2t, ..., Bnt.

3. The graph data time-series processing method based on twin nodes according to claim 1, characterized in that, If two adjacent event nodes meet a preset condition, constructing a first relation edge between the two twin static nodes corresponding to the two adjacent event nodes includes: Obtain the occurrence time of events corresponding to two adjacent twin event nodes, calculate the time difference between the occurrence of events corresponding to two adjacent twin event nodes, and if the time difference between the occurrence of events corresponding to two adjacent twin event nodes is less than a set threshold, construct a first relation edge between the two twin static nodes corresponding to the two adjacent event nodes.

4. The graph data time-series processing method based on twin nodes according to claim 3, characterized in that, The first relation edge is a one-way relation, which is a relation from the twin static node An to the twin static node An+1, where n≥1.

5. The graph data time-series processing method based on twin nodes according to claim 1, characterized in that, The second relation edge is a one-way relation, which is a direct link from the twin static node An to the twin event node B(n+1)t, where n≥1.

6. The graph data time-series processing method based on twin nodes according to claim 1, characterized in that, The third relation edge is a bidirectional relation, which is a relationship from the twin static node An to the event node Bn, and from the event node Bn to the twin static node An, where n≥1.

7. The graph data time-series processing method based on twin nodes according to claim 1, characterized in that, After obtaining the target graph database, the graph data time-series processing method further includes: The number of twin static nodes in each group within a preset time period is obtained. If the number is greater than the preset hot node threshold, the static node corresponding to the twin static node in that group is determined to be a hot node. All hot nodes are stored to obtain a hot node database.

8. A graph data time-series processing device based on twin nodes, characterized in that, The graph data time-series processing device based on twin nodes includes: The graph database acquisition module is used to acquire an insurance graph database, which includes: M static nodes, M≥1, and at least one event node associated with each static node. The static nodes and the event nodes are connected by original relation edges. The static nodes include policy nodes, person nodes, and vehicle nodes. The event nodes include case nodes. For event nodes and static nodes that have an accident relationship, they are connected by the original relation edges. The node traversal module is used to arbitrarily select one of the static nodes A and obtain n event nodes B1, B2, ..., Bn that are connected to one of the static nodes A through the original relation edge, where n≥1. The event nodes are arranged in the order of the events occurring. The event node replication module is used to replicate the n event nodes to generate n twin event nodes B1t, B2t, ..., Bnt, where n≥1; the information contained in the replicated twin event nodes is the same as the information contained in the corresponding event nodes; The static node replication module is used to replicate the static node A to generate n twin static nodes A1, A2, ..., An, where n≥1; and to import the timing information of the twin event nodes into the corresponding twin static nodes. The relation edge construction module is used to determine if two adjacent event nodes meet preset conditions, and then construct a first relation edge between the two twin static nodes corresponding to the two adjacent event nodes to represent the change information of the static node; construct a second relation edge between the twin static node An, n≥1 and the twin event node B(n+1)t, n≥1 for association; and construct a third relation edge between the twin static node An, n≥1 and the event node Bn, n≥1 for information flow; the dynamic information change of the twin static node An is controlled by the first relation edge and its time window; the twin static node An and the event node Bn at the same time point are connected by the third relation edge to ensure the free flow of various types of twin static node information; and perform graph deep learning or association analysis modeling on the occurrence of the twin event node B(n+1)t using the second relation edge of the twin static node An at the previous time point and its preceding node information. The target database generation module is used to traverse the remaining M-1 static nodes and repeat steps 2 to 5 to obtain the target graph database.

9. A computer device, characterized in that, The computer device includes a processor, a memory, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, it implements the graph data timing processing method based on twin nodes as described in any one of claims 1 to 7.

10. A computer-readable storage medium storing a computer program, characterized in that, When the computer program is executed by the processor, it implements the graph data timing processing method based on twin nodes as described in any one of claims 1 to 7.

Images