Knowledge graph-based engineering cost abnormity intelligent identification method and system

Abstract

The invention discloses a knowledge graph-based engineering cost abnormity intelligent identification method and system, particularly relates to the technical field of construction engineering cost management, and is used for solving the problems of low calculation efficiency and poor abnormity identification timeliness when deep multi-hop association query is executed in a large-scale engineering knowledge graph in the prior art. The method comprises the following steps of: decomposing multi-hop query into sub-graph query tasks limited in same entity type groups by constructing a group marked engineering cost knowledge graph; semantic density is obtained based on weighted statistics of the number of relations between entities in the sub-graphs, and the change influence degree is calculated and evaluated in combination with the information entropy of the change propagation directed graph; dynamically selecting a historical cache or parallel query execution mode according to double thresholds of the semantic density and the change propagation entropy; and finally aggregating path results, and identifying an abnormal conduction chain through a cost attribute gradient change detection mechanism of adjacent engineering entities. And the positioning efficiency and the recognition precision of the deep-level cost anomaly are remarkably improved.

Description

Technical Field

[0001] This invention relates to the field of construction project cost management technology, and more specifically, to a knowledge graph-based intelligent identification method and system for anomalies in construction project costs. Background Technology

[0002] In the field of construction project cost management, accurately and promptly identifying anomalies in cost data is crucial for controlling project risks and ensuring benefits. In recent years, knowledge graph technology, due to its powerful semantic association and reasoning capabilities, has been introduced into this field to construct a structured knowledge system for construction project cost. By integrating multi-source heterogeneous information such as historical project data, bills of quantities, material prices, contract terms, and design information, a knowledge graph describing project entities (such as sub-items, materials, equipment, processes, suppliers, etc.) and their complex relationships is formed. Based on this graph, the system can perform relational queries and rule-based reasoning to automatically discover potential risk points such as cost deviations, price anomalies, and unreasonable quantities.

[0003] However, existing knowledge graph-based methods for identifying anomalies in engineering cost data struggle to handle large-scale, highly correlated real-world engineering data. When identifying anomalies caused by deep-seated, multi-stage factors (e.g., design changes leading to changes in specific material requirements, which in turn affect the costs of related subcontracting contracts), the system needs to perform long-path association reasoning across multiple entities and relationships within the graph. This complex multi-hop query and reasoning operation consumes significant computational resources and generates severe processing delays when executed on an engineering knowledge graph containing massive nodes and edges. This directly restricts the system's ability to identify deep-seated anomalies and makes it difficult to meet the actual needs of engineering cost monitoring for timely analysis. Summary of the Invention

[0004] In order to overcome the above-mentioned defects of the prior art, the present invention provides a knowledge graph-based intelligent identification method and system for engineering cost anomalies to solve the problems mentioned in the background art.

[0005] To achieve the above objectives, the present invention provides the following technical solution:

[0006] A knowledge graph-based intelligent identification method for engineering cost anomalies includes:

[0007] S1. Construct a knowledge graph of engineering cost that includes engineering entities and the relationships between entities, and group and label the engineering entities according to entity type;

[0008] S2. Receive and parse the start and end entities in the multi-hop association query request;

[0009] S3. Based on the entity type grouping labels of the starting entity and the ending entity, decompose the multi-hop association query request into multiple subgraph query tasks. Each subgraph query task is limited to performing path search within the same entity type group.

[0010] S4. Based on the number of relationships between entities within the subgraph query task, semantic density is obtained through weighted statistical analysis; based on the change propagation directed graph of the subgraph query task, change propagation entropy is calculated using information entropy.

[0011] S5. Select the execution method for the subgraph query task: when the semantic density is higher than the first threshold and the change propagation entropy is lower than the second threshold, call the historical cache data; otherwise, execute the parallel query.

[0012] S6. The results of the aggregated parallel query are combined with historical cached data to generate a complete association path. Cost anomalies are identified based on the attribute gradient changes between adjacent engineering entities in the complete association path.

[0013] Furthermore, an engineering cost knowledge graph containing engineering entities and the relationships between entities is constructed, and the engineering entities are grouped and labeled according to entity type, including:

[0014] Define the entities of sub-items, materials and equipment, process activities, and supplier units in the engineering cost knowledge graph;

[0015] Construct material supply relationships, process connection relationships, and cost allocation relationships between engineering entities in the engineering cost knowledge graph;

[0016] Based on entity type, all engineering entities in the engineering cost knowledge graph are grouped and labeled to form material group labels, process group labels, and organization group labels.

[0017] The grouping tags are associated with the attribute information of the engineering entities and stored in the corresponding nodes of the engineering cost knowledge graph.

[0018] Furthermore, it receives and parses the starting and ending entities in a multi-hop related query request, including:

[0019] Receive the text of a multi-hop related query request input by the user;

[0020] Identify the starting and ending entity names from the multi-hop related query request text;

[0021] The starting entity is selected by matching the engineering entity name corresponding to the starting entity name based on the engineering cost knowledge graph.

[0022] The project entity corresponding to the name of the termination entity is selected as the termination entity based on the knowledge graph of project cost.

[0023] Verify the existence status of the starting and ending entities in the engineering cost knowledge graph and the grouping labels of entity types.

[0024] Furthermore, based on the entity type grouping tags of the starting and ending entities, the multi-hop association query request is decomposed into multiple subgraph query tasks. Each subgraph query task is limited to performing path search within the same entity type group, including:

[0025] Determine the entity type grouping tag corresponding to the starting entity and the entity type grouping tag corresponding to the ending entity;

[0026] Based on the grouping labels of all entity types in the engineering cost knowledge graph, the sequence of entity type groups that the starting entity must pass through to the ending entity is divided.

[0027] For each entity type group in the entity type grouping sequence, generate a corresponding subgraph query task;

[0028] In the subgraph query task, the path search scope is limited to the engineering entities and relationships between entities within the corresponding entity type group;

[0029] The output contains a set of subgraph query tasks that are limited by the path search range.

[0030] Furthermore, based on the number of relationships between entities within the subgraph query task, semantic density is obtained through weighted statistical analysis, including:

[0031] Count the number of direct relationship connections between all engineering entities in the subgraph query task;

[0032] Obtain the predefined relation type weight coefficients from the engineering cost knowledge graph;

[0033] The number of direct relation connections is calculated by weighted summation based on relation type weight coefficients;

[0034] The semantic density is obtained by dividing the weighted summation result by the total number of engineering entities included in the subgraph query task.

[0035] Furthermore, based on the directed graph of change propagation for the subgraph query task, the change propagation entropy is calculated using information entropy, including:

[0036] Construct a directed graph of change propagation and count the out-degree of change propagation for each engineering entity node in the graph;

[0037] Calculate the probability distribution of the propagation degree of changes to all engineering entity nodes;

[0038] The change propagation entropy value is calculated based on the information entropy calculation formula applied to the probability distribution.

[0039] Furthermore, the execution method for the subgraph query task is selected: when the semantic density is higher than the first threshold and the change propagation entropy is lower than the second threshold, historical cached data is invoked; otherwise, parallel queries are executed, including:

[0040] Obtain the semantic density calculation results and change propagation entropy calculation results for the subgraph query task;

[0041] The semantic density calculation result is numerically compared with a predefined first threshold;

[0042] The change propagation entropy calculation result is numerically compared with a predefined second threshold;

[0043] When the semantic density calculation result is higher than the first threshold and the change propagation entropy calculation result is lower than the second threshold, the historical cached data corresponding to the subgraph query task is retrieved from the historical query result library.

