Enterprise debt chain intelligent voltage drop and management and control method based on dynamic knowledge graph

Abstract

The invention discloses an enterprise debt chain intelligent voltage drop and management and control method based on a dynamic knowledge graph. The method comprises the following steps: S1, constructing an enterprise transaction knowledge graph; s2, querying a debt chain based on a knowledge graph; s3, carrying out intelligent voltage drop on account receivable; and S4, carrying out production and fusion linkage customer acquisition and high-frequency path query based on the centrality. According to the invention, a clear debt reduction target can be provided for an enterprise, the debt problem can be solved at the minimum cost, and the qualification and debt ratio is reduced; the receivable account is tracked more effectively, and the risks of bad debts and overdue payment are reduced, so that the transaction cost is reduced, the cash flow management is optimized, and the financial health degree of an enterprise is improved; different degrees of attention to customers and merchants who have close transactions in the group are improved, group production and fusion linkage is assisted, and improvement of production and fusion service capability of group financial enterprises is realized.

Description

Technical Field

[0001] The present invention relates to the field of enterprise management, and particularly relates to an intelligent reduction and control method for enterprise debt chains based on a dynamic knowledge graph. Background Art

[0002] In the context of the integration of fintech and artificial intelligence, as a branch in the application field of artificial intelligence technology, knowledge graph technology provides an advanced method for the field of enterprise financial management. At present, this technology has entered many industries and fields, and various vertical domain knowledge graphs have been established, such as e-commerce, finance, medical, legal knowledge graphs, etc. The enterprise financial knowledge graph is also one of the very promising vertical development fields of knowledge graphs in the future. Wang Haofen et al. (2020) pointed out that with the continuous deepening of application scenarios, in the construction of enterprise knowledge graphs, the representation and acquisition of multi-type knowledge, the reasoning and calculation of massive knowledge, and the timeliness of knowledge will become problems that need to be solved urgently. Chen Xiaojun et al. (2020) systematically studied the enterprise risk knowledge graph and realized the retrieval and utilization of the knowledge graph through intelligent question answering. Zheng Jie et al. (2022) proposed to judge the possible tax risks of the financial data and other relevant information declared by enterprises from the perspective of supervision, and applied it to the construction of the knowledge graph of enterprise tax compliance risks using Neo4j to realize the storage and query of the knowledge graph. Although knowledge graph technology has begun to be applied to enterprise financial management, the existing research still stays at a relatively superficial theoretical feasibility discussion and has not developed a system that can be used for real business operations and daily management of enterprises.

[0003] Based on the above problems, and at the same time to strengthen the industrial-financial linkage of the group company, realize the reduction of accounts receivable in different sectors within the group, supply chain management, and assist financial institutions in customer acquisition, the present invention proposes an intelligent reduction and control method for enterprise debt chains based on a dynamic knowledge graph. Summary of the Invention

[0004] In order to overcome the problems in the background art, the present invention provides an intelligent reduction and control method for enterprise debt chains based on a dynamic knowledge graph, and the specific content is as follows:

[0005] (1) Construction of an enterprise transaction knowledge graph based on multi-source heterogeneous enterprise data; aggregating and integrating enterprise financial data with multiple dimensions, diverse forms of expression, large scale, and complex relationships, and forming a large-scale transaction association network through a financial management system based on knowledge graph technology, breaking the dilemma of the traditional enterprise management mode being scattered, data being difficult to effectively utilize, and management efficiency being low;

[0006] (2) Debt chain query based on knowledge graph: By using knowledge graph technology and breadth-first search (BFS) algorithm, enterprises can quickly find all related creditor's rights and debt relationships; based on the found creditor's rights and debt relationships, further subdivide them into two-way debts, triangular debts, and multi-angle debts, and conduct in-depth analysis of the company's debts; match and verify the queried data with the real data in the financial center, and intelligently check the accounting books, improving the financial management efficiency and accuracy of enterprises while reducing labor costs.

[0007] (3) Intelligent reduction of accounts receivable: Use the path search algorithm to identify and extract the debt chain, and take the minimum amount on the debt chain as the "amount that can be reduced". In the way of reducing the two types of funds, it helps enterprises reduce the asset-liability ratio and transaction costs; by constructing a knowledge graph network of merchants and customers with different internal sectors of the group as the core, it is convenient for group managers to master the information of accounts receivable that can be reduced in key sectors, and clearly understand the explicit creditor's rights and debt relationships between external units and different ownership units within the internal sectors, so as to assist managers in making corresponding overall arrangements and reducing relevant creditor's rights and debts, and then achieving the goal of effectively reducing the accounts receivable of the group and its subsidiaries. On this basis, introduce the time dimension, conduct in-depth analysis of the contribution degree of the stock increment of the total amount that can be reduced each month, obtain the contribution degree of different merchants and customers to the amount that can be reduced, and then provide decision-making assistance for the group to conduct overall debt reduction.

