A knowledge graph-based associated account fund penetration analysis method

Abstract

The application relates to the technical field of knowledge graphs, in particular to a method for analyzing funds penetration of associated accounts based on a knowledge graph, which comprises the following steps: according to a received query instruction, extracting associated relationship edge metadata of a starting account node and a target account node in a graph database, and obtaining a penetration mode state transition configuration; gathering average degree statistics of various relationship types, mounting the average degree statistics to each state layer node of the penetration mode state transition configuration as a cost weight scalar, and generating a weighted state scheduling constraint benchmark. The application saves predecessor node identification and incoming relationship edge pointers through a track history record, can perform double-end backtracking after a homologous intersection node sequence appears, can eliminate suspended isolated nodes, can splice effective relationship edges and intermediate account nodes according to a connected order of the starting account node to the target account node, and can form a fund penetration associated link graph with less redundancy.

Description

Technical Field

[0001] This invention relates to the field of knowledge graph technology, and in particular to a method for analyzing the funds of related accounts based on knowledge graphs. Background Technology

[0002] Knowledge graph technology is a technology that uses entities, relationships, and attributes as core organizational units to structurally represent, integrate, manage, semantically reason about, and analyze relationships between real-world business objects and their interrelationships.

[0003] Existing knowledge graphs typically use entities, relationships, and attributes as basic organizational units, focusing on the structured representation, integrated management, semantic reasoning, and association analysis of business objects and their interrelationships. In practice, they tend to show the relationships between accounts and the attributes corresponding to a particular relationship edge. When the scale of account relationships is large, the hierarchy of fund flows is deep, and the account affiliation structure is overlapping, simply relying on the general representation of entity relationship attributes can easily place multiple types of relationships, such as fund transfers, affiliation control, and association with the same subject, into the same query space. This lacks state constraints, directional constraints, and branch cost constraints for penetration paths, which may lead to the simultaneous expansion of a large number of semantically irrelevant branches during the query process. For example, when there are multiple layers of intermediate accounts between the starting account and the target account, a large number of candidate paths will be generated around the densely related accounts. If only ordinary relationship connections are searched, it is easy to cause problems such as path number inflation, invalid nodes being mixed in, difficulty in timely removal of isolated nodes, and the real fund transmission links being submerged by redundant relationships, thereby increasing the pressure on manual verification. Therefore, improvements are needed. Summary of the Invention

[0004] The purpose of this invention is to address the shortcomings of existing technologies by proposing a knowledge graph-based method for analyzing the funds of related accounts.

[0005] To achieve the above objectives, the present invention adopts the following technical solution: a method for analyzing the funds of related accounts based on knowledge graphs, comprising the following steps: Based on the received query command, extract the metadata of the association between the starting account node and the target account node in the graph database, obtain the state transition configuration of the penetration mode, aggregate the average degree statistics of various relationship types, attach the average degree statistics to each state layer node of the state transition configuration of the penetration mode as cost weight scalar, and generate a weighted state scheduling constraint benchmark. Based on the weighted state scheduling constraint benchmark, the forward state cost and reverse state cost of the forward and backward cursors are read, and the bidirectional extended load difference is calculated. It is determined whether the bidirectional extended load difference is greater than the preset branch switching threshold. If so, the cursor end with the smaller forward state cost and reverse state cost is given a wake-up activation instruction, and the other cursor end is given a sleep blocking instruction, generating an asymmetric cursor scheduling matrix. If not, the wake-up activation instruction and sleep blocking instruction status of each cursor end are maintained, and the asymmetric cursor scheduling matrix of the previous iteration is inherited.

[0006] Preferably, the method further includes: Based on the asymmetric cursor scheduling matrix, the down-jump relationship edge parameters associated with the current extended account entity node on the cursor end of the side given the wake-up activation command are read. The down-jump relationship edge parameters are compared with the weighted state scheduling constraint benchmark to obtain the semantic legal matching value. The corresponding branches with semantic legal matching values ​​equal to zero are truncated, and the terminal node number parameters of the corresponding branches with semantic legal matching values ​​equal to non-zero values ​​are extracted and merged to establish a constrained association topology set. When the constrained association topology set is directed into the forward extension node set or backward extension node set corresponding to the cursor end of the side given the wake-up activation command, a pathfinding trajectory history record is generated simultaneously. Find the parameter intersection element of the updated forward extension node set and the backward extension node set, and determine whether a sequence of nodes from the same source has been obtained. If not, return to the step of reading the forward state value and reverse state value of the current forward and backward cursors and iterate until the preset maximum penetration depth is reached. If obtained, extract the corresponding data item of the sequence of nodes from the same source in the pathfinding trajectory history record, and backtrack along the predecessor node identifier and the incoming path relationship edge pointer recorded in the pathfinding trajectory history record to the starting account node and the target account node respectively, and generate a fund penetration association link graph.

[0007] Preferably, the step of obtaining the penetration mode state transition configuration is as follows: Based on the received query command, the starting account node identifier and the target account node identifier are located in the graph database. The edge type field, edge direction field, edge endpoint field, and edge level field of the reachable relationship edge between the starting account node and the target account node are read. The fund flow type feature parameter and the account membership level attribute parameter are extracted. According to the consistency of the direction of the fund flow type feature parameter, the hierarchical progression relationship of the account membership level attribute parameter is compared item by item. The relationship edge that satisfies the penetration direction and hierarchical progression relationship is written into the penetration mode meta-path constraint to obtain the penetration mode state transition configuration.

[0008] Preferably, the step of obtaining the weighted state scheduling constraint benchmark is as follows: Read the relation type identifiers corresponding to each state layer node in the penetration mode state transition configuration, count the number of starting end account nodes, the number of ending end account nodes, and the total number of relation edges connected to each relation type identifier in the graph database, aggregate them according to the distribution of the total number of relation edges relative to the number of starting end account nodes and the number of ending end account nodes, remove relation type identifiers not referenced by the penetration mode state transition configuration, and obtain the average degree statistic. The layer sequence number, relation type identifier, and allowed jump direction identifier of each state layer node in the penetration mode state transition configuration are called. The average degree statistics are attached to the corresponding state layer nodes one by one according to the relation type identifier to form the cost weight scalar of each state layer node. The state layer nodes that lack the average degree statistics are marked as unschedulable. The remaining state layer nodes are rearranged according to the layer sequence number and allowed jump direction identifier to generate a weighted state scheduling constraint benchmark.