[0044] Otherwise, start the parallel query engine to perform parallel path search on the subgraph query task.

[0045] Furthermore, the results of the aggregated parallel queries are combined with historical cached data to generate a complete association path. Cost anomalies are identified based on attribute gradient changes between adjacent engineering entities in the complete association path, including:

[0046] Connect the path search results returned by the parallel query engine with the historical cached data called from the historical query results library.

[0047] Construct a complete association path from the starting entity to the ending entity based on the path connection results;

[0048] Extract each pair of adjacent engineering entities sequentially within the complete associated path;

[0049] Calculate the cost attribute value difference for each pair of adjacent engineering entities as the attribute gradient change;

[0050] When the change in attribute gradient exceeds a predefined cost anomaly threshold, the corresponding entity is marked as having a cost anomaly in its adjacent engineering entity.

[0051] On the other hand, the present invention provides a knowledge graph-based intelligent identification system for engineering cost anomalies, comprising:

[0052] The graph construction module is used to build an engineering cost knowledge graph that includes engineering entities and the relationships between entities, and to group and label engineering entities according to entity type;

[0053] The request parsing module is used to receive and parse the start and end entities in multi-hop related query requests;

[0054] The request decomposition module is used to decompose multi-hop association query requests into multiple subgraph query tasks based on the entity type grouping tags of the starting entity and the ending entity. Each subgraph query task is limited to performing path search within the same entity type group.

[0055] The task analysis module is used to query the number of relationships between entities within a task based on a subgraph, and obtain semantic density through weighted statistical analysis; it also queries the directed graph of change propagation for a task based on a subgraph, and calculates the change propagation entropy using information entropy.

[0056] The execution selection module is used to select the execution method for subgraph query tasks: when the semantic density is higher than the first threshold and the change propagation entropy is lower than the second threshold, historical cached data is called; otherwise, parallel queries are executed.

[0057] The path generation module is used to aggregate the results of parallel queries and historical cached data to generate complete association paths, and to identify cost anomalies based on the attribute gradient changes between adjacent engineering entities in the complete association path.

[0058] Compared with the prior art, the present invention has the following beneficial effects:

[0059] 1. By constructing an engineering entity grouping and labeling mechanism, massive knowledge graph data is divided into logical subgraphs according to entity type, enabling subsequent query tasks to be executed within specific groups, significantly reducing the computational complexity of multi-hop association queries. Then, a dual evaluation index of semantic density and change propagation entropy is introduced. Semantic density quantifies the strength of entity associations within the subgraph through weighted statistics, while change propagation entropy assesses the degree of change impact diffusion based on information entropy theory. The two work together to form the basis for intelligent query decision-making. Finally, by dynamically selecting the execution path of historical cache or parallel query, and combining it with the attribute gradient change detection mechanism of adjacent engineering entities, the accurate location of anomalies is achieved.

[0060] 2. The grouping and labeling mechanism provides a structured foundation for subgraph partitioning, semantic density calculation accurately captures the internal association features of subgraphs, change propagation entropy analysis effectively assesses the risk of change propagation, dual-threshold decision model dynamically optimizes query strategies, complete path aggregation ensures the continuity of analysis, and attribute gradient detection enables the visual tracking of abnormal propagation chains. The technical approach of organically integrating knowledge graph grouping optimization, association strength quantitative evaluation, change propagation modeling, and distributed query scheduling effectively solves the efficiency bottleneck of large-scale engineering knowledge graph queries. Attached Figure Description

[0061] Figure 1 This is a flowchart of a knowledge graph-based intelligent identification method for engineering cost anomalies according to the present invention.

[0062] Figure 2This is a schematic diagram of the structure of an intelligent identification system for engineering cost anomalies based on knowledge graphs according to the present invention. Detailed Implementation

[0063] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0064] Example 1: Figure 1 This invention presents a knowledge graph-based intelligent identification method for engineering cost anomalies, comprising:

[0065] S1. Construct a knowledge graph of engineering cost that includes engineering entities and the relationships between entities, and group and label the engineering entities according to entity type;

[0066] S2. Receive and parse the start and end entities in the multi-hop association query request;

[0067] S3. Based on the entity type grouping labels of the starting entity and the ending entity, decompose the multi-hop association query request into multiple subgraph query tasks. Each subgraph query task is limited to performing path search within the same entity type group.

[0068] S4. Based on the number of relationships between entities within the subgraph query task, semantic density is obtained through weighted statistical analysis; based on the change propagation directed graph of the subgraph query task, change propagation entropy is calculated using information entropy.

[0069] S5. Select the execution method for the subgraph query task: when the semantic density is higher than the first threshold and the change propagation entropy is lower than the second threshold, call the historical cache data; otherwise, execute the parallel query.

[0070] S6. The results of the aggregated parallel query are combined with historical cached data to generate a complete association path. Cost anomalies are identified based on the attribute gradient changes between adjacent engineering entities in the complete association path.

[0071] In constructing the engineering cost knowledge graph, the definition of engineering entities is achieved by parsing the following technical documents: Sub-item engineering entities can be defined with reference to the national standard "Specification for Construction Engineering Quantity List Pricing." The quantity list code in their entity attribute information adopts the 12-digit hierarchical coding structure specified in this standard. The first two digits represent the professional engineering code, the middle five digits represent the sub-item engineering sequence code, and the last five digits represent the sub-item engineering project code. Quota labor consumption is obtained by accessing the construction company's enterprise quota database, specifically extracting values ​​from the "labor man-days" field of the labor, material, and machinery consumption table, with the unit of measurement being man-days. The benchmark unit price of materials and equipment entities is obtained by periodically accessing the engineering cost information platform published by the provincial engineering cost management agency. A data synchronization task is automatically executed at 1:00 AM daily, verifying the mapping relationship between material codes and knowledge graph codes during synchronization. A manual review process is triggered when a code change is detected. The pre-process constraints of the process activity entities are generated by parsing the process flow diagram in the construction organization design document. Natural language processing technology is used to identify the process names following keywords such as "preceding process" and "immediate work" in the document, and fuzzy matching of the names with the process activity entities in the knowledge graph is performed. The historical performance evaluation scores of the supplier entity are obtained monthly through the API interface of the public service platform for engineering construction supervision, which retrieves the construction unit rating data of the supplier in the projects undertaken in the past three years, calculates the arithmetic mean, and retains two decimal places.

[0072] The specific implementation of the method for constructing relationships between engineering entities is as follows: The weight coefficient setting of material supply relationships is divided into two stages: The initialization stage calculates the cost proportion of the material in the quota consumption of the corresponding sub-item project. For example, the quota consumption of steel bars in reinforced concrete engineering is 5 tons / 100 cubic meters, and the unit price of steel bar material is 5,000 yuan / ton. Then the cost proportion = (5 × 5,000) ÷ the direct cost of the quota of the sub-item project × 100%; The calibration stage analyzes historical engineering settlement data through a linear regression model. The model input parameters include the material price fluctuation coefficient (taken from the monthly report of the engineering cost information platform) and the actual supply deviation rate (the ratio of the difference between the contract quantity and the actual quantity). The output is the weight correction factor, and the final weight = initial proportion × correction factor.