[0008] (4) Intelligent customer acquisition through the integration of production and finance: Through the constructed dynamic knowledge graph, use the centrality algorithm to identify key merchants and customers. Through centrality analysis, enterprises can identify key transaction nodes and high-value merchants and customers, and then optimize resource allocation; remind the company's management to pay a certain degree of attention to external merchants and customers with a large number of transactions and large amounts of money with internal enterprises, and invest limited resources in places where returns are most likely to be obtained. In addition, on the basis of debt chain query, introduce the time dimension. Through horizontal comparison of different types of debt chains in different months, obtain debt chains with high frequencies, identify merchants and customers with close business contacts with enterprise units, predict future transaction models and capital requirements, so as to better plan financial and operation strategies, provide data support for the integration of production and finance, assist the group in debt reduction, and reduce the financial costs of enterprises.

[0009] The present invention solves the above technical problems through the following technical solutions. The present invention includes the following steps:

[0010] S1: Construction of an enterprise transaction knowledge graph. Use the group transaction data to construct a knowledge graph based on the enterprise transaction data.

[0011] S2: Debt chain query based on the knowledge graph.

[0012] Define the function for querying creditor's rights and debts relationship as Q(v) = "match(n:company{name:$name)-[r]-(m)return n.name,r.money,m.name", where $name is a filling parameter used to pass in the specific company name. After inputting the node v, query the list of nodes and amounts customer_amount that have creditor's rights and debts relationship with it;

[0013] S3: Intelligent reduction of accounts receivable;

[0014] Define the debt chain L=(v1,e1,v2,e2,...,v n )), where v i is a node, and e i is an edge, representing the creditor's rights and debts relationship; Define the debt chain amount function as the minimum weight of all edges on the chain. The process is as follows:

[0015] F(L)=min(w(e1),w(e2),…,w(e n-1 ))), where w(e i ) is the weight of edge e i ), representing the amount of creditor's rights and debts; Use Python to implement intelligent reduction estimation. Subtract the minimum weight from the amounts of all relationships on the path queried by the debt chain, and update all debt chains until no further reduction can be made;

[0016] S4: Industry-finance linkage customer acquisition and high-frequency path query based on centrality;

[0017] Define the centrality C n =deg(n), where deg(n) represents the number of edges connected to node n;

[0018] Out-degree centrality: Represents the number of other nodes pointed to by a node, that is, the number of transactions paid by this enterprise to other enterprises;

[0019] In-degree centrality: Represents the number of other nodes pointing to this node, that is, the number of transactions paid by other enterprises to this enterprise;

[0020] Use the query statement "MATCH(n:Node)-[r:LINKED_TO]->()RETURN n.name,count(r)asoutgoingDegree" to obtain the number of other nodes received by each node, that is, the number of accounts receivable of each enterprise from other enterprises;

[0021] Use the query statement "MATCH(n:Node)<-[r:LINKED_TO]-() RETURN n.name as nodeName, count(r) as incomingDegree" to obtain the number of times each node points to other nodes, that is, the number of times each enterprise owes other enterprises; on this basis, sort the quantities to identify high-value customers and potential debt risks.

[0022] For high-frequency path queries, according to the debt chain L=(v1,e1,v2,e2,...,v n ), extract the monthly creditor-debtor relationships and customer objects centered on the company from Neo4j, store the monthly customer objects using the set object set in Python, and use the operations of the set to vertically compare the creditor-debtor relationships and customer object sets in different months to find the common creditor-debtor relationships and customer objects and the newly emerged creditor-debtor relationships and customer objects.

[0023] Furthermore, the specific steps for constructing the enterprise transaction knowledge graph are as follows:

[0024] S1.1: Data extraction, use SQL query to extract transaction data from the enterprise financial system;

[0025] S1.2: Data cleaning and preprocessing. For duplicate records, use the drop_duplicates statement of the third-party library pandas in Python to remove duplicates; for missing values, since filling in the transaction amount will cause a discrepancy in the real data, directly delete them; for the missing timestamp, if allowed by the business logic, use the transaction record date as an approximation, or use the average timestamp of adjacent records.

[0026] S1.3: Entity recognition and normalization. When the original data extracted by sql has inconsistent special symbols, case sensitivity of the enterprise name, the solution adopted is to use Python to remove special characters and spaces;

[0027] S1.4: Merge business details. Since it is necessary to model the units at the group internal level and the secondary level separately, the transactions need to be merged according to the single entity units and secondary units respectively;

[0028] When modeling single entity units, sum up the transaction amounts according to the same names or other identifiers of the trading parties, and merge different business details into transaction records at the single entity unit level; the same applies to the secondary level;

[0029] S1.5: Entity mapping. Map the entities in the cleaned data to the nodes in the knowledge graph, using the company name as the unique index. Use the drop_duplicates statement in the pandas library of Python to ensure the exhaustiveness and uniqueness of each enterprise entity. Finally, use Python to generate a CSV file that only contains nodes and attributes.

[0030] S1.6: Relationship mapping. For each transaction record, connect the enterprise nodes of both parties of the transaction with an edge, and assign the corresponding timestamp and weight (transaction amount). Finally, use Python to generate a CSV file that only contains relationships.