[0009] Preferably, the step of obtaining the bidirectional extended load differential is as follows: Based on the weighted state scheduling constraint benchmark, the cost weight scalar of the current state layer node of the forward cursor is read, the cost weight scalar of the current state layer node of the backward cursor is read, the cost weight scalar of the current state layer node of the forward cursor is registered as the forward state cost value, the cost weight scalar of the current state layer node of the backward cursor is registered as the reverse state cost value, and the absolute value of the numerical difference between the forward state cost value and the reverse state cost value is processed to obtain the bidirectional extended load difference.

[0010] Preferably, the steps for obtaining the asymmetric cursor scheduling matrix are as follows: Call the preset branch switching threshold, compare the bidirectional expansion load difference with the preset branch switching threshold, if the bidirectional expansion load difference is greater than the preset branch switching threshold, read the forward state cost value and reverse state cost value values ​​and sort them, select the cursor end with the smallest value and register it as the cursor end to be activated, and register the unselected cursor ends as the cursor ends to be blocked, if the bidirectional expansion load difference is less than or equal to the preset branch switching threshold, retain the existing instruction state of each cursor end and obtain the cursor end scheduling determination result; Write a wake-up activation instruction to the active cursor end and a sleep blocking instruction to the blocked cursor end. Arrange the instruction writing positions of the forward and backward cursor ends according to the cursor direction identifier. If the cursor end scheduling determination result is to retain the existing instruction state of each cursor end, then read the asymmetric cursor scheduling matrix of the previous iteration, copy the instruction writing positions of the forward and backward cursor ends in the previous iteration, and generate the asymmetric cursor scheduling matrix.

[0011] Preferably, the step of obtaining the constrained associated topology set is as follows: Based on the asymmetric cursor scheduling matrix, the instruction write positions corresponding to the forward and backward cursor ends are analyzed. The cursor end corresponding to the wake-up activation instruction is filtered. The node number, current state layer number, and allowed jump direction identifier of the current extended account entity node of the cursor end are read. The relationship type field, relationship direction field, and branch end node number parameters of the external jump relationship edge of the current extended account entity node are retrieved. The jump relationship edge parameters are compared with the preset relationship type identifier attached to the current state layer node in the weighted state scheduling constraint benchmark. The jump relationship edge with the same relationship type field and the relationship direction field that meets the allowed jump direction identifier is registered as a non-zero value. The jump relationship edge with the inconsistent relationship type field or the relationship direction field that does not meet the allowed jump direction identifier is registered as a zero value, thus obtaining the semantically valid matching value. Read the branch number, branch end node number parameter, relation type field, and relation direction field corresponding to each downward relationship edge. Write the branch number with a semantically valid matching value of zero into the truncation mark, stop writing the branch end node number parameter corresponding to the truncation mark, extract the branch end node number parameter with a semantically valid matching value of non-zero value according to the branch number order, remove duplicate records with the same branch end node number parameter, retain the relation type field and relation direction field corresponding to the branch end node number parameter, and establish a constrained association topology set.

[0012] Preferably, the step of obtaining the pathfinding trajectory history record is as follows: Read the direction identifier of one side of the cursor end corresponding to the wake-up activation instruction in the asymmetric cursor scheduling matrix. If the direction identifier of one side of the cursor end is a forward cursor end, then write the branch end node number parameter in the constrained associated topology set into the forward extension node set. If the direction identifier of one side of the cursor end is a backward cursor end, then write the branch end node number parameter in the constrained associated topology set into the backward extension node set. Simultaneously read the node number of the current extended account entity node and the edge number of the incoming path relationship edge corresponding to each branch end node number parameter. Register the node number of the current extended account entity node as the predecessor node identifier and the edge number of the incoming path relationship edge as the incoming path relationship edge pointer to generate a pathfinding trajectory history record.

[0013] Preferably, the steps for obtaining the fund penetration correlation diagram are as follows: Read the account entity node numbers in the forward extension node set item by item, and read the account entity node numbers in the backward extension node set item by item. Write the records with completely identical account entity node numbers into the intersection candidate positions. Register the intersection order according to the iteration rounds of the forward cursor and the iteration rounds of the backward cursor. If the intersection candidate position is empty, return to execute the operation of reading the forward state value of the current forward cursor and the reverse state value of the current backward cursor. Compare the current penetration depth with the preset maximum penetration depth. If the current penetration depth has not reached the preset maximum penetration depth, continue the loop iteration. If the current penetration depth has reached the preset maximum penetration depth, stop adding intersection candidate positions. If the intersection candidate position is not empty, output the account entity node numbers according to the intersection order to obtain the same origin intersection node sequence. The system retrieves the account entity node number, predecessor node identifier, incoming path relation edge pointer, and cursor end direction identifier from the pathfinding trajectory history record. It locates the corresponding data item according to the account entity node number in the same origin intersection node sequence. The data item with the cursor end direction identifier as the forward cursor end is traced back to the starting account node level by level along the predecessor node identifier. The data item with the cursor end direction identifier as the backward cursor end is traced back to the target account node level by level along the predecessor node identifier. Each time the traceback is performed, the relation edge number pointed to by the incoming path relation edge pointer is read synchronously. The account entity node number and relation edge number obtained by the traceback are registered according to the traceback order to form a path traceback link record. Based on the path backtracking link record, check whether there are connectable relationship edge numbers on both sides of the account entity node number. Mark the account entity node number that is not connected to any relationship edge number as a hanging isolated node and remove it. Register the retained account entity node number as an intermediate account node and the retained relationship edge number as a valid relationship edge. Concatenate the nodes in the order of starting account node, valid relationship edge, intermediate account node, valid relationship edge, and target account node. For repeated connected segments corresponding to the same intermediate account node, retain the first concatenation record to generate a fund penetration association link diagram.

[0014] Compared with the prior art, the advantages and positive effects of the present invention are as follows: This invention locates the starting account node, target account node, and related relationship metadata from the query command, and compares and combines the feature parameters of fund flow type and the attribute parameters of account membership level. Penetrating search no longer stops at the static display of entity and relationship associations, but simultaneously incorporates fund direction, account level, and relationship type into the executable penetrating mode state transition configuration, giving multi-hop relationships between accounts clear semantic boundaries and path constraints. By attaching the average degree statistics of various relationship types to the state layer nodes to form cost weight scalars, it can distinguish the branch expansion pressure brought by different relationship types before expansion, reducing the diffusion of invalid account nodes. Furthermore, by reading the forward state cost and reverse state cost... It generates bidirectional extended load differentials, which can dynamically select the extension direction according to the load difference at the cursor end, so that the forward and backward cursors no longer advance synchronously, reducing traversal redundancy caused by densely related areas on one side; it truncates zero-value branches by semantically valid matching values ​​and retains the node number parameter at the end of non-zero-value branches, which can eliminate branches with mismatched relationship types or jump directions that do not meet constraints in advance; it saves the predecessor node identifier and the pointer of the incoming relationship edge by saving the path trajectory history, which can perform double-end backtracking after the occurrence of the same source intersection node sequence, and remove suspended isolated nodes. It splices the effective relationship edges and intermediate account nodes according to the connection order from the starting account node to the target account node to form a fund penetration association link graph with less redundancy. Attached Figure Description