[0073] The weighting coefficients for process connection relationships are calculated using the critical path method: First, the total float of the process is calculated based on the schedule network diagram: Total float = latest start time - earliest start time; then, the weights are set according to the formula: Weighting coefficient = 1 / (1 + total float / baseline duration), where the baseline duration is the average duration of the critical processes in the project. For example, if the total float of a process is 5 days and the baseline duration is 10 days, then the weight = 1 / (1 + 5 / 10) = 0.67. The weighting coefficients for cost allocation relationships are set based on the target cost breakdown table approved by the construction unit. This table clearly defines the allocation ratio of the cost of each sub-item to the process activity. For example, if the total cost of a concrete project is 1 million yuan, and the formwork project accounts for 300,000 yuan, then the corresponding cost allocation weighting coefficient is set to 0.3.

[0074] The grouping tag generation and storage technology includes: Material grouping tags are generated by parsing the 3rd and 4th digits of the material / equipment code's category code. The system has a pre-set category code mapping table; for example, code 0401 represents steel reinforcement, and 0402 represents concrete. Validity verification is performed during generation: if the entity code is not included in the mapping table, it is automatically classified as "Other Materials" and an alarm log is triggered. Process grouping tags are generated according to construction stage division rules. The rule base comes from the construction organization design document approved by the supervising engineer. The system extracts the process list from the "Construction Stage Division" section through text parsing; for example, "Main Structure Stage: Includes all processes numbered GX1001 to GX1500". Organization grouping tags are generated according to the following rules: First, the professional contracting category field in the scanned copy of the supplier's qualification certificate is read; then, it is matched against the qualification level classification table in the "Construction Enterprise Qualification Standards." For example, qualification number D201 represents a first-class qualification for steel structure engineering professional contracting.

[0075] The associated storage of grouping tags and entity attributes is achieved through the hybrid indexing mechanism of the graph database: create a combined index of node tags and attributes in the Neo4j graph database. For example, create an index for the material class grouping: CREATE INDEX ON :MaterialGroup(material_code, base_price). The stored procedure includes three layers of verification: the first layer verifies the dimensional consistency. The cost-related attribute values must be associated with the currency unit (RMB yuan). When it is found that the unit is not marked, the storage is automatically terminated and the error code E1001 is returned; the second layer verifies the numerical range. For example, the benchmark unit price of materials cannot be negative. If a negative value is detected, it is replaced with the nearest valid value and the abnormal event is recorded; the third layer verifies the logical consistency between the grouping tag and the entity type. For example, when the entity type is "material equipment", its grouping tag must contain the prefix "Material", otherwise the data repair service is started. The attribute update mechanism is designed as a dual-channel synchronization: the real-time channel processes the manual updates by users, and the index is refreshed immediately after the update; the batch channel processes the system-level updates at 0:00 every day, and the concurrency conflict is controlled by the version number (format YYYYMMDD_001). The storage structure of the grouping tag supports dynamic expansion. Each grouping tag is associated with an attribute change history table. For example, the material benchmark unit price change history table contains fields: effective date, unit price value, and document number of the change basis.

[0076] Receiving the multi-hop association query request text input by the user is implemented through the interaction interface of the project cost analysis system. This interface supports two input modes: structured form mode and free text mode. When the free text mode is adopted, the system starts the natural language parsing process. The parsing process loads the pre-set project cost term dictionary for professional term extraction. This dictionary contains all the engineering entity type names and standard alias mapping relationships defined in S1. The term extraction adopts the maximum forward matching algorithm. The algorithm parameter settings include: the maximum word length is set to 12 characters, and the stop word filter table contains non-entity words such as "of", "query", and "analysis". The rules for identifying the starting entity name and the ending entity name are defined as: locate the noun phrase after a specific preposition in the text as the candidate name. Among them, the phrase after "from" or "starting from" is identified as the candidate for the starting entity name, and the phrase after "to" or "ending at" is identified as the candidate for the ending entity name. For example, for the input text "Analyze the association path from the steel bar supplier to the concrete pouring process", the "steel bar supplier" is identified as the candidate for the starting entity name, and the "concrete pouring process" is identified as the candidate for the ending entity name.

[0077] Multi-hop association query requests refer to query instructions that search for indirect association paths from the starting project entity to the ending project entity within the engineering cost knowledge graph. This path must penetrate relationships between at least two entities. For example, querying the complete transmission chain of "reinforcing steel supplier (starting entity) → reinforcing steel material → concrete engineering → pouring process (ending entity)" can be used to trace the transmission impact of material supply anomalies on construction costs. Its core feature is the formation of a complete analysis path through the interconnection of multiple sets of entity relationships.

[0078] The operation process for matching entity names based on the engineering cost knowledge graph is as follows: Standardized preprocessing is performed on the identified entity names, including unified conversion of full-width and half-width characters and removal of illegal characters (only Chinese characters, English letters, numbers, and underscores are retained). The matching process implements a three-level retrieval mechanism: The first level is exact matching, which searches for records in the knowledge graph node attributes where the "entity name" field is completely identical. For example, inputting "HRB400 steel bar" matches the material / equipment entity name field. The second level is fuzzy matching, which calculates the edit distance of the name strings when exact matching yields no results. A similarity threshold of 80% or higher is considered a valid match. For example, inputting "concrete pouring" and "concrete pouring process" has a similarity calculation result of 85%, indicating a successful match. The third level is synonym expansion matching, which expands the query through a pre-built thesaurus derived from the national standard "Engineering Cost Terminology Standard". For example, inputting "concrete supplier" automatically expands the query to "concrete supplier". The matching priority rule is: prioritize the entity node with the highest activity in the last 30 days. The activity calculation formula is: Activity = Number of visits × 0.6 + Number of attribute updates × 0.4. The calculation result is rounded to three decimal places.

[0079] The process of verifying the starting and ending entities includes existence status verification and grouping mark verification. Existence status verification is achieved by querying the status flags of the graph database nodes: the status flags contain three preset status values: "Valid" indicates the node is accessible, "Historical" indicates the node is archived, and "Deleted" indicates the node is logically deleted. Verification passes only when the status value is "Valid". Grouping mark verification performs the following steps: It retrieves the entity type grouping mark rule base defined by S1. The rule base defines the mandatory correspondence between grouping mark prefixes and entity types; for example, the grouping mark prefix for sub-item engineering entities is "FB_", and the prefix for material and equipment entities is "CL_". It checks whether the prefix of the "grouping mark" field in the attributes of the matched engineering entity nodes matches its entity type definition. The verification exception handling mechanism is as follows: when the existence status is "Deleted", error code E2001 is returned and similar entities are recommended; when the grouping mark prefix does not match, the grouping mark generation algorithm of S1 is called to recalculate and update the grouping mark.

[0080] The technical parameters of the data processing flow include: the maximum length of the input text is set to 200 characters; excessively long texts trigger an automatic segmentation mechanism. The matching operation has a timeout control threshold of 5000 milliseconds; after the timeout, cached matching results from the most recent 72 hours are returned. During the verification phase, an audit log is generated, with fields including: the original input text, the name of the identified entity, the identifier of the matched entity node (format: ENTITY_type encoding_8-bit hash value), and the verification result status code. The output data structure includes a global identifier for the starting entity, a global identifier for the ending entity, and a verification report with entity type grouping tags. The multi-entity processing rule is as follows: when multiple candidate starting entities are identified, the system calculates the relevance score between each candidate entity and the ending entity. Relevance score = number of historical association paths × 0.7 + average relationship weight × 0.3; the entity with the highest score is selected as the default result.