[0031] Furthermore, the specific process of the debt chain query based on the knowledge graph is as follows:

[0032] S2.1: Conduct a breadth-first search (BFS) starting from the target node v.

[0033] S2.2: Traverse the nodes directly connected to v, and record the creditor-debtor relationship and the corresponding amount:

[0034] After the breadth-first search ends, all the nodes that have a creditor-debtor relationship with node v and their corresponding amounts will be stored in the list customer_amount.

[0035] S2.3: Sort in descending order according to the amount to obtain the sorted list customer_amount':

[0036] Use the sort function of the sorting algorithm. Using the amount in the tuple as the index, sort the list customer_amount in descending order. The sorted list is customer_amount'. Extract the node part from the sorted list customer_amount' to form a node set Nodeset, that is, Nodeset = u|(u,amount) ∈ customer_amount′.

[0037] S2.4: The algorithm can check the results in customer_amount' with the financial statement data according to different situations to ensure accuracy:

[0038] Obtain the financial statement data corresponding to node v, including the amounts of creditor's rights and debts with each node; traverse each node u and the corresponding amount amount in the list customer_amount', and use the if statement to compare with the data in the financial statement; if any inconsistency is found, record the difference and return False for warning to remind the finance staff to check and correct the data manually; if all data are verified correctly, finally output the list customer_amount' as the list of nodes and amounts with creditor's rights and debts relationships with node v.

[0039] Furthermore, the specific process of performing breadth-first search (BFS) starting from the target node v is as follows:

[0040] Initialize a queue Q_node and add the starting node v to this queue; initialize a set V visited , which is used to store the nodes that have been visited, and add v to V initially visited ; initialize an empty list customer_amount to record the creditor's rights and debts relationships and the corresponding amounts, where each element is a tuple (customer, amount), indicating that the amount of creditor's rights and debts between node and node v customer is amount; when the queue Q_node is not empty, repeat the following steps:

[0041] S2.1.1. Take out a node v from the queue Q_node;

[0042] S2.1.2. Traverse all nodes u directly connected to node v. If u is not in V visited , add it to V visited and the queue Q_node;

[0043] When there is a creditor's rights and debts relationship between v and u, update the list customer_amount, take u as the customer in the tuple, and the corresponding amount of creditor's rights and debts as the amount in the tuple;

[0044] When amount already exists, overwrite and create.

[0045] Furthermore, the specific steps of the intelligent reduction of accounts receivable are as follows:

[0046] S3.1: Debt chain identification and extraction:

[0047] S3.1.1: Starting from any node v of the graph G i , perform depth-first search (DFS) or breadth-first search (BFS);

[0048] S3.1.2: During the search process, record the nodes, edges, and edge attributes (amounts) passed through to form a debt chain L i ;

[0049] S3.1.3: Check L i to see if it meets the pre-set debt chain requirements, including being a closed loop and having no duplicate nodes;

[0050] S3.1.4: If it meets the requirements, add L i to the debt chain set L;

[0051] S3.1.5: Repeat steps S3.1.1 - S3.1.4 until all nodes in the graph G have been traversed;

[0052] S3.2: Calculate the amount that can be reduced in the debt chain:

[0053] For each debt chain L i ∈ L, calculate its reducible amount F(L):

[0054] Furthermore, the steps of the industry - finance integration for customer acquisition are as follows:

[0055] S4.1.1: Create a centrality record for each node in the graph, including out - degree, in - degree, and total centrality;

[0056] S4.1.2: Calculate the out - degree of each node;

[0057] S4.1.3: Traverse all relationships in the graph;

[0058] S4.1.4: For each out - relationship (i.e., a relationship starting from one node and pointing to another node), increase the out - degree count of the starting node;

[0059] S4.1.5: Calculate the in - degree of each node;

[0060] S4.1.6: Traverse all relationships in the graph again;

[0061] S4.1.7: For each in - relationship (i.e., a relationship pointing to a node), increase the in - degree count of the ending node;

[0062] S4.1.8: Calculate the total centrality, traverse all nodes, and output the out - degree centrality, in - degree centrality, and total centrality of each node.

[0063] S4.2: Calculate the high - frequency paths:

[0064] S4.2.1: Obtain data monthly, obtaining the debt chain paths for this month and the debt chain paths for the previous x months;

[0065] S4.2.2: Import the data into Python and use the third-party library pandas to perform frequency query;

[0066] S4.2.3: For each debt chain path in this month, compare it with other months and calculate the total frequency of each debt chain path appearing in other months;

[0067] S4.2.4 Traverse all debt chain paths within this month until all path frequencies are calculated;

[0068] S4.2.5 sorts the path frequencies to obtain all high-frequency paths under a specific threshold.

[0069] Compared with the prior art, the present invention has the following advantages: the enterprise debt chain intelligent pressure reduction and management method based on dynamic knowledge graph can achieve:

[0070] (1) Integration and utilization of multi-dimensional and multi-source data: The enterprise transaction knowledge graph proposed in this invention can solve the problems currently faced by large enterprise groups, such as the decentralized storage and difficulty in integrating financial data. It realizes the collection, integration, sharing and mutual use of financial data of large enterprise groups, improves the breadth and depth of financial data collection, and promotes the construction of a financial digital intelligence system. It is a flexible structure and timely feedback enterprise financial management solution worthy of attention.

[0071] (2) Debt chain query based on knowledge graph: Based on the knowledge graph constructed from multi-source heterogeneous enterprise data, the present invention analyzes the internal ownership units of the group, the merchants and suppliers that have transactions with the ownership units, and intelligently calculates the transaction amounts, transaction quantities and other information at different levels and in different sectors, providing group managers with an overall transaction overview of each unit in the group; group managers can judge whether to pay different degrees of attention to different units based on the overall transaction quantity and transaction amount, explore important external units, and reduce the external risks of the group at the same time;

[0072] (3)Intelligent reduction of accounts receivable; F(L), based on big data technology and path search algorithm, can accurately find complex debt relationships such as two-way debts and multi-angle debts, automatically calculate the minimum amount on the debt chain, mark it as the "amount that can be reduced", and realize the traceability of complex debt relationships and the quantification of the amount to be reduced; this provides a clear debt reduction target for enterprises, helps to solve debt problems at the lowest cost, and reduces the asset-liability ratio. Through intelligent management, enterprises can more effectively track accounts receivable, reduce the risks of bad debts and overdue payments, thereby reducing transaction costs, optimizing cash flow management, and improving the financial health of enterprises. On this basis, considering the time dimension, conduct penetration analysis to show the changes in the amount that can be reduced in stock and the amount that can be reduced incrementally, and explore the reasons for the changes behind. Specifically, the change in stock refers to the amount reduced this month from the total amount that could be reduced last month. The proportion of the change in the stock of the ownership unit is the amount of the change in the stock of the ownership unit / the total amount of the change in the stock of the secondary ownership unit to which it belongs. The proportion of the change in the stock of the customer is the amount of the change in the stock of the customer / the total amount of the change in the stock of the group. The increment refers to the newly added amount that can be reduced this month. The proportion of the change in the increment of the ownership unit is the amount of the increment of the ownership unit / the total amount of the increment of the secondary ownership unit to which it belongs. The proportion of the change in the increment of the customer is the amount of the increment of the customer / the total amount of the increment of the group.

[0073] (4)Customer acquisition through the integration of industry and finance based on centrality and high-frequency path query: Frequently occurring debt relationships may indicate that certain trading partners have close and continuous business dealings with the enterprise. This invention uses the centrality algorithm to intelligently identify key trading customers, realizes different levels of attention to customers with close business dealings within the group, helps the integration of industry and finance within the group, and enhances the industrial and financial service capabilities of the group's financial enterprises; at the same time, the acquisition of high-frequency paths can help the group analyze the frequency and periodicity of debt relationships, and enterprises can predict future trading patterns and capital requirements based on this, so as to better plan financial and operation strategies. BRIEF DESCRIPTION OF THE DRAWINGS

[0074] Figure 1 is the overall structure diagram of the present invention. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0075] The following will give a detailed description of the embodiments of the present invention. These embodiments are implemented on the premise of the technical solution of the present invention, and detailed implementation methods and specific operation processes are given, but the protection scope of the present invention is not limited to the following embodiments.

[0076] As Figure 1 shown, this embodiment provides a technical solution: A method for intelligent reduction and control of enterprise debt chains based on a dynamic knowledge graph, including the following steps:

[0077] S1: Construction of the enterprise transaction knowledge graph:

[0078] S2: Debt chain query based on knowledge graph;

[0079] S3: Intelligent reduction of accounts receivable;

[0080] S4: Industry-finance linkage customer acquisition and high-frequency path query based on centrality;

[0081] The specific content of the above process is as follows:

[0082] S1. Construction of enterprise transaction knowledge graph:

[0083] Build a knowledge graph in a bottom-up manner, use nodes to represent enterprise entities, and edges and their attribute values to represent the creditor-debtor relationships and amounts between enterprise entities. Select the Neo4j graph database to process and store the multi-source heterogeneous financial data of enterprises. Implement it based on Python and the Neo4j graph database, and use the third-party library py2neo in Python to connect the Python environment with the Neo4j graph database;

[0084] To illustrate the effectiveness of the present invention, we verify it based on the financial data provided by an enterprise group; the data includes two parts: the creditor-debtor table of internal units within the group and the creditor-debtor table of units under the group and external customers. As of December 2023, there are a total of 1,504 affiliated units and 46,028 external customers;

[0085] The specific implementation steps are as follows:

[0086] S1.1: Data extraction, use SQL query to extract transaction data from the enterprise financial system.