[0015] Figure 1 This is a schematic diagram of the steps of the present invention; Figure 2 A scalar plot of the average degree statistic and cost weights; Figure 3 This is a diagram showing the bidirectional extended load differential and the preset branch switching threshold. Detailed Implementation

[0016] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will be further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the invention.

[0017] Please see Figure 1-3 This invention provides a technical solution: a method for analyzing the funds of related accounts based on knowledge graphs, comprising the following steps: Based on the received query command, extract the metadata of the association between the starting account node and the target account node in the graph database, obtain the state transition configuration of the penetration mode, aggregate the average degree statistics of various relation types, attach the average degree statistics to each state layer node of the state transition configuration of the penetration mode as cost weight scalars, and generate a weighted state scheduling constraint benchmark. Based on the weighted state scheduling constraint benchmark, read the forward state cost and reverse state cost of the forward and backward cursors, calculate the bidirectional extended load difference, and determine whether the bidirectional extended load difference is greater than the preset branch switching threshold. If so, select the cursor end with the smaller forward state cost and reverse state cost and assign a wake-up activation instruction, and assign a sleep blocking instruction to the other cursor end to generate an asymmetric cursor scheduling matrix. If not, maintain the current wake-up activation instruction and sleep blocking instruction status of each cursor end, and inherit the asymmetric cursor scheduling matrix of the previous iteration. Based on the asymmetric cursor scheduling matrix, the down-jump relationship edge parameters associated with the current extended account entity node of the cursor end on the side given the wake-up activation command are read. The down-jump relationship edge parameters are compared with the weighted state scheduling constraint benchmark to obtain the semantically valid matching value. The corresponding branches with semantically valid matching values ​​equal to zero are truncated, and the terminal node number parameters of the corresponding branches with semantically valid matching values ​​equal to non-zero values ​​are extracted and merged to establish a constrained association topology set. When the constrained association topology set is directed into the forward extension node set or backward extension node set corresponding to the cursor end on the side given the wake-up activation command, a pathfinding trajectory history record is generated simultaneously. Find the intersection of the updated forward and backward extension node sets and determine if a sequence of nodes from the same source has been obtained. If not, return to the previous step of reading the forward and backward state values ​​of the current cursors and iterate until the preset maximum penetration depth is reached. If a sequence of nodes from the same source is obtained, extract the corresponding data items of the sequence of nodes from the pathfinding history and backtrack along the predecessor node identifier and the incoming path relationship edge pointer recorded in the pathfinding history to the starting account node and the target account node respectively, and generate a fund penetration association link graph.

[0018] The steps to obtain the penetration mode state transition configuration are as follows: Based on the received query command, the starting account node identifier and the target account node identifier are located in the graph database. The edge type field, edge direction field, edge endpoint field, and edge level field of the reachable relationship edge between the starting account node and the target account node are read. The fund flow type feature parameter and the account membership level attribute parameter are extracted. According to the consistency of the direction of the fund flow type feature parameter, the hierarchical progression relationship of the account membership level attribute parameter is compared item by item. The relationship edge that satisfies the penetration direction and hierarchical progression relationship is written into the penetration mode meta-path constraint to obtain the penetration mode state transition configuration.

[0019] Specifically, based on the received query command, the system first parses the starting account node identifier (e.g., 'account_A') and the target account node identifier (e.g., 'account_Z') contained in the command, precisely locating these two node entities in the graph database. Then, a breadth-first or depth-first traversal algorithm is executed, but its maximum search depth is limited, for example, no more than 10 levels, to discover all reachable paths connecting the starting and target account nodes. During this process, for each traversed relation edge, its four associated core fields are read simultaneously: the edge type field recording the nature of the relationship (e.g., 'transfer' or 'guarantee'), the edge direction field recording the flow of funds (e.g., a directed edge from account A to account B), the edge endpoint field recording the two endpoints, and the edge level field describing the account's position in the organizational or group structure (e.g., company executive level 1, department manager level 2, ordinary employee level 3). Next, based on the read field information, two key parameters are extracted: one is the fund flow type feature. The parameters are directly mapped from the edge direction field and are used to identify whether funds are flowing in or out. Another parameter is the account affiliation level attribute parameter, which is obtained from the edge level field. Next, all reachable paths are filtered. The core criteria for filtering are the consistency of fund flow and the progression of account levels. For example, if the query requires analyzing the penetration path of funds from higher to lower levels, the filtering conditions are set as follows: the fund flow type feature parameter must be entirely positive outflow, and the account affiliation level attribute parameter must be monotonically increasing, such as from level 1 to level 2, then to level 3, and vice versa. Each edge on all traversed paths that satisfies this preset penetration direction and hierarchical progression relationship is recorded. These edges are then organized into a series of ordered path segments according to their order in the path. These segments together constitute the penetration mode meta-path constraint. Finally, these constraints are structured to form a set containing all legal state transition rules, resulting in the penetration mode state transition configuration.

[0020] The steps for obtaining the weighted state scheduling constraint benchmark are as follows: Read the relation type identifiers corresponding to each state layer node in the penetration mode state transition configuration, count the number of starting end account nodes, the number of ending end account nodes, and the total number of relation edges connected to each relation type identifier in the graph database, aggregate them according to the distribution of the total number of relation edges relative to the number of starting end account nodes and the number of ending end account nodes, remove relation type identifiers not referenced by the penetration mode state transition configuration, and obtain the average degree statistic. The system calls the layer sequence number, relation type identifier, and allowed jump direction identifier of each state layer node in the penetration mode state transition configuration. The average degree statistics are attached to the corresponding state layer nodes one by one according to the relation type identifier to form the cost weight scalar of each state layer node. State layer nodes with missing average degree statistics are marked as unschedulable. The remaining state layer nodes are rearranged according to the layer sequence number and allowed jump direction identifier to generate a weighted state scheduling constraint benchmark.