[0081] The terminology dictionary is stored using a Redis hash structure, with keys being standardized terminology strings and values ​​being entity type encoded strings. The edit distance algorithm for fuzzy matching is implemented by initializing a two-dimensional matrix to store intermediate results and iteratively calculating the minimum number of single-character edit operations required for string transformation (insertion, deletion, and replacement operations all have a cost of 1). The grouping and tagging validation rule base is stored in JSON format, with the structure {"entity type":"prefix","validation rule":"regular expression"}. All operations are exposed via an HTTP interface, and the input and output data format conforms to the JSON API specification. The exception code system includes: E2001 indicating that the entity does not exist, E2002 indicating a grouping and tagging exception, and E2003 indicating a matching timeout.

[0082] The entity type grouping tags for the starting and ending entities are determined by accessing the knowledge graph node storage structure. The specific execution process is as follows: The attribute set of the starting entity node is read, and the field value named "Grouping Tag" is extracted. This field value is generated and stored by the grouping tag generation service in step S1. Simultaneously, the same attribute field of the ending entity node is read. For example, when the starting entity is a supplier entity, its grouping tag field value is "ZZ_Steel Structure Supplier"; when the ending entity is a process activity entity, the grouping tag field value is "GX_Main Structure Process". The extraction process includes data integrity verification: if an empty grouping tag field value is detected, the grouping tag completion service in S1 is called to recalculate the field value; if the field value prefix does not match the entity type (e.g., a supplier entity has a "CL_" prefix), an error handling process is triggered, error code E3001 is recorded, and the current operation is terminated.

[0083] The technical solution for dividing entity type grouping sequences includes: constructing a grouping topology graph, where nodes are labels for all entity type groups, and edges represent the probability of historical association paths existing between groups. The partitioning algorithm employs an improved breadth-first search: during initialization, the starting group label is added to a queue; the adjacent group set of the current group is iteratively visited, with adjacency relationships derived from a historical query path database (storing successfully executed association paths within the last 30 days); when the terminating group is visited, a sequence is generated by backtracking. The sequence generation rules are: prioritize the sequence with the fewest path hops; when multiple sequences with the same number of hops exist, select the sequence with the highest historical query frequency. For example, the starting group "ZZ_Steel Structure Supplier" and the terminating group "GX_Main Structure Process" might generate the following sequence: ZZ_Steel Structure Supplier → CL_Steel Material → FB_Reinforced Concrete Engineering → GX_Main Structure Process. The maximum sequence length is set to 5 hops; if the maximum is exceeded, a null value is returned and error code E3002 is recorded.

[0084] The operation flow for generating a subgraph query task is as follows: traverse each grouping label in the grouping sequence and create an independent query task instance. The task instance contains the following attributes: target grouping label (e.g., "CL_Steel Class"), path search constraints, and task identifier (format: TASK_Sequence Position_8-bit Random Code). Path search constraints are implemented using graph query syntax: add node label filtering conditions to the relation traversal operation to limit processing to nodes with specific grouping labels. For example, in the relation query statement, nodes must have the label "CL_Steel Class". Redundancy detection is performed during task generation: when the same grouping label appears consecutively in the sequence, they are merged into a single task, and the search depth is expanded to the sum of the depths of the tasks before merging.

[0085] The technical implementation of limiting the path search scope includes defining a dual filtering mechanism in the subgraph query task. The node filtering rule is: only entity nodes with the current group label are processed, and this label exactly matches the "group label" field in the node attributes. The relationship filtering rule is: only the three relationship types defined in S1 (material supply relationship, process connection relationship, and cost attribution relationship) are allowed to participate in the path search. The search depth parameter is dynamically configured according to the sequence position: the depth of tasks at the beginning and end of the sequence is 1, and the depth of tasks in the middle is 2. For example, in the task at the second position of the group sequence, it is allowed to start from the steel entity and reach the sub-project entity through two hops of relationships. Scope limitation is implemented through the graph database traversal interface, and the calling parameters include: target group label, list of allowed relationship types, and maximum depth value.

[0086] The final processing flow for the output subgraph query task set is as follows: Task instances are organized into an ordered list, with the list order strictly consistent with the grouping sequence. Each task instance is encapsulated as a JSON object, containing: task identifier, target group tag, path search constraints, and execution priority. Priority is calculated using the formula: Priority = 10 - Sequence Position × 2 + Group Activity × 0.1, where group activity is taken from the average daily query count statistics of the monitoring system. Before output, task dependency validation is performed: it checks whether the output entity set of the preceding task contains the input entities required by the current task. If a dependency is detected as missing, an entity parsing subtask is automatically inserted (error code E3003). The task set is stored in a distributed task queue, and task distribution is implemented using message middleware. The base value of the task timeout threshold is set to 3000 milliseconds, and the dynamic adjustment formula is: Timeout Threshold = Base Value × (1 + Number of Group Entities / 100000), where the number of entities is obtained in real-time from the knowledge graph statistics service.

[0087] When constructing the group topology graph, the probability threshold for historical associated paths is set to 0.05 (i.e., at least 5% of historical paths contain jumps to this group); the 8-bit random code of the task identifier is generated using the CRC32 algorithm; entity matching in dependency verification uses a node ID exact matching mechanism. All error codes are defined as follows: E3001 indicates an abnormal group labeling, E3002 indicates an excessively long sequence, and E3003 indicates a missing dependency.

[0088] The specific operational process for counting the number of direct relationship connections in a subgraph query task is as follows: Traverse all engineering entity nodes within the scope of the subgraph query task, and obtain the number of relationship connections for each node through the node degree interface of the graph database. Node degree includes two values: out-degree and in-degree. The out-degree represents the number of relationships where the node is the starting entity, and the in-degree represents the number of relationships where the node is the ending entity. The formula for calculating the total number of direct relationship connections is: add the sum of the out-degrees and the sum of the in-degrees of all nodes and divide by 2. This calculation method eliminates duplicate counting of relationships at the beginning and end nodes. For example, if a subgraph contains 5 engineering entity nodes with out-degree values ​​of 3, 2, 4, 3, and in-degree values ​​of 2, 3, 3, 4, and 3 respectively, then the total number of direct relationship connections = (15 + 15) / 2 = 15. The statistical process excludes self-circulating relationships and only counts the three valid relationship types defined in S1: material supply relationship, process connection relationship, and cost attribution relationship. During the data preprocessing stage, relationship records marked as "historical" are filtered to ensure that only valid relationship connections are counted.

[0089] The technical implementation for obtaining relation type weight coefficients includes: accessing the central relation attribute database of the engineering cost knowledge graph, which stores the latest weight coefficient values ​​for various relations. The rules for generating relation type weight coefficients are defined as follows: the weight coefficient for material supply relations is calculated by weighting the proportion of material cost in the total cost of the sub-item project with the supply stability coefficient, where the cost proportion weight coefficient is 0.7 and the supply stability coefficient weight coefficient is 0.3; the weight coefficient for process connection relations is calculated based on the ratio of the total process float to the baseline construction period; the weight coefficient for cost allocation relations directly adopts the allocation ratio value from the target cost decomposition table. Weight coefficients are stored in a relation configuration table, which contains three fields: relation type code, weight value, and effective timestamp. For example, the standard weight value for material supply relations is 0.75; when a specific project has special settings, a project-specific value is used. The version control mechanism is as follows: when multiple effective versions exist, the latest version weight value prior to the current task execution time is automatically selected.