[0087] S1.2: Data cleaning and preprocessing. For duplicate records, use the drop_duplicates statement of the third-party library pandas in python to remove duplicates; for missing values, since filling in the transaction amount will cause discrepancies in the real data, directly delete them; for missing timestamps, if allowed by the business logic, use the transaction record date as an approximation, or use the average timestamp of adjacent records;

[0088] S1.3: Entity recognition and normalization. When the original data extracted by sql has inconsistent cases of special symbols and case in the enterprise name, the solution adopted is to use Python to remove special characters and spaces;

[0089] S1.4: Merge business details. Since modeling needs to be carried out separately for units at the group internal level and units at the secondary level, transactions need to be merged separately according to individual units and secondary units. Specifically, when modeling individual units, the transaction amounts are aggregated according to the same names or other identifiers of the two parties to the transaction, and different business details are merged into transaction records at the individual unit level; the same applies to the secondary level.

[0090] S1.5: Entity mapping. Map the entities in the cleaned data to the nodes in the knowledge graph. Using the company name as the unique index, the drop_duplicates statement in the pandas library of python is used to ensure the exhaustiveness and uniqueness of each enterprise entity. Finally, a csv file containing only nodes and attributes is generated using python.

[0091] S1.6: Relationship mapping. For each transaction record, connect the enterprise nodes of the two parties to the transaction with an edge, and assign the corresponding timestamp and weight (transaction amount). Finally, a csv file containing only relationships is generated using python.

[0092] As shown in Table 1, taking 8 pieces of data as an example, first use the drop_duplicates statement in the pandas library of python to remove duplicates from the enterprise names; secondly, use the loc statement and the concat statement to merge the company entities to obtain a csv file containing only nodes and attributes; then create a csv file containing the head node, tail node and node attributes (i.e., accounts receivable, accounts payable amount); finally, import the processed data into the neo4j database for modeling, and use the code "bin\neo4j-admin database import full--multiline-fields=true--nodes=import / node.csv-relationships=import / relation.csv--input-encoding=UTF-8neo4j" to establish the relationship between all entity companies and customers in the enterprise.

[0093]

[0094] Table 1 Example of enterprise creditor-debtor relationship

[0095] S2: Debt chain query based on the knowledge graph:

[0096] Define the function for querying creditor-debtor relationships Q(v) = "match(n:company{name: $name)-[r]-(m) return n.name,r.money,m.name", where $name is a filling parameter used to pass in the specific company name. After inputting the node v, query the list of nodes and amounts customer_amount that have creditor-debtor relationships with it;

[0097] The specific implementation steps are as follows:

[0098] S2.1: Conduct a breadth-first search (BFS) starting from the target node v. Initialize a queue Q_node and add the starting node v to this queue; Initialize a set V visited , which is used to store the nodes that have been visited, and add v to V initially visited ; Initialize an empty list customer_amount, which is used to record creditor-debtor relationships and corresponding amounts. Each element is a tuple (customer, amount), indicating that the creditor-debtor amount between node v and customer is amount; When the queue Q_node is not empty, repeat the following steps:

[0099] S2.1.1: Take out a node v from the queue Q_node;

[0100] S2.1.2: Traverse all nodes u directly connected to node v. If u is not in V visited , add it to V visited and the queue Q_node; If there is a creditor-debtor relationship between v and u, update the list customer_amount, take u as the customer in the tuple, and the corresponding creditor-debtor amount as the amount in the tuple. If the amount already exists, overwrite and create;

[0101] S2.2: Traverse the nodes directly connected to v and record the creditor-debtor relationships and corresponding amounts:

[0102] After the breadth-first search ends, the list customer_amount will contain all the nodes that have creditor-debtor relationships with node v and their corresponding amounts for storage;

[0103] S2.3: Sort in descending order according to the amount to obtain the sorted list customer_amount':

[0104] Use the sorting algorithm sort function to sort the list customer_amount in descending order with the amount in the tuple as the index. The sorted list is the customer_amount';

[0105] Extract the node part from the sorted list customer_amount' to form a node set Nodeset, that is, Nodeset = u | (u, amount) ∈ customer_amount′;

[0106] S2.4: The algorithm can check the results in customer_amount' against the financial statement data according to different situations to ensure accuracy:

[0107] Obtain the financial statement data corresponding to node v, including the amounts of creditor's rights and debts for each node; traverse each node u and the corresponding amount amount in the list customer_amount', and use the if statement to compare with the data in the financial statement; if any inconsistent situation is found, record the difference and return False as a warning to remind the finance department to manually check and correct the data; if all data are verified to be correct, finally output the list customer_amount' as the list of nodes and amounts with creditor's rights and debts relationships with node v;

[0108] S3: Intelligent reduction of accounts receivable:

[0109] Define the debt chain L = (v1, e1, v2, e2,..., v n ), where v i is a node and e i is an edge, representing the creditor's rights and debts relationship;

[0110] Define the debt chain amount function as the minimum weight of all edges on the chain, and the process is as follows:

[0111] F(L) = min(w(e1), w(e2), …, w(e n-1 ), where w(e i ) is the weight of edge e i and represents the amount of creditor's rights and debts;

[0112] S3.1: Debt chain identification and extraction:

[0113] S3.1.1: Starting from any node v i in the graph G, perform a depth-first search (DFS) or breadth-first search (BFS);

[0114] S3.1.2: During the search process, record the nodes, edges and edge attributes (amounts) passed through to form the debt chain L i ;

[0115] S3.1.3: Check whether L i meets the pre-set debt chain requirements, such as being a closed loop, having no repeated nodes, etc.;

[0116] S3.1.4: If satisfied, add L i to the debt chain set L;

[0117] S3.1.5: Repeat steps S3.1.1 - S3.1.4 until all nodes in graph G have been traversed;

[0118] S3.2: Import the debt chain data into Python and use the third - party library pandas to perform debt chain pressure drop processing, and estimate the overall pressure - drop amount of the group;

[0119] S3.2.1: Take the minimum amount on each path as the pressure - drop amount and sort the pressure - drop amounts;

[0120] S3.2.2: Select the path with the largest pressure - drop amount, and subtract the pressure - drop amount from the amount on that path;

[0121] S3.2.3: Traverse other debt chains and update the amounts on other paths that contain the path with the largest pressure - drop amount;

[0122] S3.2.4: Repeat S3.2.1 - S3.2.3 until all pressure - drop amounts have been calculated;

[0123] To illustrate the effectiveness of the present invention, we extract a debt chain from the financial data provided by an enterprise group for verification. The specific data is as follows:

[0124] Nodes: A, B, C, D, E; Edges and weights (debt amounts): A->B(100w)->C(50w)->D(75w)->E(50w)->A(20w). Here, E->A represents a closed loop, and in the debt chain, we will decide whether to consider such a closed loop according to specific requirements;

[0125] Step 1: Select a starting node; in this example, we start from node A;

[0126] Step 2: In this example, we choose to perform a depth - first search; starting from node A, move along the edge A->B to node B, record this edge and the edge weight 100w and node B, and the current debt chain L i : A->B;

[0127] Step 3: Continue the search from node B, move along the edge B->C to node C, record this edge and the edge weight 50w and node C, and the current debt chain L i : A->B->C;

[0128] Step 4: Repeat the above process until all neighbor nodes are visited; in this example, we move from node C to node D; the current debt chain L i :A->B->C->D;

[0129] Step 5: Determine the debt chain L i Whether the preset conditions are met; in this example, our preset condition is that the debt chain is non-closed and has no repeated nodes, so L i If it meets the requirements of the debt chain, it will be added to the debt chain set L; the debt chain set L: A->B->C->D;

[0130] Step 6: Backtrack to the previous node (node ​​C in this example) and try to search for other unvisited neighbor nodes; if there are no unvisited neighbors, continue backtracking until you find a node with unvisited neighbors or return to the starting node; in this example, we continue to backtrack from node C until we return to the starting node A, because none of the nodes have unvisited neighbors;

[0131] Step 7: Repeat steps 2 to 6 until all nodes have been visited; in this example, we start a new search from node A, but all paths from A have been explored; therefore, we need to choose a new starting node, such as node B, and repeat the search process, and eventually all debt chains will be found;

[0132] S3.2: Calculate the amount that can be reduced in the debt chain:

[0133] Step 1: For each debt chain L i ∈L, calculate the amount F(L) that can be reduced; in this example, the debt chain L i :The amount of pressure drop of A->B->C->D F(L)=min{100w,50w,75w}=50w;

[0134] Step 2: Reduce the amount on the path and update the amount on the path. The updated path becomes A->B(50w)->C(0)->D(25w). At this time, the amount that can be reduced on the path becomes 0.

[0135] Step 3: Update the amounts in other paths including A->B, B->C, C->D;

[0136] Repeat the above steps until all the deduction amounts become 0, at which point all the deduction amounts of the group are calculated.

[0137] S4: Industry-finance linkage customer acquisition and high-frequency path query based on centrality:

[0138] S4.1.1 Create a centrality record for each node in the graph, including out-degree, in-degree, and total centrality;

[0139] S4.1.2: Calculate the out-degree of each node;

[0140] S4.1.3: Traverse all relationships in the graph;

[0141] S4.1.4: For each out-relationship (i.e., a relationship starting from one node and pointing to another node), increment the out-degree count of the starting node;

[0142] S4.1.5: Calculate the in-degree of each node;

[0143] S4.1.6: Traverse all relationships in the graph again;

[0144] S4.1.7: For each in-relationship (i.e., a relationship pointing to a node), increment the in-degree count of the ending node;

[0145] S4.1.8: Calculate the total centrality, traverse all nodes, and output the out-degree centrality, in-degree centrality, and total centrality of each node.

[0146] As shown in the data in Table 1, the out-centrality of the unit "05133210P" is 7, and the total amount is "80723059.16"; the in-centrality of the unit "064236420P" is 2, and the total amount is "6654535.01";

[0147] S4.2: Calculate the high-frequency paths:

[0148] S4.2.1: Obtain data by month, obtain the debt chain paths for this month and the debt chain paths for the previous x months, where x is a positive integer, and its specific value is set by the user according to requirements;

[0149] S4.2.2: Import the data into Python and use the third-party library pandas for frequency query;

[0150] S4.2.3: For each debt chain path in this month, compare it with other months respectively, and calculate the total frequency of each debt chain path appearing in other months;

[0151] S4.2.4: Traverse all debt chain paths within this month until all path frequencies are calculated;

[0152] S4.2.5: Sort the path frequencies to obtain all high-frequency paths under a specific threshold.

[0153] Furthermore, the terms "first" and "second" are used for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the quantity of the indicated technical features. Thus, features defined with "first" and "second" may explicitly or implicitly include at least one such feature. In the description of the present invention, "a plurality of" means at least two, such as two, three, etc., unless otherwise specifically defined.

[0154] In the description of this specification, descriptions with reference to the terms "one embodiment", "some embodiments", "examples", "specific examples", or "some examples", etc. means The specific features, structures, materials, or characteristics described in connection with the embodiment or example are included in at least one embodiment or example of the present invention. In this specification, the schematic descriptions of the above terms do not necessarily refer to the same embodiment or example. Moreover, the specific features, structures, materials, or characteristics described can be combined in a suitable manner in any one or more embodiments or examples. In addition, without contradiction, those skilled in the art can combine and combine the different embodiments or examples described in this specification and the features of different embodiments or examples.

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

Claims

1. An intelligent pressure reduction and control method for enterprise debt chains based on a dynamic knowledge graph, characterized in that, The method includes the following steps: S1: Construction of an enterprise transaction knowledge graph; S2: Debt chain query based on the knowledge graph; Define the creditor-debtor relationship query function Q(v) = "match(n:company{name:$name)-[r]-(m)returnn.name,r.money,m.name", where $name is a filling parameter used to pass in the specific company name. After inputting the node v, query the list of nodes and amounts customer_amount that have creditor-debtor relationships with it; S3: Intelligent reduction of accounts receivable; Define the debt chain L = (v1, e1, v2, e2,..., v n ), where v i is a node, and e i is an edge, representing creditor-debtor relationships; Define the debt chain amount function as the minimum weight of all edges on the chain. The process is as follows: F(L) = min(w(e1), w(e2), …, w(e n-1 ), where w(e i ) is the weight of edge e i , representing the amount of creditor's rights and debts; Use Python to implement intelligent reduction estimation. Subtract the minimum weight from the amounts on all relationships on the path queried by the debt chain, and update all debt chains until no further reduction can be made; S4: Industry-finance linkage customer acquisition and high-frequency path query based on centrality; Define the centrality C n = deg(n), where deg(n) represents the number of edges connected to node n; Out-degree centrality: Represents the number of nodes that a node points to, that is, the number of transactions that the enterprise pays to other enterprises; In-degree centrality: Represents the number of nodes that point to this node, that is, the number of transactions that other enterprises pay to this enterprise; Use the query statement "MATCH(n:Node)-[r:LINKED_TO]->()RETURN n.name,count(r)asoutgoingDegree" to obtain the number of other nodes received by each node, that is, the number of accounts receivable of each enterprise from other enterprises; Use the query statement "MATCH(n:Node)<-[r:LINKED_TO]-()RETURN n.name as nodeName,count(r)as incomingDegree" to obtain the number of nodes that each node points to other nodes, that is, the number of accounts payable of each enterprise to other enterprises; Based on this, sort the quantities to identify high-value business customers and debt risks; For high-frequency path queries, according to the debt chain L = (v1, e1, v2, e2,..., v n ), extract the monthly creditor-debtor relationships and merchant objects centered on the company from Neo4j, store the monthly merchant objects using the set object set in Python, and use the intersection and union operations of the sets to vertically compare the creditor-debtor relationships and merchant object sets in different months to find the common creditor-debtor relationships and merchant objects and the newly emerging creditor-debtor relationships and merchant objects.

2. The intelligent pressure reduction and control method for enterprise debt chains based on a dynamic knowledge graph according to claim 1, wherein: The specific steps for constructing the enterprise transaction knowledge graph are as follows: S1.1: Data extraction, use SQL query to extract transaction data from the enterprise financial system; S1.2: Data cleaning and preprocessing. For duplicate records, use the drop_duplicates statement of the third-party Python library pandas to remove duplicates; For missing values, since filling in the transaction amount will cause discrepancies in the real data, directly delete them; For the missing timestamp, if allowed by the business logic, use the transaction record date as an approximation, or use the average timestamp of adjacent records; S1.3: Entity recognition and normalization. When there are inconsistencies in the special symbols and case of the enterprise name in the raw data extracted by sql, use Python to remove special characters and spaces; S1.4: Merge business details. Model the units at the group internal level and the secondary level units separately, and merge the transactions according to the individual units and secondary units; When modeling a single entity unit, aggregate the transaction amounts according to the same names or other identifiers of the two trading parties, and merge different business details into transaction records at the single entity unit level; The same applies to the secondary level; S1.5: Entity mapping. Map the entities in the cleaned data to the nodes in the knowledge graph. Using the company name as the unique index, use the drop_duplicates statement in the pandas library of Python to ensure the exhaustiveness and uniqueness of each enterprise entity. Then, use Python to generate a csv file that only contains nodes and attributes; S1.6: Relationship mapping. For each transaction record, connect the enterprise nodes of the two trading parties with an edge, and assign the corresponding timestamp and weight. Finally, use Python to generate a csv file that only contains relationships.

3. The intelligent pressure reduction and control method for enterprise debt chains based on a dynamic knowledge graph according to claim 1, wherein: The specific process of the debt chain query based on the knowledge graph is as follows: S2.1: Conduct a breadth-first search starting from the target node v; S2.2: Traverse the nodes directly connected to v, and record the creditor-debtor relationship and the corresponding amount: After the breadth-first search ends, the list customer_amount will store all the nodes that have a creditor-debtor relationship with node v and their corresponding amounts; S2.3: Sort in descending order according to the amount to obtain the sorted list customer_amount'; Use the sort function of the sorting algorithm. Using the amount in the tuple as the index, sort the list customer_amount in descending order. The sorted list is customer_amount'; Extract the node part from the sorted list customer_amount' to form a node set Nodeset, that is, Nodeset = u|(u, amount) ∈ customer_amount′; S2.4: Check the accuracy of the results in different customer_amount' against the financial statement data: Obtain the financial statement data corresponding to node v, including the creditor-debtor amounts with each node; Traverse each node u and the corresponding amount amount in the list customer_amount', and use the if statement to compare with the data in the financial statements; If any inconsistent situation is found, record the difference and return a False warning to remind the finance department to manually check or correct the data; If all the data is checked and correct, finally output the list customer_amount' as the list of nodes and amounts that have a creditor-debtor relationship with node v.

4. The intelligent pressure reduction and control method for enterprise debt chains based on a dynamic knowledge graph according to claim 3, characterized in that: The specific process of conducting a breadth-first search starting from the target node v is as follows: Initialize a queue Q_node and add the starting node v to this queue; initialize a set V visited , which is used to store the visited nodes, and add v to V initially visited ; Initialize an empty list customer_amount to record the creditor-debtor relationship and the corresponding amount. Each element is a tuple indicating that the creditor-debtor amount between node u and node v is amount; When the queue Q_node is not empty, repeat the following steps: S2.1.1: Take out a node v from the queue Q_node; S2.1.2: Traverse all nodes u directly connected to node v. If u is not in V visited add it to V visited and queue Q_node; When there is a creditor-debtor relationship between v and u, update the list customer_amount, with u as the customer in the tuple and the corresponding creditor-debtor amount as the amount in the tuple; If the amount already exists, overwrite and create.

5. The intelligent pressure reduction and control method for enterprise debt chains based on a dynamic knowledge graph according to claim 1, wherein: The specific steps for intelligent reduction of accounts receivable are as follows: S3.1: Debt chain identification and extraction: S3.1.1: Starting from any node v of the graph G i perform a depth-first search or a breadth-first search; S3.1.2: During the search process, record the nodes, edges, and edge attributes passed through to form a debt chain L i ; S3.1.3: Check L i to see if it meets the pre-set debt chain requirements, including closed loops and non-repeating nodes; S3.1.4: When the pre-set debt chain requirements are met, add L i to the debt chain set L; S3.1.5: Repeat steps S3.1.1 - S3.1.4 until all nodes in the graph G have been traversed; S3.2: Calculate the amount that can be reduced in the debt chain: For each debt chain L i ∈ L, calculate its pressure drop amount F(L):

6. The intelligent pressure reduction and control method for enterprise debt chains based on a dynamic knowledge graph according to claim 1, characterized in that: The steps for customer acquisition through the integration of industry and finance are as follows: S4.1.1: Create a centrality record for each node in the graph, including out-degree, in-degree, and total centrality; S4.1.2: Calculate the out-degree of each node; S4.1.3: Traverse all relationships in the graph; S4.1.4: For each out-relationship, increment the out-degree count of the starting node; S4.1.5: Calculate the in-degree of each node; S4.1.6: Traverse all relationships in the graph again; S4.1.7: For each in-relationship, increment the in-degree count of the ending node; S4.1.8: Calculate the total centrality, traverse all nodes, and output the out-degree centrality, in-degree centrality, and total centrality of each node; S4.2: Calculate the high-frequency paths: S4.2.1: Obtain data monthly, getting the debt chain paths for this month and the debt chain paths for the previous x months; S4.2.2: Import the data into Python and use the third-party library pandas for frequency query; S4.2.3: For each debt chain path in this month, compare it with other months respectively and calculate the total frequency of each debt chain path appearing in other months; S4.2.4 Traverse all debt chain paths within this month until all path frequencies are calculated; S4.2.5 Sort the path frequencies to obtain all high-frequency paths under a specific threshold.

Images