[0021] Specifically, the process reads the penetration mode state transition configuration generated in the previous step. This configuration defines in detail all legal relationship types in the fund penetration analysis, such as {'transfer', 'investment', 'related transaction'}. It iterates through each relationship type identifier in this set of relationship types. For each identifier, such as 'transfer', a global statistical query is executed across the entire graph database. This query is not limited to a specific starting or target account, but rather targets all edges with a 'transfer' relationship. Specifically, three statistics are performed: first, the number of independent account nodes that are the starting point of a 'transfer' relationship is counted, denoted as... The second step is to count the number of independent account nodes that act as the termination point of the 'transfer' relationship, denoted as . The third is to count the total number of edges in the 'transfer' relationship, denoted as... For example, after statistical analysis of the 'transfer' type, we get... For 10,000 accounts, For 15,000 accounts, Given 80,000 relational edges, based on these three statistical values, two core indicators describing the distribution of relational edges are calculated: average out-degree and average in-degree. The average out-degree is calculated by dividing the total number of relational edges by the number of nodes in the starting account. In the example above, it is 80000 / 10000 = 8. The average in-degree is calculated by dividing the total number of relation edges by the number of terminal account nodes. In the example, 80000 / 15000 ≈ 5.33. These two values ​​reflect the average number of branches of this type of relation edge when starting from or reaching a regular node. The calculated average out-degree and average in-degree are stored as a pair of values ​​associated with the corresponding relation type identifier 'transfer'. This process is repeated for all relation type identifiers included in the penetration mode state transition configuration, and any relation type identifiers that exist in the graph but are not referenced in the current penetration mode state transition configuration, such as 'kinship', are explicitly removed. Finally, all the calculated relation types and their corresponding average out-degree and average in-degree indices are aggregated into a structured dataset to obtain the average degree statistic.

[0022] The process calls the previously generated penetration mode state transition configuration. Logically, this configuration is viewed as a state machine, where each state layer node represents a potential step in the penetration path. Each node is defined by a layer sequence number (e.g., an integer starting from 1), a relation type identifier (e.g., 'transfer'), and a allowed jump direction identifier (e.g., 'forward' or 'backward'). Simultaneously, it retrieves the average degree statistic calculated in the previous step. This statistic stores the average out-degree and average in-degree values ​​for each relation type in key-value pairs, for example: {'transfer': {'avg_out': 8, 'avg_in': 5.33}, 'investment': {'avg_out': 2.5, 'avg_in':} 15.1}} Next, traverse each state layer node in the penetration mode state transition configuration, look up the corresponding statistical data from the average degree statistics according to its relation type identifier, and select the mounting weight according to its allowed jump direction identifier. If the allowed jump direction is 'forward', the average out-degree of that relation type is selected as the cost weight scalar; if it is 'backward', the average in-degree is selected as the cost weight scalar. This weight represents a quantitative estimate of the expected computational complexity when expanding from the current state in one step. For example, a state layer node with a level order of 2, a relation type of 'investment', and a direction of 'forward' has its cost weight scalar set to 2.5. During the mounting process, if the relation type specified by a certain state layer node is not recorded in the average degree statistics, this usually means that the relation of this type has never appeared in the entire graph. Then, the state layer node is marked as unschedulable. Specifically, its cost weight scalar is set to a maximum value, for example... Thus, they are effectively ignored in subsequent scheduling. After the weights of all state layer nodes are attached, all state layer nodes marked as schedulable are sorted by their layer sequence number. Within the same layer sequence, they are sorted by the allowed jump direction identifier. Finally, an ordered list of path search rules with quantified cost values ​​is formed, generating a weighted state scheduling constraint benchmark.

[0023] The steps for obtaining the bidirectional extended load differential are as follows: Based on the weighted state scheduling constraint benchmark, the cost weight scalar of the current state layer node of the forward cursor is read, and the cost weight scalar of the current state layer node of the backward cursor is read. The cost weight scalar of the current state layer node of the forward cursor is registered as the forward state cost value, and the cost weight scalar of the current state layer node of the backward cursor is registered as the reverse state cost value. The absolute value of the numerical difference between the forward state cost value and the reverse state cost value is processed to obtain the bidirectional extended load difference.

[0024] Specifically, based on the weighted state scheduling constraint benchmark, the current states of the forward and backward cursors are first determined in the benchmark. The forward cursor starts from the initial account node, and its current state layer node is determined by the path levels it has traversed. The backward cursor starts from the target account node, and its current state layer node is determined similarly. Next, the cost weight scalar attached to the state layer node of the forward cursor is precisely read from the weighted state scheduling constraint benchmark. For example, if the forward cursor has explored to the third layer, the corresponding relationship type is 'related transaction', and its average out-degree is 15.4, then this 15.4 is read. Subsequently, the attachments of the state layer node of the backward cursor are read in the same way. The cost weight scalar, for example, when the backward cursor explores to the second layer, the corresponding relation type is 'guarantee', and its average in-degree is 35.8, then this 35.8 is read. The cost weight scalar 15.4 read by the forward cursor is directly registered as the forward state cost value, and the cost weight scalar 35.8 read by the backward cursor is directly registered as the reverse state cost value. These two cost values ​​quantify the expected computational complexity or number of branches for expanding one more step forward from their respective directions. Finally, the numerical difference between these two cost values ​​is calculated, and their absolute value is taken, that is, the absolute value of the difference between 15.4 and 35.8 is calculated to obtain the bidirectional expansion load difference of 20.4.

[0025] The steps to obtain the asymmetric cursor scheduling matrix are as follows: Call the preset branch switching threshold, compare the difference between the bidirectional extended load and the preset branch switching threshold. If the difference between the bidirectional extended load and the preset branch switching threshold are greater than the preset branch switching threshold, read the forward state cost value and the reverse state cost value, sort them, select the cursor end with the smallest value and register it as the cursor end to be activated, and register the cursor ends that are not selected as the cursor ends to be blocked. If the difference between the bidirectional extended load and the preset branch switching threshold are less than or equal to the preset branch switching threshold, retain the existing instruction state of each cursor end and obtain the cursor end scheduling judgment result. Write a wake-up activation instruction to the active cursor end and a sleep blocking instruction to the blocked cursor end. Arrange the instruction writing positions of the forward and backward cursor ends according to the cursor direction identifier. If the cursor end scheduling determination result is to retain the existing instruction state of each cursor end, then read the asymmetric cursor scheduling matrix of the previous iteration, copy the instruction writing positions of the forward and backward cursor ends in the previous iteration, and generate the asymmetric cursor scheduling matrix.