[0090] The specific steps for weighted summation are as follows: Create a mapping dictionary between relation types and weights, where the dictionary key is the full name of the relation type and the dictionary value is the corresponding weight coefficient. Iterate through the set of direct relation connections obtained from the statistics, performing the following operations for each relation connection: identify its relation type identifier → query the mapping dictionary to obtain the weight coefficient → calculate the weighted value of the connection (weighted value = 1 × weight coefficient). The final weighted summation result is the arithmetic sum of the weighted values ​​of all relation connections. The calculation process includes data validation rules: when an undefined relation type is detected, a default weight value of 0.5 is used and an alarm event is recorded; when the weight coefficient is greater than 1, it is automatically corrected to 1, and when it is less than 0, it is corrected to 0. For example, if a subgraph's statistical results include 10 material supply relationships (weight 0.75) and 5 process connection relationships (weight 0.85), then the weighted summation result = 10 × 0.75 + 5 × 0.85 = 11.75.

[0091] The technical solution for semantic density calculation is as follows: Obtain the total number of engineering entities within the subgraph query task scope, and return the number of valid entities through the graph database node statistics interface. Semantic density = weighted summation result / total number of engineering entities. The calculation result is rounded to three decimal places and is a dimensionless value. The post-processing workflow includes: result range verification (normal value range is 0 to 5), triggering a recalculation verification process when the calculation result is greater than 5; and a zero-value handling mechanism (returning a specific error code E4001 when the total number of entities is 0). For example, if the weighted summation result of a subgraph is 8.25, containing 10 engineering entities, then the semantic density = 8.25 / 10 = 0.825. The calculation result is written to the semantic density field of the task result object.

[0092] The weight coefficient update mechanism is set to execute automatically on a regular basis, with an update cycle of 30 days, recalculating coefficient values ​​based on newly added project data. Weighted summation calculations use double-precision floating-point arithmetic, with rounding rules set to round to even numbers. The semantic density threshold is set as follows: values ​​below 0.3 are considered low correlation density, and values ​​above 1.2 are considered high correlation density; this threshold is determined based on statistical analysis of historical task data. The exception handling code system includes: E4001 indicating an empty entity set exception, E4002 indicating a missing weight coefficient exception, and E4003 indicating a calculation result overflow exception. Detailed audit logs are recorded throughout the entire process, with log fields including snapshots of input parameters, intermediate calculation results, and the final output value.

[0093] The relation count is performed using the node degree calculation interface of a graph database; weight coefficients are stored using a configuration table of a relational database; and the computation service is deployed in an independent computing unit. The input data structure is defined as a task identifier, entity count, and a set of relation type statistics; the output structure includes semantic density values ​​and status codes. Performance optimization measures include: initiating a block-based computation mechanism when the number of entities exceeds 500, with each computation block containing 100 entity nodes. The computation result caching mechanism is set to a validity period of 24 hours; duplicate requests with the same task identifier directly return the cached value.

[0094] When the weight coefficient of a process connection relationship is detected to be 1.25, it is automatically corrected to 1.0 before being included in the calculation; when a subgraph contains 3 entity nodes but the total number of relationships is 0, the semantic density calculation result is 0 and marked as a valid value; when an abnormal grouping label causes the total number of entities to be 0, error code E4001 is returned and the subsequent processing flow is terminated. All calculation operations are recorded with a complete audit trail to ensure that the calculation results are traceable and verifiable.

[0095] The technical implementation process of constructing a directed graph for change propagation is as follows: Based on a subgraph query task, the engineering entity nodes and change propagation relationships between entities are extracted. Change propagation relationships are limited to a subset of three types of relationships: material supply relationships, process connection relationships, and cost allocation relationships. This subset is obtained by filtering the change impact flag field in the relationship attributes; if the flag value is true, it is included in the directed graph. The node set of the directed graph is all engineering entity nodes within the subgraph. Edges represent the change propagation direction, and the specific rules for setting the direction are: in material supply relationships, the propagation direction is from the supplier to the material recipient; in process connection relationships, the propagation direction is from the preceding process to the subsequent process; and in cost allocation relationships, the propagation direction is from the cost source to the cost bearer. For example, when a steel reinforcement supplier changes its price, the propagation direction is set to the supplier entity point to the steel reinforcement material entity, and then to the concrete engineering entity. The graph is stored in an adjacency list format, with each node recording a list of identifiers for its direct successor nodes.

[0096] The specific operations for calculating the out-degree of change propagation include: traversing all engineering entity nodes in the directed graph of change propagation and calculating the out-degree value of each node. The out-degree of change propagation is defined as the number of successor nodes directly reachable from that node via the change propagation relationship. The calculation method is to query the length of the successor node list corresponding to that node in the adjacency list structure. For example, if a concrete engineering node has three outgoing edges pointing to the pouring process node, the curing process node, and the inspection process node respectively, then its out-degree value is 3. The statistical process excludes the influence of loop paths; when a propagation path with consecutive beginnings and end is detected, only the first occurrence of the propagation relationship is retained. During the data preprocessing stage, nodes with invalid status markers are filtered out, and only nodes with valid status markers are counted.

[0097] The technical solution for calculating the probability distribution is as follows: Assume a directed graph of change propagation contains N engineering entity nodes, each with a change propagation out-degree value of d_i, where i represents the node index from 1 to N. First, calculate the sum S of the change propagation out-degrees of all nodes, which is equal to the cumulative sum of all node change propagation out-degree values. The out-degree probability p_i of each node is equal to that node's change propagation out-degree value d_i divided by the sum S. The probability distribution set is represented as a numerical sequence from p_1 to p_N. The calculation process includes a zero-value handling mechanism; when the sum S equals 0, the p_i of each node is set to 1 divided by the total number of nodes N. For example, if a directed graph contains 3 nodes with change propagation out-degree values ​​of 2, 1, and 0 respectively, then the sum S is 3, and the probability distribution sequence is 0.666667, 0.333333, and 0.000000. The calculation results are stored in a probability distribution array, rounded to six decimal places.

[0098] The core steps of applying the information entropy calculation formula include: calculating the change propagation entropy value H based on the probability distribution arrays p_1 to p_N. The information entropy calculation formula is expressed as follows: the change propagation entropy value H is equal to the sum of the products of negative p_i and the logarithms of p_i with base 2, where i traverses all nodes from 1 to N. The base of the logarithm is fixed at 2, and the calculation result is in bits. The calculation process handles special numerical cases: when the probability p_i equals 0, the contribution of this term to the entropy calculation is defined as 0. For example, for the probability distribution sequences 0.666667, 0.333333, and 0.000000, the entropy value H is approximately 0.9183 bits. The calculation result is rounded to four decimal places and written into the task analysis report.

[0099] The change propagation directed graph construction uses a dedicated export interface of the graph database, exporting data in a graph exchange format file. Change propagation out-degree statistics are implemented by traversing the node adjacency list structure, employing a breadth-first traversal algorithm to ensure no duplicate counts. Probability distribution calculations use double-precision floating-point arithmetic, with standard rounding rules set for rounding. The logarithmic operation in information entropy calculation calls the binary logarithm function from the mathematical function library, with input parameter range validation set to force a value of 0 when the probability value is less than 0.000001. The post-processing workflow includes entropy range validation: the theoretical minimum value is 0, corresponding to a single propagation path scenario; the theoretical maximum value is the logarithm of the total number of nodes N (base 2), corresponding to a uniform propagation scenario. An exception code E6001 is triggered when the calculation result exceeds the theoretical range.

[0100] The adjustable range of the logarithmic base is set from 2 to 10, with a default value of 2 set according to information theory standards. The zero-value handling threshold is set to treat a probability value less than 0.000001 as 0. Audit log records fields including the total number of nodes N, the total out-degree of change propagation S, the probability distribution sequence, the final entropy value, and the computation time. The exception code system is defined as follows: E6001 indicates an entropy value exceeding the limit, E6002 indicates a probability and deviation exception (allowing a deviation of ±0.001), and E6003 indicates an invalid node participating in the calculation exception.