[0026] Specifically, a preset branch switching threshold is invoked. This threshold is used to determine whether the load imbalance of the bidirectional search has reached a level requiring intervention. This threshold is not a fixed value but is dynamically calculated. The calculation method is to take the average of the current forward state cost value and the reverse state cost value, and then multiply it by a preset adjustment coefficient, such as 0.5. This coefficient is empirically set based on historical query performance data and graph density to achieve a balance between search efficiency and switching overhead. Taking the previously obtained forward state cost value of 15.4 and reverse state cost value of 35.8 as an example, the branch switching threshold is calculated as (15.4 + 35.8) / 2 * The result is 12.8. Then, the bidirectional expansion load difference of 20.4 obtained in the previous step is compared with the calculated branch switching threshold of 12.8. Since 20.4 is greater than 12.8, it indicates that the load difference of bidirectional search is large. At this time, the branch selection logic is triggered. The program reads the forward state value of 15.4 and the reverse state value of 35.8, sorts the values, selects the cursor end corresponding to the smallest value of 15.4, that is, the forward cursor end, and registers it as the cursor end to be activated. At the same time, the backward cursor ends that are not selected and have larger values ​​are registered as the cursor ends to be blocked. If the calculated bidirectional expansion load difference is less than or equal to the branch switching threshold, for example, the difference is 10, then it is determined to be load balancing. The existing instruction state of each cursor end is retained and not changed, and the cursor end scheduling determination result is obtained.

[0027] Based on the cursor scheduling determination result obtained in the previous step, for the forward cursor that is determined to be activated, an instruction representing "wake-up activation" (e.g., binary value 1) is written to its corresponding control flag in memory. Simultaneously, for the backward cursor that is determined to be blocked, an instruction representing "sleep blocking" (e.g., binary value 0) is written to its control flag. Next, these two instructions are organized in a fixed order, i.e., the forward cursor instruction first, followed by the backward cursor instruction, forming a two-dimensional instruction structure, such as [1, 0]. This structure clarifies which direction of the search will be executed and which direction will be paused in the next iteration. If the cursor scheduling determination result is to retain the existing instruction state of each cursor, it means that the bidirectional expansion load difference has not exceeded the dynamically calculated threshold. In this case, no new instructions need to be generated; instead, the asymmetric cursor scheduling matrix generated at the end of the previous iteration loop is directly accessed and read from memory. For example, if the matrix in the previous round was [1, 1], indicating simultaneous bidirectional activation, then in this round, this [1, 1] matrix is ​​directly copied. [1] The matrix serves as the instruction for the current round. In this way, it inherits the scheduling strategy of the previous round. Ultimately, whether by generating new instructions or copying old instructions, an instruction matrix that clearly defines the working state of the forward and backward cursors in this iteration will be obtained, thus generating an asymmetric cursor scheduling matrix.

[0028] The steps to obtain the constrained associated topology set are as follows: Based on the asymmetric cursor scheduling matrix, the instruction write positions corresponding to the forward and backward cursor ends are analyzed. The cursor end corresponding to the wake-up activation instruction is filtered. The node number, current state layer number, and allowed jump direction identifier of the current extended account entity node of the cursor end are read. The relationship type field, relationship direction field, and branch end node number parameters of the external jump relationship edge of the current extended account entity node are retrieved. The jump relationship edge parameters are compared with the preset relationship type identifier attached to the current state layer node in the weighted state scheduling constraint benchmark. The jump relationship edge with the same relationship type field and the relationship direction field that meets the allowed jump direction identifier is registered as a non-zero value. The jump relationship edge with the same relationship type field or the relationship direction field that does not meet the allowed jump direction identifier is registered as a zero value. The semantically valid matching value is obtained. Read the branch number, branch end node number parameter, relation type field, and relation direction field corresponding to each downward relationship edge. Write the branch number with a semantically valid matching value of zero to the truncation mark, stop writing the branch end node number parameter corresponding to the truncation mark, extract the branch end node number parameter with a semantically valid matching value of non-zero value according to the branch number order, remove duplicate records with the same branch end node number parameter, retain the relation type field and relation direction field corresponding to the branch end node number parameter, and establish a constrained association topology set.

[0029] Specifically, based on the asymmetric cursor scheduling matrix, such as a two-dimensional array [1, 0], the matrix is ​​first parsed to determine the active search direction, where 1 represents wake-up activation and 0 represents dormancy blocking. In this example, the forward cursor end corresponding to index 0 is activated. Subsequently, for each current extended account entity node in the forward extension node set, such as account 'C', its metadata in the graph database is read, including its unique node number 'node_C', its current state layer number in the penetration analysis, such as layer 3, and the allowed jump direction identifier determined by the asymmetric cursor scheduling matrix, i.e., 'forward'. Then, based on the node number 'node_C', all outgoing jump edges directly connected to this node are retrieved from the graph database, and for each edge, its relationship type field, such as 'transfer' or 'guarantee', relationship direction field, such as 'outgoing' or 'ingoing', and the branch that the edge points to are extracted. The branch end node number parameter is used, for example, 'node_D'. Then, the parameters of these down-jump edges are compared one by one with the weighted state scheduling constraint benchmark. Specifically, based on the current state layer number 3 and the allowed jump direction 'forward', the corresponding constraint rule is found in the constraint benchmark. This rule may be preset to only allow edges with the relationship type 'transfer' and the relationship direction 'outward' to pass. For each down-jump edge starting from 'node_C', if its relationship type field is 'transfer' and its relationship direction field is 'outward', it is determined to be semantically valid and a non-zero value, such as 1, is registered for it. If the relationship type is 'guarantee' or the relationship direction is 'inward', it is determined to be a mismatch and a zero value 0 is registered for it. After traversing all down-jump edges of the current extended account entity node, a matching value sequence consisting of 0 and 1 is obtained, which is the semantically valid matching value.

[0030] Read the semantically valid matching values ​​generated in the previous step, corresponding one-to-one with each downward relationship edge. Simultaneously, read the attributes carried by these downward relationship edges themselves, including the branch number used to uniquely identify each edge (e.g., an integer sequence starting from 1), the branch end node number parameter, the relationship type field, and the relationship direction field. Then, iterate through this series of downward relationship edges. For any relationship edge with a semantically valid matching value equal to zero (e.g., its branch number is 3), immediately associate a truncation flag with that branch number 3. This flag prevents subsequent processes from writing the branch's end node number parameter into any set, effectively pruning this search path that does not conform to the penetration pattern. For relationship edges with semantically valid matching values ​​equal to non-zero values, such as 1, perform an extraction operation, collecting its branch end node number parameters into a temporary list according to the original order of the branch numbers. For example, if the matching value of branches 1, 2, and 4 is 1, and their end nodes are 'node_X', 'node_Y', and 'node_X' respectively, then the temporary list is ['node_X', 'node_Y', ...]. Next, this temporary list is deduplicated, removing all duplicate records where the branch terminal node number parameters are exactly the same, so that the list ['node_X', 'node_Y', 'node_X'] becomes ['node_X', 'node_Y']. While deduplicating, to preserve path information, each unique branch terminal node number parameter is bound to its source relation type field and relation direction field. For example, this ultimately forms a structured set containing elements like {node_id: 'node_X', from_relation: 'transfer', from_direction: 'outbound'} and {node_id: 'node_Y', from_relation: 'transfer', from_direction: 'outbound'}. This set is the desired constrained association topology set.