[0101] For example, when the change propagation out-degree of a certain material equipment node is 4, indicating that it affects 4 sub-project nodes, and the change propagation out-degree of the other 9 nodes is 0, the probability distribution sequence is 1.0 followed by 9 zeros, and the entropy value is calculated to be 0. When the change propagation out-degree of all 13 nodes is 3, the entropy value reaches its theoretical maximum value of approximately 3.7004 bits. The output data structure is defined as a JSON object containing a change propagation entropy value field, a node number field, and a status code field. Performance optimization uses a partitioned computation mechanism; when the number of nodes exceeds 1000, the calculation is performed in parallel by subgraph partitioning, and the results are then merged.

[0102] The technical implementation process for obtaining the semantic density calculation results and change propagation entropy calculation results is as follows: The semantic density value and change propagation entropy value generated and stored in step S4 are extracted through the result storage interface of the subgraph query task. The semantic density value is stored in the semantic density field of the task result object, and the change propagation entropy value is stored in the change propagation entropy field. The data acquisition process includes a validity verification step: checking whether the semantic density value is within the closed interval of 0 to 5, and checking whether the change propagation entropy value is within the closed interval of 0 to the logarithm of the total number of nodes to base 2; if the value is detected to be outside the valid range, it is marked as invalid data and error code E7001 is returned. For example, for the subgraph query task with task identifier TASK_2_5A3F8B91, the semantic density field value read from the result storage area is 0.85, and the change propagation entropy field value is 0.92.

[0103] The comparison operation between the semantic density calculation result and the first threshold is implemented as follows: The first threshold is predefined as, for example, 1.2. This threshold is set based on the statistical analysis results of the historical subgraph query task dataset—calculating the semantic density value distribution of 1000 successfully executed subgraph query tasks, and taking the 85th percentile value as the threshold benchmark. The comparison operation performs a numerical magnitude judgment: when the semantic density calculation result is greater than or equal to the first threshold, it is determined to be above the threshold; when the semantic density calculation result is less than the first threshold, it is determined to be below the threshold. The first threshold supports dynamic configuration and adjustment; the value range can be set between 0.5 and 3.0 through the management interface, with a default value of 1.2. For example, when a semantic density calculation result of 1.85 is detected, the judgment result of being above the threshold is triggered because 1.85 is greater than 1.2. The comparison process records an audit log, and the log fields include the task identifier, semantic density value, first threshold value, and comparison result status.

[0104] The comparison between the change propagation entropy calculation result and the second threshold is as follows: The predefined formula for calculating the second threshold is 0.8 multiplied by the logarithm of the total number of nodes to the base 2, where the total number of nodes N is taken from the number of entity nodes in the current subgraph. This formula is based on the information entropy theory: when the entropy value is lower than 80% of the theoretical maximum value, it is determined that the change propagation path is relatively concentrated. The comparison operation performs numerical judgment: when the change propagation entropy calculation result is less than the second threshold calculation result, it is determined to be below the threshold. For example, if the total number of nodes N in a subgraph is 10, the logarithm of 10 to the base 2 is approximately 3.3219, and the second threshold calculation result is 0.8 × 3.3219 ≈ 2.6575; if a change propagation entropy value of 2.15 is detected, the judgment result of being below the threshold is triggered. Boundary condition handling: when the total number of nodes N is less than 3, the second threshold adopts a fixed value of 0.5.

[0105] The technical implementation of the historical cache data retrieval mechanism includes: initiating the historical cache retrieval process when both the semantic density calculation result is higher than the first threshold and the change propagation entropy calculation result is lower than the second threshold. The historical query result database uses a key-value pair storage structure, where the key is the string form of the subgraph query task identifier, and the value is the historical execution result set and its metadata. The retrieval process includes a cache validity verification step: checking whether the time difference between the cache generation timestamp and the current time is within the validity period (default validity period is 30 days), and checking whether the cache data version number is consistent with the current knowledge graph version number. For example, if the cache database is retrieved using the task identifier TASK_2_5A3F8B91 as the key, and a valid cache exists, the result set is returned directly. Exception handling includes: error code E7002 indicates that the cache record does not exist, and error code E7003 indicates that the cache has expired.

[0106] The parallel query engine startup process is as follows: when the cache call conditions are not met (i.e., semantic density is below the first threshold or change propagation entropy is above the second threshold), a parallel query task is submitted to the distributed query cluster. The engine architecture adopts a task scheduling node and compute node separation model: the task scheduling node is responsible for parsing the query task parameters, and the compute nodes execute subgraph path search operations. The parallelism parameter is dynamically configured according to the subgraph size: the number of parallel compute nodes is equal to the smaller value between the total number of entities in the subgraph divided by 50 and the maximum parallelism of 32. For example, if a subgraph contains 800 project entities, calculating 800 divided by 50 equals 16, then 16 parallel compute nodes are allocated. Task distribution uses a consistent hashing algorithm to ensure that tasks with the same grouping label are routed to the same compute node group.

[0107] The first threshold update mechanism is set to execute automatically every 90 days, recalculating the 85th percentile value based on the semantic density data of subgraph query tasks added within the last 90 days. The cache validity period parameter can be configured from 1 to 90 days, and can be adjusted through the configuration interface according to business needs. The parallel query timeout threshold is set to 5000 milliseconds, and the retry mechanism after timeout will execute a maximum of 3 times. Result consistency is guaranteed using a two-phase commit protocol to ensure that intermediate results generated during parallel queries can be correctly merged into a complete result set.

[0108] When the semantic density calculation result is 1.85 (above the first threshold of 1.2) and the change propagation entropy calculation result is 2.15 (below the second threshold of 2.6575), the historical cached data retrieval process is executed and the cached result set is returned. When the semantic density calculation result is 0.85 (below the first threshold of 1.2) or the change propagation entropy calculation result is 2.75 (above the second threshold of 2.6575), the parallel query engine is started to perform a real-time path search operation. The decision-making process is recorded in the task execution log, and the log fields include details of the judgment conditions, execution path identifier, and result data source marker. All technical parameters are uniformly managed through the central configuration center, supporting dynamic adjustments during service operation without affecting service continuity.

[0109] The technical implementation process of path connection operation is as follows: After the parallel query engine returns path search results or calls historical cache data, the path connection operation is executed. The connection rule is: taking the starting entity node as the path start point and the ending entity node as the path end point, the path segments in the parallel query results are matched and connected with the path segments in the historical cache data. The matching condition is that the connecting nodes of adjacent path segments must have the same engineering entity identifier, and the relationship type must conform to any one of the material supply relationship, process connection relationship, and cost attribution relationship defined in S1. For example, if the parallel query result contains the path segment "Supplier A→Steel B", and the historical cache contains the path segment "Steel B→Concrete Project C", then the connection generates the complete path "Supplier A→Steel B→Concrete Project C". Conflict detection is performed during the connection process: when there are multiple candidate paths for the same node, the path record that was successfully executed within the last 7 days is selected first.

[0110] The technical solution for constructing a complete association path includes: generating a directed path sequence from the starting entity to the ending entity based on the path connection results. The path sequence is stored as an ordered list of node identifiers, and the association relationship between adjacent nodes is represented by a triple (starting node, relation type, ending node). The construction process includes path integrity verification: checking whether the starting node matches the starting entity identifier of the subgraph query task, and whether the ending node matches the ending entity identifier; checking that all nodes in the path belong to the entity set of the current subgraph query task. For example, the generated ordered node sequence is ["Supplier A", "Steel B", "Concrete Project C", "Sub-project D"], and the relation sequence is ["Supply Relationship", "Material Composition Relationship", "Process Connection Relationship"]. The path data is stored in a JSON structure: {"nodes":["id1","id2","id3"],"edges":[{"from":"id1","to":"id2","type":"supply"}]}.