[0031] The steps to obtain the pathfinding trajectory history are as follows: Read the direction identifier of one side of the cursor end corresponding to the wake-up activation instruction in the asymmetric cursor scheduling matrix. If the direction identifier of one side of the cursor end is the forward cursor end, write the branch end node number parameter in the constrained associated topology set to the forward extension node set. If the direction identifier of one side of the cursor end is the backward cursor end, write the branch end node number parameter in the constrained associated topology set to the backward extension node set. Simultaneously read the node number of the current extended account entity node and the edge number of the incoming path relationship edge corresponding to the branch end node number parameter. Register the node number of the current extended account entity node as the predecessor node identifier and the edge number of the incoming path relationship edge as the incoming path relationship edge pointer to generate a pathfinding trajectory history record.

[0032] Specifically, the asymmetric cursor scheduling matrix is ​​read, for example, [1, 0], and the cursor end direction identifier corresponding to the wake-up activation instruction with a value of 1 is parsed out. In this example, it is the forward cursor end. Based on this direction identifier, the target set for subsequent operations is determined to be the forward extension node set. Then, each element in the constrained association topology set established in the previous process is traversed, and the branch end node number parameters contained in each element, such as 'node_X' and 'node_Y', are written one by one into the forward extension node set to complete the expansion of the search boundary. At the same time as the writing operation is performed, the process of generating the pathfinding trajectory history is triggered synchronously. Specifically, for each new node written into the forward extension node set, such as 'node_X', the program will trace back its source and read its corresponding node number, which was located on the extension boundary of the current extension account entity node before the expansion. For example, 'node_C', and the unique edge number in the graph database for the incoming path relationship edge connecting 'node_C' and 'node_X', such as 'edge_C_to_X_123'. Then, in the pathfinding history of a hash table or key-value pair storage structure, a new entry is created, using the number of the new node 'node_X' as the key and an object containing predecessor node information and path information as the value. In this object, the number of 'node_C' is registered as the predecessor node identifier, and the edge number 'edge_C_to_X_123' of the incoming path relationship edge is registered as the incoming path relationship edge pointer. By creating such a record containing its direct predecessor and incoming path pointer for each newly discovered node, the pathfinding history is generated and continuously expanded.

[0033] The steps to obtain the fund penetration and correlation diagram are as follows: Read the account entity node numbers in the forward extension node set item by item, and read the account entity node numbers in the backward extension node set item by item. Write the records with completely identical account entity node numbers into the intersection candidate positions. Register the intersection order according to the iteration rounds of the forward cursor and the iteration rounds of the backward cursor. If the intersection candidate position is empty, return to execute the operation of reading the forward state value of the current forward cursor and the reverse state value of the current backward cursor. Compare the current penetration depth with the preset maximum penetration depth. If the current penetration depth has not reached the preset maximum penetration depth, continue to loop iterate. If the current penetration depth has reached the preset maximum penetration depth, stop adding intersection candidate positions. If the intersection candidate position is not empty, output the account entity node numbers according to the intersection order to obtain the same origin intersection node sequence. The system retrieves the account entity node number, predecessor node identifier, incoming path relation edge pointer, and cursor end direction identifier from the pathfinding trajectory history. It locates the corresponding data item for each account entity node number in the same source intersection node sequence. The data item with the cursor end direction identifier indicating the forward cursor end is backtracked step by step along the predecessor node identifier to the starting account node. The data item with the cursor end direction identifier indicating the backward cursor end is backtracked step by step along the predecessor node identifier to the target account node. Each backtracking operation synchronously reads the relation edge number pointed to by the incoming path relation edge pointer. The account entity node number and relation edge number obtained from the backtracking are registered according to the backtracking order to form a path backtracking link record. Based on the path backtracking link record, check whether there are connectable relationship edge numbers on both sides of the account entity node number. Mark the account entity node number that is not connected to any relationship edge number as a hanging isolated node and remove it. Register the retained account entity node number as an intermediate account node and the retained relationship edge number as a valid relationship edge. Concatenate the nodes in the order of starting account node, valid relationship edge, intermediate account node, valid relationship edge, and target account node. For repeated connected segments corresponding to the same intermediate account node, retain the first concatenation record to generate a fund penetration association link diagram.

[0034] Specifically, the system reads all account entity node numbers from the forward extension node set item by item and loads them into a hash set data structure. Then, it reads the account entity node numbers from the backward extension node set item by item. For each node number in the backward extension node set, it performs a search operation in the hash set. If the search is successful, it indicates that the node number is the intersection point of the forward and backward searches. The system immediately writes the account entity node number into a temporary intersection candidate position list. At the same time, it records the iteration rounds of the forward cursor when the intersection point is found, such as round 4, and the iteration rounds of the backward cursor, such as round 3. This pair of round data {forward: 4, backward: 3} is used as a measure of the intersection order and associated with the node number. If the intersection candidate position list is still empty after traversing the backward extension node set, the loop control logic is triggered. First, the current penetration depth is obtained, which is defined as the sum of the iteration rounds of the forward and backward cursors, i.e., 4 + 3 = 7. Then compare this depth with a preset maximum penetration depth, which is an integer pre-configured based on business complexity and system performance limitations, such as 15. If the current penetration depth 7 does not reach the preset maximum penetration depth 15, return to execute the operation of reading the forward state value of the current forward cursor and the reverse state value of the current backward cursor, and continue the next round of expansion and search. If the current penetration depth reaches the preset maximum penetration depth, stop adding any nodes to the intersection candidate positions, even if intersection points may be found later. If the intersection candidate position list is not empty after any iteration, sort all intersection nodes in the list according to their associated intersection order metric. The sorting rule is to put the nodes with smaller sum of iteration rounds first. Finally, output the account entity node numbers in the sorted order to obtain the sequence of origin intersection nodes.

[0035] The pathfinding history is invoked. This history is a hash map where the account entity node number is the key and the value is an object containing the predecessor node identifier, the incoming path edge pointer, and the cursor direction identifier. Simultaneously, the previously generated sequence of originating and rendezvous nodes is invoked. Each account entity node number in the sequence is retrieved sequentially, for example, 'node_M'. Using 'node_M' as the key, two searches are performed in the pathfinding history. The first search matches the record with the cursor direction identifier 'forward' to obtain its corresponding predecessor node identifier, for example, 'node_L', and the incoming path edge pointer, for example, 'edge_L_M'. Then, 'node_M' and 'edge_L_M' are pushed onto a stack for backtracking, and 'node_L' is set as the new current node. This process is repeated: searching for the preceding record of 'node_L' in the history, obtaining its predecessor and incoming path edge, and pushing it onto the stack. This backtracking process continues upwards until the current node is reached. The second search matches the record marked 'backward' at the cursor end, up to the initially set starting account node. It retrieves the corresponding predecessor node identifier 'node_N' and the incoming path relation edge pointer 'edge_N_M'. Similarly, 'node_M' and 'edge_N_M' are pushed onto another backtracking stack. Using 'node_N' as the current node, the search proceeds backtracking level by level along the backward search path until the current node equals the target account node. In each backtracking operation, the relation edge number pointed to by the incoming path relation edge pointer read from the historical record is extracted. Once both backtracking directions are complete, the account entity node numbers and relation edge numbers in the two backtracking stacks are recorded in two lists according to the pop order (from the starting or target node to the intersection node). Finally, these two lists, along with the intersection node itself, are combined into a complete path record. This operation is repeated for all nodes in the same origin intersection node sequence to form a path backtracking link record.

[0036] Based on the path backtracking link records, each complete path from the starting account node to the target account node is checked and processed item by item. For a path, such as starting account -> edge 1 -> node A -> edge 2 -> node B -> edge 3 -> target account, each intermediate node, i.e., node A and node B, is traversed, and their connection relationship is checked. For node A, it is checked whether there is edge 1 pointing to it and edge 2 originating from it in the path record; for node B, it is checked whether there is edge 2 pointing to it and edge 3 originating from it. If a node, such as node A, is found to have only edge 1 in the record but no edge 2, then this node is considered a breakpoint in the path, marked as a dangling isolated node, and removed from the final result along with the entire path record associated with it. All account entity node numbers in the remaining paths that pass the check are registered as intermediate account nodes, and all relationship edge numbers are registered as valid relationship edges. Then, the path is processed in the following order: starting account node -> valid relationship edge -> intermediate account node -> valid relationship edge -> ... -> The connection order of the target account nodes is determined by concatenating the identifiers of these nodes and edges to form a structured path representation. After generating multiple paths, a deduplication operation is performed. Specifically, each concatenated path is converted into an ordered tuple consisting of node and edge numbers as its unique identifier, and this identifier is stored in a hash set. If the identifier already exists when attempting to store it, it indicates that this is a duplicate path. The first concatenated record is retained, and the current duplicate record is discarded. Finally, all unique, verified, and concatenated paths are summarized to generate a fund penetration association graph.

[0037] The above are merely preferred embodiments of the present invention and are not intended to limit the present invention in any other way. Any person skilled in the art may make changes or modifications to the above-disclosed technical content to create equivalent embodiments that can be applied to other fields. However, any simple modifications, equivalent changes, and modifications made to the above embodiments based on the technical essence of the present invention without departing from the scope of the present invention shall still fall within the protection scope of the present invention.

Claims

1. A method for analyzing the funds of related accounts based on knowledge graphs, characterized in that, Includes the following steps: Based on the received query command, extract the metadata of the association between the starting account node and the target account node in the graph database, obtain the state transition configuration of the penetration mode, aggregate the average degree statistics of various relationship types, attach the average degree statistics to each state layer node of the state transition configuration of the penetration mode as cost weight scalar, and generate a weighted state scheduling constraint benchmark. Based on the weighted state scheduling constraint benchmark, the forward state cost and reverse state cost of the forward and backward cursors are read, and the bidirectional extended load difference is calculated. It is determined whether the bidirectional extended load difference is greater than the preset branch switching threshold. If so, the cursor end with the smaller forward state cost and reverse state cost is given a wake-up activation instruction, and the other cursor end is given a sleep blocking instruction, generating an asymmetric cursor scheduling matrix. If not, the wake-up activation instruction and sleep blocking instruction status of each cursor end are maintained, and the asymmetric cursor scheduling matrix of the previous iteration is inherited.

2. The knowledge graph-based method for analyzing funds across related accounts according to claim 1, characterized in that, The method further includes: Based on the asymmetric cursor scheduling matrix, the down-jump relationship edge parameters associated with the current extended account entity node on the cursor end of the side given the wake-up activation command are read. The down-jump relationship edge parameters are compared with the weighted state scheduling constraint benchmark to obtain the semantic legal matching value. The corresponding branches with semantic legal matching values ​​equal to zero are truncated, and the terminal node number parameters of the corresponding branches with semantic legal matching values ​​equal to non-zero values ​​are extracted and merged to establish a constrained association topology set. When the constrained association topology set is directed into the forward extension node set or backward extension node set corresponding to the cursor end of the side given the wake-up activation command, a pathfinding trajectory history record is generated simultaneously. Find the parameter intersection element of the updated forward extension node set and the backward extension node set, and determine whether a sequence of nodes from the same source has been obtained. If not, return to the step of reading the forward state value and reverse state value of the current forward and backward cursors and iterate until the preset maximum penetration depth is reached. If obtained, extract the corresponding data item of the sequence of nodes from the same source in the pathfinding trajectory history record, and backtrack along the predecessor node identifier and the incoming path relationship edge pointer recorded in the pathfinding trajectory history record to the starting account node and the target account node respectively, and generate a fund penetration association link graph.

3. The knowledge graph-based method for analyzing funds across related accounts according to claim 1, characterized in that, The steps for obtaining the penetration mode state transition configuration are as follows: Based on the received query command, the starting account node identifier and the target account node identifier are located in the graph database. The edge type field, edge direction field, edge endpoint field, and edge level field of the reachable relationship edge between the starting account node and the target account node are read. The fund flow type feature parameter and the account membership level attribute parameter are extracted. According to the consistency of the direction of the fund flow type feature parameter, the hierarchical progression relationship of the account membership level attribute parameter is compared item by item. The relationship edge that satisfies the penetration direction and hierarchical progression relationship is written into the penetration mode meta-path constraint to obtain the penetration mode state transition configuration.

4. The knowledge graph-based method for analyzing funds across related accounts according to claim 1, characterized in that, The steps for obtaining the weighted state scheduling constraint benchmark are as follows: Read the relation type identifiers corresponding to each state layer node in the penetration mode state transition configuration, count the number of starting end account nodes, the number of ending end account nodes, and the total number of relation edges connected to each relation type identifier in the graph database, aggregate them according to the distribution of the total number of relation edges relative to the number of starting end account nodes and the number of ending end account nodes, remove relation type identifiers not referenced by the penetration mode state transition configuration, and obtain the average degree statistic. The layer sequence number, relation type identifier, and allowed jump direction identifier of each state layer node in the penetration mode state transition configuration are called. The average degree statistics are attached to the corresponding state layer nodes one by one according to the relation type identifier to form the cost weight scalar of each state layer node. The state layer nodes that lack the average degree statistics are marked as unschedulable. The remaining state layer nodes are rearranged according to the layer sequence number and allowed jump direction identifier to generate a weighted state scheduling constraint benchmark.