[0111] The specific operation for extracting adjacent project entities is as follows: traverse the node sequence of the complete associated path and extract each pair of consecutive node combinations in sequence. The extraction rule is: if the path contains N nodes, then N-1 pairs of adjacent entity pairs are generated, where the i-th pair contains the i-th node and the (i+1)-th node (i=1,2,...,N-1). For example, the node sequence ["A","B","C","D"] will extract three pairs of adjacent entities: (A,B), (B,C), and (C,D). The extraction process performs validity verification: excludes self-looping node pairs (i.e., those with the same start and end nodes); excludes node pairs whose relation type is not defined in S1.

[0112] The implementation of attribute gradient change calculation includes: for each pair of adjacent engineering entities, calculating the cost attribute difference. The cost attribute value is taken from the "Unit Cost" attribute field of the engineering entity, which is provided by the entity attribute library of the knowledge graph, and the numerical unit is yuan / unit of measurement. The gradient change calculation formula is: the absolute value of the cost attribute value of the later entity minus the cost attribute value of the earlier entity. For example, if the unit cost of the earlier entity "Steel B" is 5000 yuan / ton, and the unit cost of the later entity "Concrete Engineering C" is 800 yuan / cubic meter, then the gradient change = |800 - 5000| = 4200. The calculation process includes unit consistency verification: when inconsistent units of measurement are detected, the unit conversion service is called to convert to a standard unit (such as uniformly set to yuan / square meter).

[0113] The cost anomaly marking mechanism compares the calculated attribute gradient change with a predefined cost anomaly threshold. The threshold setting rule is to take the 90th percentile of the historical cost difference for similar entities in the current project, with a base threshold set as, for example, a relative change rate of 30%. An anomaly is marked when either of the following conditions is met: 1) the absolute value of the gradient change is greater than or equal to the threshold; 2) the gradient change rate (change amount / previous entity cost value × 100%) is greater than or equal to 30%. For example, if a gradient change of 4200 is detected to be greater than the threshold of 3000, a record is added to the anomaly marking table: anomaly location (steel B → concrete C), change amount 4200, anomaly type "absolute exceedance". The marking results are stored in the path analysis report, with fields including: anomaly node pair, change amount, threshold, and anomaly level (levels 1-3).

[0114] The cost anomaly threshold uses a dynamic update mechanism, recalculating the 90th percentile value monthly based on newly added project data. The unit conversion service includes 200 built-in engineering unit conversion rules, such as a 1000x conversion from tons to kilograms. Anomaly level classification rules: Level 1 is less than 50% exceeding the threshold, Level 2 is 50%–100%, and Level 3 is above 100%. Boundary handling includes: normal calculation when the path contains only 2 nodes; and returning error code E8001 when a node's cost attribute is missing.

[0115] For example, in the complete path "Supplier A (cost 5000) → Steel B (cost 5500) → Concrete C (cost 800)," the change in the first pair (A→B) is |5500-5000|=500 (less than the threshold of 3000, no flagging), and the change in the second pair (B→C) is |800-5500|=4700 (greater than the threshold of 3000, flagged as a Level 3 anomaly). The output includes an anomaly location map and detailed data tables, supporting visualization of the anomaly propagation path in the engineering BIM model. All calculation processes are logged in a complete audit log to ensure the anomaly detection results are traceable and verifiable.

[0116] In the field of engineering cost management, existing technologies typically employ static path queries or manual experience to judge cost anomalies. This embodiment, however, improves upon existing technologies through a combination of multiple technical elements. Specifically, the three-dimensional relationship model established in step S1 breaks through the limitations of traditional two-dimensional associations, dynamically coupling material supply, process connection, and cost attribution relationships within a unified knowledge graph, providing a structured foundation for subsequent analysis. Steps S2 to S4 introduce a semantic density quantification evaluation mechanism, dynamically adjusting relation type weight coefficients and calculating change propagation entropy, applying information entropy theory to engineering change impact assessment for the first time, achieving accurate quantification of subgraph complexity. Step S5's dual-threshold decision mechanism integrates the collaborative judgment of semantic density and change propagation entropy, dynamically selecting the optimal query strategy based on subgraph characteristics. Step S6's gradient anomaly detection model uses path aggregation and attribute gradient analysis to automatically identify cost jumps between adjacent entities. Each step forms a tightly integrated technical loop: dynamic relationship modeling of the knowledge graph supports semantic density calculation, entropy analysis results drive query strategy selection, parallel processing and caching mechanisms ensure large-scale data processing efficiency, ultimately achieving accurate location of cost anomalies. This cross-domain technology integration, which combines engineering entity relationship topology analysis, information entropy theory application, and distributed computing, effectively solves technical problems such as weak correlation of engineering data, strong subjectivity in change impact assessment, and low efficiency of large-scale path calculation. It reduces computing resource consumption while improving the accuracy of anomaly detection.

[0117] Example 2: Figure 2 A schematic diagram of a knowledge graph-based intelligent identification system for engineering cost anomalies is provided. The system comprises:

[0118] The graph construction module is used to build an engineering cost knowledge graph that includes engineering entities and the relationships between entities, and to group and label engineering entities according to entity type;

[0119] The request parsing module is used to receive and parse the start and end entities in multi-hop related query requests;

[0120] The request decomposition module is used to decompose multi-hop association query requests into multiple subgraph query tasks based on the entity type grouping tags of the starting entity and the ending entity. Each subgraph query task is limited to performing path search within the same entity type group.

[0121] The task analysis module is used to query the number of relationships between entities within a task based on a subgraph, and obtain semantic density through weighted statistical analysis; it also queries the directed graph of change propagation for a task based on a subgraph, and calculates the change propagation entropy using information entropy.

[0122] The execution selection module is used to select the execution method for subgraph query tasks: when the semantic density is higher than the first threshold and the change propagation entropy is lower than the second threshold, historical cached data is called; otherwise, parallel queries are executed.

[0123] The path generation module is used to aggregate the results of parallel queries and historical cached data to generate complete association paths, and to identify cost anomalies based on the attribute gradient changes between adjacent engineering entities in the complete association path.

[0124] All calculations involved in the embodiments are dimensionless numerical calculations, and the preset parameters and thresholds in the calculations are set by those skilled in the art according to the actual situation.

[0125] It should be noted that this invention can be deployed on the device itself to realize embedded applications, or it can run on a PC or other terminal with a user interface, thereby meeting various hardware environments and usage requirements.

[0126] The above embodiments can be implemented, in whole or in part, by software, hardware, firmware, or any other combination thereof. When implemented using software, the above embodiments can be implemented, in whole or in part, as a computer program product. The computer program product includes one or more computer instructions or computer programs. When the computer instructions or computer programs are loaded or executed on a computer, all or part of the processes or functions described in the embodiments of this application are generated. The computer can be a general-purpose computer, a special-purpose computer, a computer network, or other programmable device. The computer instructions can be stored in a computer-readable storage medium or transmitted from one computer-readable storage medium to another. For example, the computer instructions can be transmitted from one website, computer, server, or data center to another website, computer, server, or data center via wireless or wired transmission; wired transmission methods include optical fiber, twisted pair, coaxial cable, etc.; wireless transmission includes infrared, microwave, etc. The computer-readable storage medium can be any available medium that a computer can access or a data storage device such as a server or data center containing one or more sets of available media. The available medium can be a magnetic medium (e.g., floppy disk, hard disk, magnetic tape), an optical medium (e.g., DVD), or a semiconductor medium. A semiconductor medium can be a solid-state drive.