5. The knowledge graph-based method for analyzing funds across related accounts according to claim 1, characterized in that, The steps for obtaining the bidirectional extended load differential are as follows: Based on the weighted state scheduling constraint benchmark, the cost weight scalar of the current state layer node of the forward cursor is read, the cost weight scalar of the current state layer node of the backward cursor is read, the cost weight scalar of the current state layer node of the forward cursor is registered as the forward state cost value, the cost weight scalar of the current state layer node of the backward cursor is registered as the reverse state cost value, and the absolute value of the numerical difference between the forward state cost value and the reverse state cost value is processed to obtain the bidirectional extended load difference.

6. The knowledge graph-based method for analyzing funds across related accounts according to claim 1, characterized in that, The steps for obtaining the asymmetric cursor scheduling matrix are as follows: Call the preset branch switching threshold, compare the bidirectional expansion load difference with the preset branch switching threshold, if the bidirectional expansion load difference is greater than the preset branch switching threshold, read the forward state cost value and reverse state cost value values ​​and sort them, select the cursor end with the smallest value and register it as the cursor end to be activated, and register the unselected cursor ends as the cursor ends to be blocked, if the bidirectional expansion load difference is less than or equal to the preset branch switching threshold, retain the existing instruction state of each cursor end and obtain the cursor end scheduling determination result; Write a wake-up activation instruction to the active cursor end and a sleep blocking instruction to the blocked cursor end. Arrange the instruction writing positions of the forward and backward cursor ends according to the cursor direction identifier. If the cursor end scheduling determination result is to retain the existing instruction state of each cursor end, then read the asymmetric cursor scheduling matrix of the previous iteration, copy the instruction writing positions of the forward and backward cursor ends in the previous iteration, and generate the asymmetric cursor scheduling matrix.

7. The knowledge graph-based method for analyzing funds across related accounts according to claim 2, characterized in that, The steps for obtaining the constrained associated topology set are as follows: Based on the asymmetric cursor scheduling matrix, the instruction write positions corresponding to the forward and backward cursor ends are analyzed. The cursor end corresponding to the wake-up activation instruction is filtered. The node number, current state layer number, and allowed jump direction identifier of the current extended account entity node of the cursor end are read. The relationship type field, relationship direction field, and branch end node number parameters of the external jump relationship edge of the current extended account entity node are retrieved. The jump relationship edge parameters are compared with the preset relationship type identifier attached to the current state layer node in the weighted state scheduling constraint benchmark. The jump relationship edge with the same relationship type field and the relationship direction field that meets the allowed jump direction identifier is registered as a non-zero value. The jump relationship edge with the inconsistent relationship type field or the relationship direction field that does not meet the allowed jump direction identifier is registered as a zero value, thus obtaining the semantically valid matching value. Read the branch number, branch end node number parameter, relation type field, and relation direction field corresponding to each downward relationship edge. Write the branch number with a semantically valid matching value of zero into the truncation mark, stop writing the branch end node number parameter corresponding to the truncation mark, extract the branch end node number parameter with a semantically valid matching value of non-zero value according to the branch number order, remove duplicate records with the same branch end node number parameter, retain the relation type field and relation direction field corresponding to the branch end node number parameter, and establish a constrained association topology set.

8. The knowledge graph-based method for analyzing funds across related accounts according to claim 2, characterized in that, The steps for obtaining the historical pathfinding trajectory are as follows: Read the direction identifier of one side of the cursor end corresponding to the wake-up activation instruction in the asymmetric cursor scheduling matrix. If the direction identifier of one side of the cursor end is a forward cursor end, then write the branch end node number parameter in the constrained associated topology set into the forward extension node set. If the direction identifier of one side of the cursor end is a backward cursor end, then write the branch end node number parameter in the constrained associated topology set into the backward extension node set. Simultaneously read the node number of the current extended account entity node and the edge number of the incoming path relationship edge corresponding to each branch end node number parameter. Register the node number of the current extended account entity node as the predecessor node identifier and the edge number of the incoming path relationship edge as the incoming path relationship edge pointer to generate a pathfinding trajectory history record.

9. The knowledge graph-based method for analyzing funds across related accounts according to claim 2, characterized in that, The steps for obtaining the fund penetration correlation diagram are as follows: Read the account entity node numbers in the forward extension node set item by item, and read the account entity node numbers in the backward extension node set item by item. Write the records with completely identical account entity node numbers into the intersection candidate positions. Register the intersection order according to the iteration rounds of the forward cursor and the iteration rounds of the backward cursor. If the intersection candidate position is empty, return to execute the operation of reading the forward state value of the current forward cursor and the reverse state value of the current backward cursor. Compare the current penetration depth with the preset maximum penetration depth. If the current penetration depth has not reached the preset maximum penetration depth, continue the loop iteration. If the current penetration depth has reached the preset maximum penetration depth, stop adding intersection candidate positions. If the intersection candidate position is not empty, output the account entity node numbers according to the intersection order to obtain the same origin intersection node sequence. The system retrieves the account entity node number, predecessor node identifier, incoming path relation edge pointer, and cursor end direction identifier from the pathfinding trajectory history record. It locates the corresponding data item according to the account entity node number in the same origin intersection node sequence. The data item with the cursor end direction identifier as the forward cursor end is traced back to the starting account node level by level along the predecessor node identifier. The data item with the cursor end direction identifier as the backward cursor end is traced back to the target account node level by level along the predecessor node identifier. Each time the traceback is performed, the relation edge number pointed to by the incoming path relation edge pointer is read synchronously. The account entity node number and relation edge number obtained by the traceback are registered according to the traceback order to form a path traceback link record. Based on the path backtracking link record, check whether there are connectable relationship edge numbers on both sides of the account entity node number. Mark the account entity node number that is not connected to any relationship edge number as a hanging isolated node and remove it. Register the retained account entity node number as an intermediate account node and the retained relationship edge number as a valid relationship edge. Concatenate the nodes in the order of starting account node, valid relationship edge, intermediate account node, valid relationship edge, and target account node. For repeated connected segments corresponding to the same intermediate account node, retain the first concatenation record to generate a fund penetration association link diagram.

Images