[0127] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working processes of the systems, devices, and modules described above can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here.

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

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

[0130] In addition, the functional modules in the various embodiments of this application can be integrated into one processing module, or each module can exist physically separately, or two or more modules can be integrated into one module.

[0131] If the aforementioned functions are implemented as software functional modules and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or a portion of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0132] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

[0133] In conclusion, the above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A knowledge graph-based intelligent identification method for engineering cost anomalies, characterized in that, include: S1. Construct a knowledge graph of engineering cost that includes engineering entities and the relationships between entities, and group and label the engineering entities according to entity type; S2. Receive and parse the start and end entities in the multi-hop association query request; S3. Based on the entity type grouping labels of the starting entity and the ending entity, decompose the multi-hop association query request into multiple subgraph query tasks. Each subgraph query task is limited to performing path search within the same entity type group. S4. Based on the number of relationships between entities within the subgraph query task, semantic density is obtained through weighted statistical analysis; based on the change propagation directed graph of the subgraph query task, change propagation entropy is calculated using information entropy. S5. Select the execution method for the subgraph query task: when the semantic density is higher than the first threshold and the change propagation entropy is lower than the second threshold, call the historical cache data; otherwise, execute the parallel query. S6. The results of the aggregated parallel query are combined with historical cached data to generate a complete association path. Cost anomalies are identified based on the attribute gradient changes between adjacent engineering entities in the complete association path.

2. The method for intelligent identification of engineering cost anomalies based on knowledge graphs according to claim 1, characterized in that, Construct a knowledge graph of engineering cost that includes engineering entities and the relationships between them, and group and label the engineering entities according to entity type, including: Define the entities of sub-items, materials and equipment, process activities, and supplier units in the engineering cost knowledge graph; Construct material supply relationships, process connection relationships, and cost allocation relationships between engineering entities in the engineering cost knowledge graph; Based on entity type, all engineering entities in the engineering cost knowledge graph are grouped and labeled to form material group labels, process group labels, and organization group labels. The grouping tags are associated with the attribute information of the engineering entities and stored in the corresponding nodes of the engineering cost knowledge graph.

3. The method for intelligent identification of engineering cost anomalies based on knowledge graphs according to claim 1, characterized in that, Receive and parse the start and end entities in a multi-hop join query request, including: Receive the text of a multi-hop related query request input by the user; Identify the starting and ending entity names from the multi-hop related query request text; The starting entity is selected by matching the engineering entity name corresponding to the starting entity name based on the engineering cost knowledge graph. The project entity corresponding to the name of the termination entity is selected as the termination entity based on the knowledge graph of project cost. Verify the existence status of the starting and ending entities in the engineering cost knowledge graph and the grouping labels of entity types.

4. The method for intelligent identification of engineering cost anomalies based on knowledge graphs according to claim 1, characterized in that, Based on the entity type grouping tags of the starting and ending entities, multi-hop association query requests are decomposed into multiple subgraph query tasks. Each subgraph query task is limited to performing path search within the same entity type group, including: Determine the entity type grouping tag corresponding to the starting entity and the entity type grouping tag corresponding to the ending entity; Based on the grouping labels of all entity types in the engineering cost knowledge graph, the sequence of entity type groups that the starting entity must pass through to the ending entity is divided. For each entity type group in the entity type grouping sequence, generate a corresponding subgraph query task; In the subgraph query task, the path search scope is limited to the engineering entities and relationships between entities within the corresponding entity type group; The output contains a set of subgraph query tasks that are limited by the path search range.

5. The method for intelligent identification of engineering cost anomalies based on knowledge graphs according to claim 1, characterized in that, Based on the number of relationships between entities within a subgraph query task, semantic density is obtained through weighted statistical analysis, including: Count the number of direct relationship connections between all engineering entities in the subgraph query task; Obtain the predefined relation type weight coefficients from the engineering cost knowledge graph; The number of direct relation connections is calculated by weighted summation based on relation type weight coefficients; The semantic density is obtained by dividing the weighted summation result by the total number of engineering entities included in the subgraph query task.

6. The method for intelligent identification of engineering cost anomalies based on knowledge graphs according to claim 1, characterized in that, Based on the directed graph of change propagation for subgraph query tasks, the change propagation entropy is calculated using information entropy, including: Construct a directed graph of change propagation and count the out-degree of change propagation for each engineering entity node in the graph; Calculate the probability distribution of the propagation degree of changes to all engineering entity nodes; The change propagation entropy value is calculated based on the information entropy calculation formula applied to the probability distribution.

7. The method for intelligent identification of engineering cost anomalies based on knowledge graphs according to claim 1, characterized in that, For subgraph query tasks, the execution method is selected as follows: when the semantic density is higher than the first threshold and the change propagation entropy is lower than the second threshold, historical cached data is invoked. Otherwise, execute parallel queries, including: Obtain the semantic density calculation results and change propagation entropy calculation results for the subgraph query task; The semantic density calculation result is numerically compared with a predefined first threshold; The change propagation entropy calculation result is numerically compared with a predefined second threshold; When the semantic density calculation result is higher than the first threshold and the change propagation entropy calculation result is lower than the second threshold, the historical cached data corresponding to the subgraph query task is retrieved from the historical query result library. Otherwise, start the parallel query engine to perform parallel path search on the subgraph query task.

8. The method for intelligent identification of engineering cost anomalies based on knowledge graphs according to claim 1, characterized in that, The results of aggregated parallel queries are combined with historical cached data to generate a complete association path. Cost anomalies are identified based on attribute gradient changes between adjacent engineering entities in the complete association path, including: Connect the path search results returned by the parallel query engine with the historical cached data called from the historical query results library. Construct a complete association path from the starting entity to the ending entity based on the path connection results; Extract each pair of adjacent engineering entities sequentially within the complete associated path; Calculate the cost attribute value difference for each pair of adjacent engineering entities as the attribute gradient change; When the change in attribute gradient exceeds a predefined cost anomaly threshold, the corresponding entity is marked as having a cost anomaly in its adjacent engineering entity.

9. A knowledge graph-based intelligent identification system for engineering cost anomalies, used to implement the knowledge graph-based intelligent identification method for engineering cost anomalies as described in any one of claims 1-8, characterized in that, include: The graph construction module is used to build an engineering cost knowledge graph that includes engineering entities and the relationships between entities, and to group and label engineering entities according to entity type; The request parsing module is used to receive and parse the start and end entities in multi-hop related query requests; The request decomposition module is used to decompose multi-hop association query requests into multiple subgraph query tasks based on the entity type grouping tags of the starting entity and the ending entity. Each subgraph query task is limited to performing path search within the same entity type group. The task analysis module is used to query the number of relationships between entities within a task based on a subgraph, and obtain semantic density through weighted statistical analysis; it also queries the directed graph of change propagation for a task based on a subgraph, and calculates the change propagation entropy using information entropy. The execution selection module is used to select the execution method for subgraph query tasks: when the semantic density is higher than the first threshold and the change propagation entropy is lower than the second threshold, historical cached data is called; otherwise, parallel queries are executed. The path generation module is used to aggregate the results of parallel queries and historical cached data to generate complete association paths, and to identify cost anomalies based on the attribute gradient changes between adjacent engineering entities in the complete association path.

Images