An engineering full-life BIM heterogeneous data dynamic fusion system and method

Abstract

This application provides a dynamic fusion system and method for heterogeneous BIM data throughout the entire engineering lifecycle. The method includes: performing cross-source semantic alignment on multi-source engineering data to obtain a unified knowledge graph; dividing the unified knowledge graph into multiple autonomous sub-domains and marking semantic anchor points, calculating the consistency summary vector for each sub-domain; responding to data source change events, delimiting the affected sub-graph range using a restricted breadth-first search with anchor points as the stopping condition; performing local realignment on the affected sub-graphs, freezing anchor point embeddings as boundary conditions, comparing the updated consistency summary with the summaries of adjacent sub-graphs, triggering cascading propagation when the difference exceeds a preset propagation threshold, otherwise terminating. This application decomposes global consistency into local problems through an anchor point boundary mechanism, ensuring that the incremental update calculation scale is only related to the affected local area rather than the entire graph scale, achieving efficient incremental fusion while guaranteeing global semantic consistency.

Description

Technical Field

[0001] This application relates to the fields of digital twin and knowledge graph technology, and in particular to a dynamic fusion system and method for heterogeneous BIM data throughout the entire engineering lifecycle. Background Technology

[0002] In the context of enterprise digital transformation, engineering lifecycle management involves the integration of heterogeneous data sources across multiple stages, including design, construction, and operation and maintenance. Existing technologies typically employ knowledge graphs as a unified semantic representation of engineering data, merging data from different professional systems into a unified graph structure.

[0003] However, engineering data is characterized by continuous version changes. When the data source is updated, existing solutions require a full reconstruction and global consistency verification of the entire knowledge graph to ensure semantic consistency across data sources. As the knowledge graph grows to millions of nodes, a fundamental contradiction arises between the computational overhead of full recalculation and the timeliness requirements of data updates. Existing solutions struggle to balance semantic consistency guarantees with incremental update efficiency. Summary of the Invention

[0004] To address the contradiction between the excessive computational cost of full recalculation during continuous data changes and the difficulty in ensuring global semantic consistency during incremental updates in existing engineering knowledge graph technologies, this application provides a dynamic fusion system and method for heterogeneous BIM data throughout the engineering lifecycle. This method divides the unified knowledge graph into autonomous sub-graph domains bounded by anchor points. When data changes are detected, only local realignment is performed on the affected sub-graphs. A boundary consistency summary comparison protocol ensures semantic consistency between local updates and the global graph, enabling efficient incremental fusion and global consistency maintenance without performing a full recalculation. Specifically, this application provides the following technical solutions: Firstly, this application provides a method for dynamic fusion of heterogeneous BIM data throughout the entire lifecycle of an engineering project, including: Acquire multi-source engineering data; Perform a first semantic alignment on the multi-source engineering data to obtain a first knowledge graph, wherein each node in the first knowledge graph is associated with a first confidence score; The first knowledge graph is divided into multiple first subgraph domains. Nodes that meet preset conditions are selected from the cross-subgraph connection nodes between the multiple first subgraph domains and marked as anchors. A first consistency summary for each first subgraph domain is calculated. In response to a first change event from the data source, perform a first propagation analysis on the first change event to determine the boundaries of the subgraph domain affected by the change, and obtain a first set of subgraphs; The first realignment process is performed on the first subgraph set. The second consistency digest of the updated boundary node is compared with the first consistency digest of the adjacent subgraph. If the difference exceeds a preset propagation threshold, the adjacent subgraph is updated; otherwise, the propagation is terminated.

[0005] Optionally, performing a first semantic alignment on the multi-source engineering data includes: Embedding vectors are generated for entity nodes from various data sources based on graph neural networks; The similarity between cross-source entity pairs is calculated based on the embedding vectors. Entity pairs with similarity exceeding a preset similarity threshold are subjected to weighted merging.

[0006] Optionally, in response to a first change event from the data source, performing a first propagation analysis on the first change event includes: A restricted breadth-first search is performed starting from the changed node, and the propagation path is truncated with the anchor point as the stopping condition. If the number of subgraphs in the first subgraph set exceeds a preset ratio, then a full realignment is performed on the first knowledge graph.

[0007] Optionally, the first alignment process includes: The embedding vector of the anchor point is frozen as a boundary condition; Perform graph neural network forward propagation on the nodes within the first subgraph set to update the embedding vectors.

[0008] Optionally, the triggering of the adjacent subgraph update is set with a maximum propagation round limit, and the propagation is forcibly terminated when the cascading propagation round reaches the maximum propagation round limit.

[0009] Secondly, this application provides a dynamic fusion system for heterogeneous BIM data throughout the entire lifecycle of an engineering project, including: an alignment module, a management module, a monitoring module, and a fusion module.

[0010] The alignment module is used to acquire multi-source engineering data and perform first semantic alignment on the multi-source engineering data to obtain a first knowledge graph, wherein each node in the first knowledge graph is accompanied by a first confidence score. The management module is used to divide the first knowledge graph into multiple first subgraph domains, select nodes that meet preset conditions from the cross-subgraph connection nodes between the multiple first subgraph domains and mark them as anchor points, and calculate the first consistency summary of each first subgraph domain. The monitoring module is used to respond to a first change event from the data source, perform a first propagation analysis on the first change event to determine the subgraph domain boundary affected by the change, so as to obtain a first subgraph set; The fusion module is used to perform a first re-alignment process on the first subgraph set, comparing the updated second consistency digest of the boundary node with the first consistency digest of the adjacent subgraph. If the difference exceeds a preset propagation threshold, the adjacent subgraph is updated; otherwise, the propagation is terminated.

[0011] Optionally, the fusion module includes: The first realignment sub-unit is used to freeze the embedding vector of the anchor point as a boundary condition and perform local realignment on the nodes in the affected subgraph. The first propagation subunit is used to compare the updated second consistency summary of the boundary node with the first consistency summary of the adjacent subgraph, and determine whether to trigger boundary consistency propagation based on the comparison result.

[0012] Optionally, performing a first semantic alignment on the multi-source engineering data includes: Embedding vectors are generated for entity nodes from various data sources based on graph neural networks; The similarity between cross-source entity pairs is calculated based on the embedding vectors. Merge entity pairs whose similarity exceeds a preset similarity threshold.

[0013] Thirdly, this application provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the above-mentioned method for dynamic fusion of heterogeneous BIM data throughout the entire engineering lifecycle.

[0014] The beneficial effects of this application are as follows: 1. By dividing the unified knowledge graph into multiple autonomous subgraph domains bounded by anchor points, and by using propagation analysis to define the affected subgraph range when data changes are detected, local realignment is performed only within this range, making the computational scale of incremental updates related to the affected local scale rather than the overall graph scale. 2. By using the comparison protocol of the consistency summary of the boundary nodes, the global semantic consistency is decomposed into two orthogonal subproblems: consistency within the subgraph and consistency at the boundary. This ensures the semantic consistency constraint of the global graph after local updates without requiring a full recalculation. 3. The combination of subgraph partitioning with anchor points as boundaries, frozen anchor point embedding as boundary conditions, and boundary consistency summary comparison protocol enables the system to achieve both computational locality and global semantic consistency without full recalculation. This is superior to the partitioned incremental computation scheme that only re-aligns the affected subgraphs without setting boundary constraints and summary determination. Attached Figure Description

[0015] Figure 1 A schematic diagram of the process for dynamic fusion of heterogeneous BIM data throughout the entire engineering lifecycle provided in this application embodiment.

[0016] Figure 2 This is a schematic diagram of the cross-source alignment similarity threshold selection curve provided in the embodiments of this application.

[0017] Figure 3 This is a schematic diagram of the sub-domain structure and anchor point boundaries provided in an embodiment of this application.

[0018] Figure 4 This is a schematic diagram showing the relationship between the propagation threshold and the cascading effect range provided in the embodiments of this application.

[0019] Figure 5 A schematic diagram of the functional flow of the BIM heterogeneous data dynamic fusion system for the entire engineering life cycle provided in this application embodiment. Detailed Implementation

[0020] To make the objectives, technical solutions, and advantages of this application clearer, the technical solutions of this application will be clearly and completely described below in conjunction with the accompanying drawings and specific embodiments. Obviously, the described embodiments are only a part of the embodiments of this application, and not all of them. Based on the embodiments in this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0021] 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 number of technical features indicated. Thus, a feature defined as "first" or "second" may explicitly or implicitly include one or more of that feature. In the description of this application, "multiple" means two or more, unless otherwise explicitly specified.

[0022] The method for dynamic fusion of heterogeneous BIM data throughout the entire lifecycle of an engineering project, as provided in this application, is applicable to various engineering data management scenarios, including but not limited to the dynamic fusion of heterogeneous BIM data throughout the entire lifecycle of large-scale engineering projects such as urban complex projects, transportation hub construction projects, industrial park renovation projects, subway tunnel projects, and large bridge projects. The method can be deployed on computing devices such as server clusters, cloud computing platforms, or edge computing nodes, or on industrial control computers or industrial gateway devices at the project site.

[0023] like Figure 1 As shown in this embodiment, the method for dynamic fusion of heterogeneous BIM data throughout the entire engineering lifecycle includes: S000 parses the entity class hierarchy and attribute relationship definitions from the building information modeling standard file to construct a unified ontology diagram.

[0024] This step mainly involves automatically extracting the building entity ontology from the BIM standard and establishing a unified semantic space.

[0025] The construction process of the unified ontology graph includes three steps: In the first step, the system reads the EXPRESS schema file of the IFC4 ADD2 standard, and transforms the EXPRESS text into an abstract syntax tree through lexical and syntactic analysis. From this tree, the system extracts the inheritance relationships, attribute definitions, and association relationships of all IfcProduct and its subclasses, forming an IFC entity class hierarchy diagram.

[0026] For example, the EXPRESS schema file of the IFC4 ADD2 standard contains approximately 812 entity classes, which, after parsing, yield 811 direct inheritance relationships, 1247 association relationships, and 3892 attribute definitions.

[0027] In the second step, the system parses the `complexType` and `element` declarations in the CityGML 3.0 GML Schema file to extract the CityGML Feature class hierarchy. Using a predefined bridging mapping rule table, it maps geospatial entities in the CityGML LOD hierarchical model to equivalent or subclass entities in the IFC entity space. For example, the CityGML `Building` class establishes an equivalence relationship with the IFC `IfcBuilding` class, and the CityGML `RoofSurface` class establishes a subclass relationship with the IFC `IfcRoof` class.

[0028] Furthermore, the CityGML's WallSurface class is established as a subclass of the IFC's IfcWall class, the Road class in the CityGML's Transportation module is established as equivalent to the IFC's IfcCivilElement class, and the PlantCover class in the CityGML's Vegetation module is mapped to the IfcGeographicElement class added in IFC4.

[0029] For example, the complete bridging mapping rule table contains 32 pairs of mapping relationships, including 8 pairs of equivalence relationships (owl:equivalentClass) and 24 pairs of subclass relationships (rdfs:subClassOf). The total number of entity classes in the merged unified ontology equals the number of IFC entity classes plus the number of CityGML entity classes minus the number of equivalence merges. Specifically, the 8 pairs of equivalence mappings merge CityGML classes into their corresponding IFC equivalence classes; CityGML classes are no longer counted separately. The 24 pairs of subclass mappings only establish hierarchical associations between CityGML classes and IFC classes; CityGML subclasses remain as independent entity classes in the class hierarchy, not reducing the total number of entity classes. Therefore, the total number of entity classes is calculated as follows: Entity class.

[0030] It should be noted that the 812 IFC entity classes are the actual statistical value of the IFC4 ADD2 EXPRESS schema file parsed in this embodiment. This value may fluctuate by several tens of orders of magnitude depending on the version or parsing tool. The 95 CityGML entity classes cover the Feature class declarations of the Core, Building, Transportation, Vegetation, WaterBody, Bridge, Tunnel, CityFurniture, LandUse, and Relief modules in CityGML 3.0.

[0031] After bridging mapping is completed, transitive consistency verification is performed. For any combination of equivalence and inclusion relations, the logical consistency of the derivation results is verified. If a mapping pair that violates consistency is found, it is marked as a conflict and the mapping rule is rolled back. For example, for the bridging rule bldg:Building is equivalent to IfcBuilding, the system verifies whether bldg:Building is included in IfcSpatialStructureElement based on the inheritance relationship of IfcBuilding being included in IfcSpatialStructureElement in IFC.

[0032] In the third stage, the system inputs the merged ontology graph into the OWL-DL inference engine, performing transitive closure inference to complete all implicit inheritance and equivalence relations. The transitive closure calculation uses the matrix form of the Warshall algorithm, taking the Boolean adjacency matrix of direct inheritance relations as input, and iteratively calculating until the matrix converges. A directed acyclic inheritance graph consisting of entity classes; Warshall's algorithm in... The iteration converges within one round, with a computational complexity of O(n log n). For example, the original 811 direct inheritance relationships are expanded to 4521 inheritance relationships after transitive closure reasoning. The final output is a unified ontology graph. It is serialized and stored in OWL format, where C contains 899 entity classes, R contains 4521 inheritance relationships and 1247 association relationships, and A contains 3892 attribute definitions.

[0033] It should be noted that the specific execution process of the transitive closure reasoning is as follows: The system constructs a dimension as The Boolean adjacency matrix M, where Entity class i is a direct subclass of entity class j if and only if i is a direct subclass of j. The iterative calculation process is as follows: make Calculation in each round , In the formula, This indicates an element-wise OR operation. Boolean matrix multiplication when and When they are completely identical, the iteration converges.

[0034] For example, for the inheritance graph consisting of 875 merged entity classes, the adjacency matrix dimension is... There are a total of 808,201 elements. The non-zero elements in the initial matrix correspond to the 811 direct inheritance relationships resolved from the IFC side. Subclass relationships introduced by the bridging mapping are incorporated, with the actual resolution statistics as the final count. After 4 iterations, convergence is achieved (the number of convergence rounds of the repeated flattening method depends on the length of the longest directed path in the inheritance graph, not the total number of entity classes. The inheritance graph of the merged IFC / CityGML ontology has a wide and shallow tree structure; the longest path from the root class IfcRoot to the deepest leaf class is approximately 12 hops). Round repeating square cover (The transitive closure calculation can be completed by skipping paths), and the final transitive closure matrix contains 4521 non-zero elements. The attribute inheritance rule is: if entity class A can reach entity class B through a transitive closure, then A inherits all the attribute definitions of B. In the end, each leaf class entity inherits an average of about 15 attributes from its ancestor classes.

[0035] In an alternative implementation, the EXPRESS schema file parsing can be achieved by automatically generating a parser using an ANTLR4-written .g4 file containing EXPRESS syntax, or by using the Python bindings of the ifcOpenShell library to read the IFC EXPRESSSchema. The OWL transitive closure inference can be implemented using Apache Jena's RDFS inferencer or HermiT OWL inferencer, both of which are based on forward chain inference or the Tableau algorithm.

[0036] S100: Acquire multi-source engineering data and convert it into a unified graph structure triple representation, with each triple carrying the data source identifier and version information.

[0037] This step converts multi-source engineering data, including construction sensor data, IoT device data, and maintenance records, into RDF triple format to establish a fusion-compatible graph structure representation. The multi-source engineering data access adopts the adapter pattern, instantiating a corresponding transformation adapter for each type of data source.

[0038] For structured data, the system uses the W3C R2RML standard for declarative mapping. The R2RML mapping rules define the transformation logic from database table rows to RDF triples, and its structure includes a logical table definition, a subject URI template, and a predicate-object mapping. The logical table definition specifies the database table or SQL query to be transformed, the subject URI template generates a globally unique resource identifier based on the primary key field in the row, and the predicate-object mapping converts each database field into the predicate and object of the RDF triple.

[0039] For example, for a record in the maintenance work order database, with work order number MO-2025-0847, target device HVAC-B2-AHU-03, and fault type "abnormal noise of fan bearing", the system converts this row of data into a set of RDF triples with the work order URI as the subject according to the R2RML mapping rule. Each field is mapped to an independent predicate-object pair. The template for generating the work order URI is http: / / eng-dt.org / resource / Order_{order_id}.

[0040] The complete data flow of the R2RML mapping actuator is as follows: The mapping executor first parses the R2RML mapping file to obtain the logical table definition, then sends an SQL query to the relational database via JDBC connection to obtain the result set, then applies the subject URI template to each row of the result set to generate subject nodes, and then generates the corresponding RDF triples for each predicate-object mapping.

[0041] The logical table definition supports SQL query views. For example, device information scattered across multiple database tables can be merged into a single device entity record using a JOIN operation. The generated triples are written to the independent named graph of the corresponding data source after ontology compliance verification. For instance, the maintenance work order database contains approximately 3200 work order records, each generating 7 to 10 RDF triples (including type declarations, attributes, and relationships). The entire named graph of the maintenance data source contains approximately 28,000 triples.

[0042] For time-series data, the system uses the W3C SSN / SOSA ontology model for semantic annotation. The SOSA model models each sensor reading as an observation event instance, which is associated with the sensor that performed the observation, the observed attribute, the observed target entity, the observed numerical result, and the observation time through attributes.

[0043] For example, temperature sensor ST-003 collected a temperature value of 25.6℃ at column C-12 on the 3rd floor of Building B2 at 10:30 on March 15, 2025. The system generates a set of SOSA observation event triples from this reading, in which the observed target entity is linked to the unified ontology via a URI. An instance of the IfcColumn class. The set of observed event triples also includes a data source identifier and a data version number, which record the source data and current version status of the observed data, respectively.

[0044] For unstructured text data, the system employs an NLP pipeline processing approach. This pipeline sequentially executes three stages: sentence segmentation, named entity recognition, and relation extraction. The named entity recognition stage uses a BIO-annotated sequence model to identify six types of entities from the text: engineering components, equipment, materials, locations, fault phenomena, and maintenance actions. The relation extraction stage classifies the identified entity pairs into five types of relationships: spatial location, fault association, repair relationships, material composition, and physical connections. The extraction results are then linked to a unified ontology. The instances in the array are aligned to generate RDF triples.

[0045] For example, the inspection report text describes that there is a horizontal crack in column C-12 on the 3rd floor of Building B2 with a crack width of about 0.3mm. After NLP pipeline processing, a fault association triplet between the column C-12 instance and the crack fault instance is generated, as well as a width attribute triplet of the crack fault instance.

[0046] The named entity recognition model adopts a BiLSTM-CRF architecture. The input layer maps each Chinese character to a pre-trained character embedding vector, with the embedding dimension typically ranging from 100 to 300; in this embodiment, 200 dimensions are used. The bidirectional LSTM layer contains two LSTM units, forward and backward, with each unit's hidden layer dimension typically ranging from 128 to 256; in this embodiment, the hidden layer dimension is 150. After concatenating the forward and backward layers, the feature dimension at each position is 300. The CRF layer introduces a label transition matrix based on the BiLSTM output. ,in For BIO tag collection, (Each of the 6 entity types has B and I labels, plus one O label). The transition matrix constrains the legality of the label sequence; for example, the I-COMPONENT label is not allowed to follow the B-EQUIPMENT label directly.

[0047] The relation classifier represents the context of entity pairs as fixed-length vectors and inputs them into a two-layer fully connected network. The hidden layer has a dimension of 256, and the output layer has a dimension of 6 (5 relation types plus 1 no-relation category). The output relation type probability distribution is normalized using softmax.

[0048] In another embodiment, the time-series data transformation can also be achieved by modeling sensor data as Datastream entities using the OGC SensorThings API standard, and then converting them into RDF triples via JSON-LD context mapping. The text data extraction can also employ a context learning approach based on a large language model to directly extract structured triples from the text; the specific method can be chosen according to actual needs and is not limited here.

[0049] Each generated triple undergoes ontology compliance verification before being written to the graph storage, verifying that the type declaration of the triple's subject exists in the unified ontology. In the entity class hierarchy.

[0050] The specific execution process of the ontology compliance verification is as follows. For each triple to be written... The system first extracts the rdf:type declaration of the subject s, and then... (The sentence is incomplete and requires more context to translate accurately.) The system checks if the type exists within the class hierarchy. The query process traces upwards along the inheritance chain, and if the type itself or any of its ancestor classes exist in the ontology, it is considered compliant.

[0051] For example, if the subject type is `eng:StructuralColumn`, the system queries the ontology and finds that `StructuralColumn` can reach `IfcColumn`, `IfcBuildingElement`, and `IfcProduct` via the `rdfs:subClassOf` link, all of which are valid types in the ontology, thus determining compliance. If the subject type is `eng:WeatherCondition`, the system does not find this type or any of its ancestor classes in the ontology, thus determining non-compliance. This triple is written to the isolation queue with a non-compliance reason marker. The triples in the isolation queue await review by domain experts to decide whether to extend the ontology definition or discard the data. The manual review is completed in the isolation queue workspace of the ontology management console, and the interface displays the triples to be reviewed and their non-compliance reasons one by one. The triples submitted after expert correction are re-executed for ontology compliance verification. After passing the verification, they are written to the naming graph of the corresponding data source. If it is necessary to extend the ontology definition, the expert creates a new entity class in the ontology management console according to the preset URI naming rules and selects its parent class mount point in the unified ontology class hierarchy. The extended ontology definition takes effect after transitive consistency verification.

[0052] For example, about 2% to 5% of triples in the operation and maintenance data source are non-compliant due to NER model identification errors. After manual review, about 60% are corrected and rewritten, while 40% are identified as noisy data and discarded.

[0053] Triples that pass validation are written to the corresponding named graph of the data source, while triples that fail validation are written to an isolated queue awaiting manual review. Each triple in each named graph carries metadata such as data source identifier, timestamp, and version number, providing a basis for version comparison for subsequent incremental change detection.

[0054] The management strategy for version information is as follows: Each data source maintains an independent version counter, which increments after each data synchronization. The version number uses a semantic versioning format, where the major version number indicates a data model change, and the minor version number indicates a data content update. The system records the latest synchronized version number and corresponding synchronization timestamp for each data source, storing them in a metadata management table. When a data source pushes new data, the system compares the pushed version number with the synchronized version number, triggering the incremental synchronization process only if the pushed version number is greater than the synchronized version number.

[0055] For example, if the maintenance work order database is currently synchronized to version v2.1, synchronization is triggered when the pushed version is v2.2, and ignored when the pushed version is still v2.1. The version metadata also records the number of triplet changes and processing time for each synchronization, allowing system maintenance personnel to monitor the update frequency of each data source and the system load.

[0056] S200, perform cross-source semantic alignment (i.e., first semantic alignment) on multi-source engineering data to obtain a unified knowledge graph (i.e., first knowledge graph), in which each node of the first knowledge graph is attached with a confidence score (i.e., first confidence score).

[0057] This step loads the RDF named graphs and unified ontology from each data source from the graph storage, calculates the structural embedding vectors of each entity node through a graph neural network, performs similarity calculation and alignment determination on cross-source entity pairs, and performs confidence-weighted merging on aligned entity pairs with topological conflicts, finally outputting the fused unified knowledge graph.

[0058] The core of the cross-source semantic alignment lies in using graph neural networks to generate embedding vectors for entity nodes in each data source. This embodiment employs the R-GCN model to perform multi-layer message passing aggregation. R-GCN maintains independent weight parameters for each relation type based on standard graph convolutional networks, distinguishing the semantic contributions of different relations during message passing. The R-GCN's... The layer message passing process is as follows: For node i, the embedding vector of its neighboring nodes j connected by each relation type r. Through relational weight matrix Summing after transformation, plus self-loop transformation The activation function yields the first... Layer embedding .

[0059] To address the parameter explosion problem caused by an excessive number of relation types, the R-GCN employs a basis decomposition strategy, representing each relation weight matrix as a linear combination of B shared basis matrices, thus reducing the number of parameters. Reduced to .

[0060] The entity type encoding maps each entity's leaf type to a one-hot vector, with the vector dimension equal to the number of leaf types in the ontology. For example, if there are approximately 420 leaf types in the ontology (i.e., terminal types with no further subclasses), then the type encoding dimension is 420.

[0061] The attribute numerical encoding directly takes the value of the entity's numerical attributes, and calculates the mean of the pre-trained word vectors for text attributes as the attribute embedding. The attribute encoding dimension is typically 64. The data source identifier encoding maps each data source to a one-hot vector, with the dimension equal to the number of data sources. In this embodiment, there are 6 data sources, and the dimension is 6.

[0062] The initial vector dimension after concatenating the three parts is: Mapped to the unified embedding dimension via the first layer R-GCN .

[0063] For example, the embedding vector dimension d typically takes a value in the range of 64 to 256; in this embodiment, it is taken as... The number of R-GCN layers L is typically between 2 and 4; in this embodiment, it is [value missing]. This means capturing the local semantic structure of nodes through 3-hop neighborhood aggregation. The number of base matrices, B, typically ranges from 5 to 30. In this embodiment, there are approximately 50 relation types. .

[0064] After multi-layer R-GCN forward propagation, each entity node obtains an embedding vector that incorporates neighborhood structure information. Cosine similarity is calculated for entity pairs from different data sources; this is calculated by dividing the dot product of the two embedding vectors by the product of their respective magnitudes. The resulting similarity value ranges from 0 to 1. When the similarity exceeds a preset similarity threshold... When two entities point to the same physical engineering entity, it is determined that they are similar. A preset similarity threshold is used. Typically, the value ranges from 0.7 to 0.95. In this embodiment, the threshold is determined by constructing a labeled validation set and taking the threshold that results in the maximum F1 score. .

[0065] The construction process of the annotation validation set is as follows. The system manually annotates 500 entity pairs from historical engineering project data, including 125 positive samples (cross-source record pairs confirmed to be the same entity) and 375 negative samples (entity pairs of the same type confirmed to be different entities), with a positive-to-negative ratio of 1:3. Difficult negative samples are prioritized for negative samples, i.e., entity pairs with the same type and similar attributes but are indeed different physical entities, such as two adjacent column components on the same floor, or different instances of the same model of equipment.

[0066] like Figure 2 As shown, on this validation set, the system iterates through thresholds from 0.60 to 0.99 with a step size of 0.01, calculates precision and recall for each threshold, and takes the threshold with the highest F1 score as the optimal threshold. For example, in... The F1 score reached its maximum of 0.94, corresponding to a precision of 0.96 and a recall of 0.92. To improve the efficiency of candidate pair generation, the system first groups entities by type and calculates similarity only between entities of the same type. Then, it uses locality-sensitive hashing to perform approximate nearest neighbor retrieval, reducing the number of candidate pairs from [previous value]. Reduced to Magnitude.

[0067] For example, for the same column component in a commercial complex project, sourced from three data sources: BIM model, construction sensors, and operation and maintenance reports, the initial features of the entity in the BIM data source are aggregated into an embedded vector after three layers of R-GCN. The embedding vector of the corresponding entity in the sensor data source is The cosine similarity between the two is approximately 0.9999, far exceeding the threshold of 0.85, thus classifying them as the same entity. In contrast, although HVAC pumps and fire pumps are both pump types, R-GCN captures their structural information as belonging to different subsystems through neighborhood aggregation, with a cosine similarity of only about 0.52, correctly rejecting the merging.

[0068] For node pairs that are identified as the same entity but have topological conflicts, the system bases its decision on the reliability of data source i. and data freshness Determine the confidence-weighted pooling coefficient (i.e., the first weighting coefficient):

[0069] In the formula, This is the set of all data sources that have topological conflicts.

[0070] Among them, the time freshness Using an exponential decay function attenuation coefficient Typically, the value is taken in the range of 0.001 to 0.1 days to the power of -1. This embodiment uses... The freshness decay of data from 100 days ago is approximately 0.37, calculated as the number of days minus one.

[0071] The reliability of the data source Initial values ​​are set by domain experts, such as the reliability of the BIM design model. Reliability of construction sensors Reliability of text extraction For numerical attribute conflicts, the weighted average of the attribute values ​​from each version is taken as the merging result. For categorical attribute or relation conflicts, the attribute value of the version with the highest weight is taken. The ontology consistency check includes querying the class constraints and topological constraints of the target node in the unified ontology to verify whether the candidate hierarchical relations are consistent with the spatial inclusion rules defined in the ontology.

[0072] For example, the ontology defines that IfcColumn can only be located within IfcBuildingStorey. If a version labels a column component as being located at the IfcBuilding level instead of the floor level, this labeling violates the ontology constraint, and the system automatically reverts to the next weighted version. Furthermore, the system also queries the graph neighborhood topology context of the target node to verify whether the candidate relationship is consistent with the relationship of the neighboring nodes. For example, if all adjacent components (connected beams and slabs) of column C-12 are labeled as being located on the 3rd floor, then the version labeling column C-12 as being on the 4th floor contradicts the topology context and should be reverted.

[0073] For hierarchical relationship conflicts, after taking the version with the highest weight, an ontology consistency check must be performed. If the hierarchical relationship of that version contradicts the class constraints of the unified ontology, it will fall back to the version with the second highest weight.

[0074] For example, a column component is labeled as located on the 3rd floor in the BIM data, but incorrectly labeled as located on the 4th floor in the maintenance report. Assume the BIM data timestamp is January 15, 2024, the maintenance report timestamp is March 16, 2025, and the current time is March 20, 2025. Calculate the freshness of the BIM data. The freshness of the operation and maintenance report Weights of normalized operation and maintenance reports The weight of BIM is far greater than that of BIM. The system should have used the maintenance report version based on the weighting. However, the system query of the knowledge graph found that the adjacent components of the column were all located on the 3rd floor. The 4th floor annotation in the maintenance report contradicted the topological context, triggering the ontology consistency rollback mechanism. Ultimately, the 3rd floor annotation of the BIM was adopted.

[0075] After merging, the confidence score of each node is equal to the product of the maximum normalized weight and the entity alignment similarity. The confidence score ranges from 0 to 1 and is used for semantic anchor selection in the subsequent subgraph encapsulation stage. Each node in the final output unified knowledge graph is accompanied by an embedding vector and a confidence score.

[0076] It should be noted that the specific implementation process of the locality-sensitive hash is as follows: The system randomly generates K hyperplane normal vectors. Each normal vector has the same dimension as the embedding vector d. For each entity node's embedding vector h, its hash signature is calculated. This yields a K-bit binary signature. Entity nodes with the same hash signature are assigned to the same hash bucket, and only cross-source entity pairs within the same bucket are considered as candidate pairs for exact cosine similarity calculation.

[0077] For example, K typically takes a value in the range of 8 to 20; in this embodiment, K is taken as... For a scenario with 50,000 nodes, grouped by type with a maximum group size of approximately 8,000 nodes, a full comparison requires computation. With 10,000 cosine similarities, after applying LSH, the average number of candidate pairs is approximately 50 nodes per bucket, reducing the number of candidate pairs to approximately [missing information]. The number of pairs was reduced by approximately 160 times.

[0078] The R-GCN training process employs a self-supervised contrastive learning approach. Positive sample pairs are known cross-source records of the same entity (seed alignment sets obtained from historical data), while negative sample pairs are random pairings of the same type but different entities. The training objective is to maximize the cosine similarity of positive sample pairs while minimizing the similarity of negative sample pairs, using the InfoNCE loss function, which incorporates a temperature parameter. In this embodiment, The value typically ranges from 0.05 to 0.5, with lower temperatures resulting in a stronger gradient penalty for difficult negative samples; during training, each positive sample pair is paired with... This embodiment takes [number] negative samples. The value typically ranges from 32 to 128. Training uses the Adam optimizer, and the learning rate is usually between 128 and 128. to The value is taken within the range, and in this embodiment, it is taken as... The training run consists of 100 epochs. After training, the model weights are frozen for inference; the weights are not updated during the inference phase.

[0079] In another embodiment, the graph neural network embedding can also be implemented using the CompGCN model, which embeds the relations themselves as vectors and integrates relation information into message passing through combination operations. In yet another embodiment, the HGT model can also be used, which uses an attention mechanism instead of fixed normalization to dynamically assign aggregation weights to different neighbors. The topological conflict resolution can also be implemented using methods based on Dempster-Shafer evidence theory or latent variable inference methods based on probabilistic graphical models.

[0080] S300, the first knowledge graph is divided into multiple first subgraph domains, and nodes that meet preset conditions are selected from the cross-subgraph connection nodes between the multiple first subgraph domains and marked as anchor points, and a first consistency summary of each first subgraph domain is calculated.

[0081] This step performs spatial segmentation on the fused unified knowledge graph, dividing it into several autonomous sub-graph domains with high cohesion and low coupling (i.e., the first sub-graph domain), marking semantic anchor nodes, and calculating the consistency summary vector (i.e., the first consistency summary) for each sub-graph domain, thus establishing the spatial segmentation basis for subsequent incremental updates.

[0082] The subgraph partitioning employs a community detection method based on maximizing modularity. Modularity Q measures the partitioning quality; high modularity means the edge density within the subgraph is significantly higher than the expected density in a random graph. This embodiment uses the Louvain community detection algorithm, which optimizes modularity through alternating iterations of local movement and graph shrinkage. In the local movement phase, the algorithm sequentially traverses each node, calculating the modularity gain after moving the node into each adjacent community. The nodes are then moved to the community with the highest gain, iterating until no positive gain can be obtained. During the graph shrinking phase, each community is shrunk into a super node. The edge weights between communities are equal to the sum of the weights of the cross-community edges in the original graph, and the weights of self-loops within a community are equal to the sum of the weights of the internal edges. These two phases are executed alternately until the modularity no longer increases.

[0083] The modularity Q is defined as:

[0084] In the formula, For elements of the adjacency matrix, Let be the degree of node i, and m be the total number of edges in the graph. The Kronecker function is set to 1 when two nodes belong to the same community. A resolution parameter is introduced to control the subgraph granularity to satisfy the constraint that the average number of nodes in each subgraph is between 100 and 10000. Adjusted by binary search Ensure the partitioning results meet the granularity range.

[0085] The specific process of the binary search is as follows: System Settings The search range is In each round, the Louvain algorithm is executed by taking the midpoint of the interval and calculating the average number of nodes in the subgraph. If the average number of nodes exceeds 10,000, the lower bound of the search interval is updated to the current midpoint; if the average number of nodes is less than 100, the upper bound is updated to the current midpoint; otherwise, the current interval is not updated. The search terminates when the granularity constraint is met. Binary search typically converges within 5 to 8 rounds.

[0086] For example, for a graph with 50,000 nodes, The average number of nodes is 1190, which meets the constraint range of 100 to 10000, and the search is completed in the first round without needing to continue. For example, for a unified knowledge graph containing 50,000 nodes and 180,000 edges, taking... Louvain's algorithm produces 42 subgraph domains, with an average of approximately 1190 nodes per subgraph domain, resulting in a modularity of [missing information]. The number of cut edges between subgraphs accounts for 7.0% of the total number of edges.

[0087] It should be noted that the Louvain algorithm automatically divides the knowledge graph into cohesive functional domains based on modularity optimization. Each sub-domain typically corresponds to a building space unit, a device subsystem, or a set of engineering components.

[0088] For example, in a commercial complex project, sub-graph It comprises 1850 nodes, mainly consisting of the building space on floors 1 to 3 of Building B2 and sensors installed in the area. (Sub-graph) It comprises 980 nodes, mainly consisting of the equipment entities of the HVAC system in Building B2 and their corresponding monitoring data. (Sub-diagram) It contains 1420 nodes, mainly consisting of the structural entities and operation and maintenance records of floors 4 to 6 of Building B2. (Sub-diagram) It contains 1100 nodes and mainly consists of outdoor landscape and road infrastructure entities. (Subgraph) It contains 1350 nodes, mainly consisting of the structural load-bearing components and defect records of Building B2. This automatic partitioning result matches the physical zoning of the project, ensuring that subsequent incremental updates typically limit the impact of changes to a single functional domain, without affecting the entire map.

[0089] like Figure 3 As shown, the selection of semantic anchors is performed from the cross-subgraph connection nodes in the subgraph partitioning results. A cross-subgraph connection node is a node that has at least one edge connecting it to other subgraph domains. Nodes that meet preset conditions are selected from the cross-subgraph connection nodes as semantic anchors. These preset conditions include a confidence score exceeding a confidence threshold. Generally speaking, It is usually not less than 0.9, but here we take... Among the candidate nodes that meet the confidence criteria, the top nodes are selected based on their degree centrality. Marked as a semantic anchor point. The degree centrality... It equals the degree of node v divided by the total number of nodes in the graph minus one. Generally, p usually takes a value between 5 and 20; here, we take [value missing]. .

[0090] To ensure that there is at least one anchor point between each pair of adjacent subgraphs to achieve boundary consistency propagation, for adjacent subgraph pairs that lack anchor points, the node with the highest confidence is added from the cross-boundary nodes of the pair of subgraphs as an additional anchor point; for example, 131 semantic anchor points are finally selected on a graph with 50,000 nodes.

[0091] The first consensus summary is computed based on the aggregation of embedding vectors of subgraph boundary nodes. Subgraph Boundary node set This refers to all nodes in the subgraph that are directly connected to adjacent subgraphs by edges. (Consistency summary vector) It equals the confidence-weighted mean of the embedding vectors of each node in the boundary node set:

[0092] In the formula, Let be the embedding vector of node v. The confidence score is used. A confidence-weighted approach is used here instead of a simple mean, ensuring that boundary nodes with high confidence contribute more to the consistency determination than those with low confidence. To ensure comparability with the consistency digest from the incremental update phase, the boundary node embedding used for digest calculation in this embodiment adopts an intra-subgraph aggregated embedding view, that is, it only aggregates the embeddings of neighbor messages within the same subgraph, excluding cross-subgraph neighbor messages; this approach uniformly applies to the first consistency digest calculated in phase S300 and the second consistency digest calculated in phase S500.

[0093] For example, subgraph The boundary node set contains 18 nodes. Taking 3 of these nodes as an example: The first dimension of the embedding is 0.72 and the confidence level is 0.95. The first dimension of the embedding is 0.68 and the confidence level is 0.92. If the first dimension of the embedding is 0.70 and the confidence level is 0.88, then the first dimension of the summary vector... The final consistent summary vector dimension of each subgraph domain is the same as the embedding vector dimension, both being 128 dimensions.

[0094] In engineering projects, these boundary interface nodes typically correspond to shared resources across functional domains. For example, subgraphs. (Architectural spatial domain) and subgraph The boundary interface nodes between (HVAC equipment domains) include HVAC terminal equipment (such as fan coil units) and air outlet entities installed in the building space. These entities have both a spatial relationship with the building space and an equipment connection relationship with the HVAC system. (Sub-diagram) (Structural component domain) and subgraph Boundary interface nodes between (architectural space domains) include components such as floor slabs and shear walls that simultaneously bear structural loads and serve spatial partitioning functions. The number of boundary interface nodes typically accounts for 3% to 8% of the total number of nodes in a sub-graph; in this embodiment, the average proportion of boundary interface nodes in the 42 sub-graphs is 5.2%.

[0095] It should be noted that incremental updates need to restrict the propagation of changes to a local scope. Anchor nodes, as high-confidence hubs in the graph structure, have their embedding vectors frozen during local realignment, forming a structural barrier to prevent the infinite propagation of change signals. Generally, the selection of anchor points needs to balance two conflicting objectives: coverage (at least one anchor bridge between each pair of adjacent subgraphs) and degrees of freedom (too many anchor points result in too few nodes that can be updated during local realignment). This embodiment uses... The degree centrality threshold strikes a balance between the two.

[0096] The modularity gain The calculation process is as follows. For node i (current degree) The connection edge weight with candidate community C Move to community C (current internal boundary rights) Total ), in the total number of sides On the graph, the modularity gain is:

[0097] When the gain is positive, the move is executed, and after multiple iterations, the modularity converges to near the global optimum. For example, for a knowledge graph with 50,000 nodes and 180,000 edges, the Louvain algorithm converges in Phase 1 after 5 iterations, and Phase 2 performs graph shrinkage 3 times, with a total computation time of approximately 2.3 seconds (single-core CPU). The final modularity increases from a randomly initialized 0.12 to 0.58.

[0098] In another embodiment, the community detection can also be implemented using the Leiden algorithm, which, based on the Louvain algorithm, ensures connectivity within each community and converges faster. In yet another embodiment, spectral clustering can also be used to partition the community based on the eigenvalue decomposition of the graph Laplacian matrix.

[0099] S400, responding to the version change event of the data source (i.e., the first change event), performing propagation analysis (i.e., the first propagation analysis) on the first change event to determine the subgraph domain boundary affected by the change, and obtaining the set of affected subgraphs (i.e., the first subgraph set).

[0100] This step is triggered when a version change of the data source is detected. The changed content is determined by differential comparison, and the spatial range affected by the change is determined by limited breadth-first search. Finally, the set of subgraphs and nodes that need to be realigned are output.

[0101] The first propagation analysis includes three stages: In the first stage, the system performs triplet-level difference comparisons on adjacent versions of the changed data source, generating a set of change operations. The essence of difference comparison is set difference operations, which convert the old version triplet set of the data source... With the new version of triplet set The comparison is performed: the newly added triplet set is the difference between the new version and the old version, and the deleted triplet set is the difference between the old version and the new version. If an old triplet with the same subject and predicate appears in the deleted set and a new triplet appears in the newly added set, they are paired and identified as a modification operation. The difference comparison uses set operations based on hash indexes, with a time complexity of O(log n). .

[0102] In the second phase, the system maps the nodes involved in the change operation set to the current subgraph partition. Each existing node is assigned an index through the subgraph produced by S300. The complexity determines the subgraph to which a node belongs. For a new node, the system queries its neighboring nodes in the graph storage and determines the subgraph to which the new node belongs through a majority vote of the subgraphs to which its neighbors belong. Subgraphs containing at least one changed node constitute the directly affected subgraph set.

[0103] The process for determining the subgraph affiliation of the newly added node is as follows: When a new subject node that is not previously present in the graph storage appears in a set of change operations, the system first queries the set of neighboring nodes of the new node. If the neighboring nodes are not empty, the system counts the frequency of each neighboring node in its subgraph and assigns the new node to the subgraph with the highest frequency.

[0104] For example, a new sensor node eng:Sensor-ST-010 is added and connected to the space node Space-B2-3F-Room-302 (belonging to...). ) and device node HVAC-FCU-B2-302 (belonging to ),like There are 2 neighbors in the middle. If there is one middle neighbor, the new node is assigned to If the neighboring nodes are empty (an isolated newly added node), the system searches for the subgraph with the highest type matching degree among all subgraphs based on the new node's rdf:type and assigns it accordingly. Specifically, the type matching degree is defined as the ratio of the sum of the number of nodes of that type and all its ancestor types in the subgraph to the total number of nodes in that subgraph; the subgraph with the highest ratio wins. If multiple subgraphs have the same highest ratio, the subgraph with fewer nodes and a more concentrated type distribution is prioritized. If the type matching degree of all subgraphs is zero (that type has not yet appeared in any subgraph), a new independent subgraph domain is created for the new node, which will be merged with other subgraph domains when the subgraph is repartitioned later. The subgraph allocation index is updated immediately after allocation to support subsequent queries.

[0105] In the third phase, the system performs a restricted breadth-first search starting from each changed node, truncating the propagation path based on semantic anchor points. During the search, when a semantic anchor point node is encountered, the current node is recorded as the boundary node of the influence domain, and further expansion in that direction is stopped. Simultaneously, a maximum propagation hop count is set. As a safety upper limit. Typically not exceeding 5, this embodiment uses... That is, the number of R-GCN layers A safety margin of 2 is added to cover the full receptive field of the graph neural network embedding computation. All non-anchor nodes visited during the search process constitute the influence domain node set. The subgraphs covering the nodes within the influence domain constitute the set of affected subgraphs (i.e., the first set of subgraphs).

[0106] It should be noted that the propagation path of the restricted breadth-first search may extend to adjacent subgraphs via non-anchor nodes that connect across subgraphs. In this case, the search will not stop at the non-anchor node, but will continue to extend along the path until the next semantic anchor is encountered or the maximum number of propagation hops is reached. Nodes in the extended adjacent subgraphs are included in the influence domain node set. The adjacent subgraph is included in the set of affected subgraphs. Therefore, the restricted breadth-first search uses semantic anchors and the maximum propagation hop count as dual stopping conditions to ensure that the affected domain covers all node paths that may be affected by the change.

[0107] For example, in a commercial complex project where three temperature sensors were replaced with newer models, differential comparison generated nine change operations (six modifications and three additions), involving three subject nodes. All three change nodes are located in the HVAC system subgraph. In the middle, a restricted BFS is performed starting from sensor ST-003. After one hop, it reaches the temperature monitoring area node, the space node, and the work order node. After two hops, it reaches the floor node but encounters a semantic anchor and stops expanding. After two hops, it reaches the HVAC unit node and continues expanding. After three hops, it reaches the HVAC main duct node but encounters a semantic anchor and stops expanding. The influence domains of the three sensors, after deduplication, comprise a total of 12 nodes, all located in the subgraph. Within, the proportion of affected subgraphs is .

[0108] If the number of subgraphs in the affected subgraph set exceeds a preset ratio Then, a full realignment is performed on the unified knowledge graph. For example, The ratio is 0.3, with the total number of subgraph regions generated by the current subgraph division as the denominator (for example, 42 subgraph regions). This means that when the number of affected subgraphs reaches... At this point, the incremental strategy is abandoned and a full recalculation is performed.

[0109] The specific triggering process for the full recalculation is as follows: When the monitoring module determines that a change event triggers the full degradation condition, the system sends a full recalculation instruction to the alignment module. After receiving the instruction, the alignment module re-executes S200 cross-source semantic alignment on the latest version named graph of all data sources, generating a new full graph embedding vector matrix and alignment relationships. Subsequently, the management module re-executes S300 subgraph partitioning, updating the subgraph allocation index, semantic anchor set, and consistency summary vector. After the full recalculation is completed, the system returns to a ready state that can respond to incremental change events.

[0110] For example, with a graph size of 50,000 nodes, a full recalculation takes approximately 45 seconds (including R-GCN inference, alignment determination, and subgraph partitioning), while incremental updates take an average of approximately 80 milliseconds, a difference of about 560 times. The full degradation mechanism ensures that the system can still update correctly under extreme change scenarios, avoiding erroneous results when the incremental strategy's assumptions fail. Furthermore, when the number of change operations exceeds a preset proportion of the total number of triples in the old version... This also triggers a full recalculation, for example... It is 0.5.

[0111] To handle a series of change events arriving within a short period, the system sets up a change aggregation window to merge multiple change events within that window into a single batch processing. The aggregation window size typically ranges from 10 to 300 seconds; this embodiment uses 60 seconds to balance change response speed and aggregation efficiency. Redundancy elimination is performed during aggregation: operations that add and then delete the same triple cancel each other out, and multiple modifications to the same triple are only retained in their final version.

[0112] The hash index for the triplet difference uses the 128-bit MurmurHash3 algorithm. For each triplet... The subject URI, predicate URI, and object (URI or literal) are concatenated to calculate a 128-bit hash value. The theoretical collision probability of a 128-bit hash is... The scale (birthday attack boundary) is considered collision-free at a scale of millions of triples. The hash index construction time is linearly related to the number of triples; for example, building a hash index for 3200 triples takes approximately 15 milliseconds.

[0113] The specific implementation of the change aggregation window adopts a sliding window mode. The system maintains a memory buffer and starts a timer when the first change event is received. Change events are continuously accumulated within the window time (60 seconds). When the window closes, the system performs redundancy elimination on all events in the buffer, and then performs influence domain delimitation and full degradation determination on the merged change operation set obtained after redundancy elimination. That is, the full degradation determination is performed at the unified processing point after the aggregation window closes, rather than determining each change event in the window separately, in order to avoid missing the full recalculation when the actual number of affected subgraphs exceeds the limit after multiple events are aggregated in the window, but the limit is not exceeded when determining each event individually.

[0114] For example, if the window receives three attribute updates for the same sensor (temperature reading changes from 25.6 to 25.8 and then to 26.1), after redundancy elimination, only the final state (a single MOD operation from 25.6 to 26.1) is retained. Intermediate states are skipped to avoid triggering two unnecessary local realignments. After the window is closed, the buffer is cleared, waiting for the next change event to trigger a new window.

[0115] The time complexity analysis of the BFS propagation within the influence domain is as follows. In the worst case, when there are no anchor points to truncate within the influence domain, the BFS expands to... Jump. Let the average node degree be... Based on a tree structure where each hop's expanded nodes do not overlap, the worst-case number of expanded nodes is estimated to be... (In the actual graph, multi-hop expansion involves shared neighbors, and the number of duplicate nodes after deduplication is lower than this upper bound). However, in a real-world scenario where anchor points account for approximately 0.26% (131 / 50000), BFS encounters an anchor point and stops at an average of 2.1 hops, with the actual average number of nodes in the influence domain being approximately... In this embodiment, the combined influence domain of the three sensors is 12 nodes, which is far lower than the theoretical worst value, demonstrating the effective constraint of the anchor point on the propagation range.

[0116] In another embodiment, the influence domain delimitation can also be achieved using a propagation decay method based on personalized PageRank, including nodes with PageRank values ​​higher than a threshold within the influence domain. In yet another embodiment, the impact of changes on the embedding of each node can be precisely quantified using an influence analysis method based on graph neural network gradients.

[0117] S500, perform local semantic realignment (i.e., first realignment processing) on ​​the first subgraph set, compare the updated consistency digest (i.e., second consistency digest) of the updated boundary node with the first consistency digest of the adjacent subgraph, if the difference exceeds the preset propagation threshold, trigger the update of the adjacent subgraph, otherwise terminate the propagation.

[0118] Based on the influence domain analysis results, this step re-executes the graph neural network embedding calculation and entity alignment determination within the affected local area, and determines whether it is necessary to propagate the update to neighboring subgraphs through the boundary consistency summary comparison protocol.

[0119] The first realignment process includes freezing the embedding vectors of semantic anchors as boundary conditions, and performing graph neural network forward propagation only on nodes within the affected subgraph set to update the embedding vectors. Specifically, the embedding vectors of semantic anchors remain unchanged during the local realignment process, retaining the values ​​calculated during S200 full alignment, and participate in the embedding aggregation of neighboring nodes as fixed signal sources in message passing. Non-anchor nodes within the influence domain reconstruct their initial embeddings based on the updated attribute features, and obtain updated embedding vectors after forward propagation through an L-layer R-GCN. This mechanism is analogous to the Dirichlet boundary conditions in partial differential equations; the frozen embeddings of anchors ensure that the results of local realignment remain consistent with the global semantic space, preventing semantic changes from leaking to unaffected regions.

[0120] For non-anchor boundary nodes within the affected subgraph, only messages from neighboring nodes within the same subgraph are aggregated during the local R-GCN forward propagation. Cross-subgraph edges from adjacent subgraphs do not participate in message passing during local realignment and are calculated uniformly after the adjacent subgraphs are triggered for updating. Accordingly, as described in S300, both the first and second consistency digests are calculated based on the aggregated embedded views within the subgraph. Although the embedding of anchor nodes is frozen, their digest contribution remains consistent in both phases. Therefore, the difference between the two digests only reflects semantic changes within the subgraph and does not include differences in receptive field caused by the participation of cross-subgraph messages.

[0121] If the changed nodes in the change operation set include semantic anchor nodes, then the semantic anchor will not undergo embedding freeze in this local realignment, but will participate in the embedding update along with other non-anchor nodes within the affected domain. Specifically, the system checks the affected domain node set before performing local realignment. With semantic anchor set intersection .like If not empty, then The anchor points in the set are removed from the frozen set; only the frozen sets are frozen. The embedding vectors of unaffected anchors are used. The frozen anchors are then reconstructed based on the updated attribute features to re-embed their initial embeddings and participate in the R-GCN forward propagation. Because the embeddings of affected anchors change, the consistency summary of their boundaries may change beyond a preset propagation threshold. This triggers cascading updates to adjacent subgraphs, which is the expected behavior. For example, if the attributes of a floor anchor node are modified, the boundary consistency summary changes significantly after the anchor node's embedding is updated, triggering updates to adjacent subgraphs and ensuring that the change information is correctly propagated.

[0122] It should be noted that this application involves two threshold parameters with different effects: a preset propagation threshold used to determine whether a change in the consistency of adjacent subgraph boundaries triggers cascading propagation. Its target is the child. Figure 1 The differences between similarity summaries are measured using the L2 distance metric of the summary vectors in this embodiment, typically ranging from 0.01 to 0.1; a preset similarity threshold is used to determine whether cross-source entity pairs point to the same entity. The two parameters, which operate on the embedding similarity of cross-source entity pairs, have different objects of operation and measurement methods and are independent parameters that should not be confused.

[0123] For example, for the HVAC system sub-diagram of Building B2 Local realignment of 12 influence domain nodes was performed, and the embedding of adjacent anchor point floor nodes and HVAC main pipe nodes was frozen. After three layers of local R-GCN forward propagation, the embedding change of the changed node (sensor) was 0.032, which decayed to 0.018 after one hop propagation and to 0.015 after two hops. The embedding change of nodes closer to the anchor point was pulled back more by the anchor point's frozen value, reflecting the attenuation anchor effect of the Dirichlet boundary condition.

[0124] The change operations employ transactional writes to guarantee atomicity. The system encapsulates all triple operations in the change operation set into a single SPARQL UPDATE transaction, either writing all operations successfully to the graph store or rolling them all back. For add operations, the system inserts the new triple into the corresponding named graph. For delete operations, the system removes the target triple from the named graph. For modify operations, the system deletes the old triple and then inserts the new triple within the same transaction. After a transaction is successfully committed, the system updates the version number metadata of the corresponding data source, marking that the data source has been synchronized to the new version. For example, 9 change operations (6 MODs + 3 ADDs) are written in a single transaction, with a transaction execution time of approximately 8 milliseconds.

[0125] After local realignment is completed, the system re-performs alignment determination for entities within the affected domain.

[0126] For newly introduced entities, alignment candidates are searched among similar entities within the affected domain, and cosine similarity is calculated. For already aligned entities with modified attributes, their similarity with their alignment partners is recalculated. If the similarity drops below a threshold minus a margin, the alignment is revoked. In other words, the criterion for revoking an alignment is a similarity score below a certain threshold. The purpose of the margin design is to prevent alignment relationships from being repeatedly established and revoked in continuous update cycles when similarity fluctuates slightly around the threshold.

[0127] For example, if the similarity of an entity pair gradually decreases from 0.86 to 0.84 after multiple incremental updates, the system maintains the alignment relationship unchanged because 0.84 is still higher than the revocation threshold of 0.80. Revocation is only performed when the similarity continues to decrease below 0.80, ensuring the stability of the alignment relationship. Revoked alignment relationships and their reasons for revocation are recorded in the alignment audit log, allowing system administrators to trace the complete history of alignment status changes. The margin is typically between 0.03 and 0.10; here, it is set to 0.05 to prevent frequent establishment and revocation of alignment relationships due to similarity oscillations near the threshold.

[0128] After local realignment is completed, the updated consistency summary (i.e., the second consistency summary) is calculated. The second consistency summary is calculated in the same way as the first consistency summary, i.e., the confidence-weighted average of the embedding vectors of the affected subgraph boundary nodes. The difference lies in using the updated embedding vectors and updated confidence scores. The second consistency summary is then compared with the first consistency summaries of the adjacent subgraphs by calculating the L2 distance between them.

[0129] If the L2 distance exceeds a preset threshold This triggers an update of the adjacent subgraph, adding it to the update queue for the next round of local realignment. If the L2 distance does not exceed a preset threshold, it is determined that the update of this subgraph has not affected the semantic interface with adjacent subgraphs, and propagation terminates. For example, The value is typically taken in the range of 0.01 to 0.1. In this embodiment, the value is taken as... .

[0130] The triggering of adjacent subgraph updates is subject to a maximum propagation round limit. When the cascading propagation reaches The propagation is forcibly terminated to prevent infinite cascading in extreme scenarios. The number of cascading propagation rounds is counted from the first triggering of adjacent subgraph updates, and each round of local realignment and boundary consistency summary comparison of adjacent subgraphs is counted as one round; generally, No more than 3, take it here. In a typical engineering knowledge graph, due to the attenuation anchoring effect of anchor points, the propagation change amplitude decreases round by round with an attenuation factor of approximately 0.3. After 3 rounds, the residual change is usually below the preset threshold, and the cascade naturally converges.

[0131] For example, such as Figure 4 As shown, for the aforementioned sensor replacement scenario, the sub-graph Of the 18 boundary nodes, only 2 embeddings underwent minor changes, and the L2 distance between the updated consistent summary and the original summary was [missing information]. When the value is far below the preset threshold of 0.05, the propagation immediately terminates.

[0132] The convergence analysis of the cascaded propagation includes: Let the L2 distance of the summary of the subgraph that changes the most in the t-th round of propagation be . Because anchor freezing provides a fixed signal in each round of message passing, changing signals are completely absorbed when passing through anchors and distributed according to the number of neighbors when passing through ordinary nodes. In a graph structure with an average degree of 7.2 and an anchor percentage of 0.26%, the attenuation factor of the change amplitude after single-hop propagation is... .

[0133] It should be noted that this theoretical value describes the case where the change attenuates hop by hop along a single propagation path; in actual diagrams, the same node often receives the changing signal simultaneously via multiple paths. The superposition of multiple paths causes the residual change reaching the node to be weighted and summed according to the contribution of each path. The net attenuation factor is between the theoretical value of the single path and 1, and the measured value is approximately 0.3, which falls within this range. The applicability of the two calibers is as follows: the single-path theoretical caliber is used to illustrate the upper bound of the anchor freezing mechanism on the propagation amplitude, while the multi-path measured caliber is used to estimate the number of cascaded convergence rounds in typical scenarios. In this embodiment, the measured value of 0.3 is substituted into the convergence estimation.

[0134] For example, if the initial change (In the scenario of core pipeline modification), after the first round of propagation... Round 2 Round 3 It can be seen that in At the threshold, propagation according to the measured caliber converges in the second round. No need to reach Even if estimated according to the single-path theory ( The residual change in the first round, 0.12 × 0.139 ≈ 0.017, was also below the threshold. The number of convergence rounds under both methods did not exceed [a certain threshold]. , The value of can cover the actual convergence requirements of cascade propagation.

[0135] The computational scale of the local realignment is compared with that of the full recalculation as follows: A full recalculation requires the entire map. Each node performs an L-layer R-GCN forward propagation, with a computational complexity of O(n). Local realignment only applies to The execution is performed on 1 node, with a computational complexity of O(n). The speedup ratio is In a typical engineering project operation and maintenance phase, a single change event usually affects 5 to 50 triples from 1 to 3 data sources, impacting the number of domain nodes. Typically in the range of 10 to 200, compared to the full range Figure 5 Ten thousand nodes can achieve an acceleration of 250 to 5000 times.

[0136] The persistent writing of the embedding vectors and confidence scores employs a batch asynchronous strategy. After local realignment, the system serializes the updated embedding vectors into a binary floating-point array format and updates the corresponding node's embedding record in the vector database all at once via a batch write interface. The confidence score, as a node attribute, is batch-written to the graph storage using SPARQL UPDATE. The write process employs a post-write verification mechanism; after writing, 5% of the updated nodes are randomly selected for readback verification to confirm the consistency between the written and calculated values. For example, the total write time for updating the embedding vectors of 12 nodes (each a 128-dimensional floating-point number) and the confidence score update is approximately 3 milliseconds, while the readback verification time is approximately 1 millisecond.

[0137] It should be noted that there is a synergistic effect among the above-mentioned subgraph partitioning based on anchor points, frozen anchor point embedding as a boundary condition, and boundary consistency summary comparison protocol: While incremental recalculation of subgraph partitioning can reduce the computational scale of a single update, the local update results lack constraints with the global semantic space and cannot guarantee semantic consistency at the subgraph boundaries. Freezing anchor embedding constrains local realignment to an embedding space consistent with full alignment, preventing update results from drifting to unaffected regions. The boundary consistency summary comparison protocol quantifies the residual boundary semantic deviations into a determinable propagation signal, and triggers cascading updates only when the deviation exceeds a preset propagation threshold.

[0138] The combination of these three factors enables the system to achieve both computational locality and global semantic consistency without requiring a full recalculation, which is superior to the partitioned incremental computation scheme that only re-aligns the affected subgraphs without setting boundary constraints and summarization.

[0139] In another embodiment, the consistency change determination can also employ a frequency domain analysis method based on graph signal processing to distinguish between global changes and local noise in the frequency domain to determine whether to propagate. In yet another embodiment, an asynchronous propagation method based on version vectors can also be used to achieve eventual consistency assurance.

[0140] This application also provides a dynamic fusion system for heterogeneous BIM data throughout the entire engineering lifecycle. For example... Figure 5 As shown, the system includes an alignment module, a management module, a monitoring module, and a fusion module.

[0141] The alignment module is used to perform cross-source semantic alignment (i.e., first semantic alignment) on multi-source engineering data to obtain a unified knowledge graph (i.e., first knowledge graph), in which each node is accompanied by a confidence score (i.e., first confidence score). The specific implementation of the alignment module is described in step S200 above, and it includes a graph sampling batch processing subunit, an R-GCN embedding calculation subunit, a candidate pair generation subunit, a similarity calculation subunit, and a conflict resolution subunit.

[0142] The management module is used to divide the first knowledge graph into multiple autonomous sub-graph domains (i.e., first sub-graph domains), select nodes that meet preset conditions from the cross-sub-graph connection nodes between the multiple first sub-graph domains and mark them as anchor points, and calculate the consistency digest vector (i.e., first consistency digest) of each first sub-graph domain. The specific implementation of the management module is as described in step S300 above, and it includes a community detection execution subunit, an anchor point selection subunit, a boundary interface calculation subunit, and a digest vector calculation subunit.

[0143] The monitoring module is used to respond to version change events of the data source (i.e., the first change event), perform propagation analysis (i.e., the first propagation analysis) on the first change event to determine the boundaries of the subgraph domain affected by the change, and obtain the set of affected subgraphs (i.e., the first subgraph set). The specific implementation of the monitoring module is described in step S400 above, and it includes a change event receiving subunit, a triplet difference numerator unit, a subgraph mapping subunit, and an influence domain BFS propagation subunit.

[0144] The fusion module performs local semantic realignment (i.e., first realignment processing) on ​​the first subgraph set, compares the updated consistency digest (i.e., second consistency digest) of the updated boundary nodes with the first consistency digest of the adjacent subgraphs, and if the difference exceeds a preset propagation threshold, triggers the update of the adjacent subgraphs; otherwise, terminates propagation. The fusion module includes a first realignment subunit and a first propagation subunit. The first realignment subunit freezes the embedding vectors of anchor points as boundary conditions and performs local realignment on nodes within the affected subgraphs. The first propagation subunit compares the updated second consistency digest of the boundary nodes with the first consistency digest of the adjacent subgraphs and determines whether to trigger boundary consistency propagation based on the comparison result. The specific implementation of the fusion module is described in step S500 above.

[0145] The monitoring module and the fusion module communicate asynchronously via a message queue. After the monitoring module completes the influence domain delimitation, it encapsulates the change operation set, the affected subgraph set, the influence domain node set, and the influence domain boundary node set into an influence domain data packet and sends it to a preset topic in the message queue. The fusion module subscribes to this topic and triggers a local realignment process upon receiving the data packet. If the monitoring module determines that the change scale triggers a full degradation threshold, it sends a full recalculation instruction to the alignment module, skipping the incremental processing of the fusion module.

[0146] The management module maintains the subgraph partitioning status and provides query services to other modules. The monitoring module obtains the mapping relationship between nodes and subgraphs and the set of semantic anchors through the query interface of the management module. The fusion module obtains the subgraph boundary node set and consistency summary vector through the query interface of the management module. When the management module detects that the graph size has increased beyond a preset repartitioning threshold, it automatically triggers subgraph repartitioning and notifies each module to refresh its cache.

[0147] Each of the above modules can be implemented by a processor executing computer programs stored in memory. The processor can be a central processing unit, a graphics processing unit, or a combination thereof. The memory can be volatile memory or non-volatile memory, or it can include both volatile and non-volatile memory.

[0148] Example 2

[0149] In this embodiment, the difference from Embodiment 1 is that the selection of the graph neural network model and the selection of the subgraph partitioning algorithm in the first semantic alignment are different, while the remaining steps are the same as in Embodiment 1.

[0150] In this embodiment, the first semantic alignment uses the CompGCN model instead of the R-GCN model in Embodiment 1 to perform multi-layer message passing aggregation.

[0151] It should be noted that the core difference between CompGCN and R-GCN is that R-GCN maintains an independent weight matrix (or its basis decomposition approximation) for each relation type, while CompGCN embeds the relation itself as a vector and integrates the relation into the message passing process through combination operations.

[0152] Specifically, CompGCN in the In layer message passing, for node i and its neighbor node j connected through relation r, the relation embedding vector is first constructed. Embedded vectors of neighboring nodes Perform a combination operation, then pass through the weight matrix. Aggregation after transformation. The combination operation uses subtraction combination, that is, the combination result is... This combination method allows the relationships in the embedded space to be modeled as translation vectors from the head entity to the tail entity.

[0153]

[0154] In the formula, For node i, the set of all (neighbor nodes, relation type) pairs. The activation function is CompGCN. The advantage of CompGCN is that it maintains only one shared weight matrix. and a set of relation embedding vectors The number of parameters is Compared to R-GCN-based decomposition When the number of relation types A larger embedding dimension d results in a lower number of parameters. This embodiment uses the embedding dimension d. The relationship embedding dimension is the same as the node embedding dimension, and the number of layers is... The relation embedding vector is optimized together with the node embedding during the training phase.

[0155] The training process of the CompGCN model is the same as in Example 1, employing a self-supervised contrastive learning approach. Positive sample pairs are known cross-source records of the same entity, while negative sample pairs are random pairings of the same type but different entities. The InfoNCE loss function is used. Training utilizes the Adam optimizer, with a learning rate of [value missing]. The training consists of 100 rounds.

[0156] Here, after generating embedding vectors for 50,000 nodes of the same commercial complex project using the CompGCN model, the process of performing cross-source semantic alignment is the same as in Example 1. For example, on the same labeled validation set, CompGCN achieves the optimal similarity threshold. The F1 score reached 0.93, corresponding to a precision of 0.95 and a recall of 0.91, which is close to the F1 score of 0.94 of R-GCN in Example 1. The alignment accuracy of CompGCN in this scenario is slightly lower than that of R-GCN, but the number of training parameters is reduced by about 35%, and the inference speed is improved by about 20%. The confidence-weighted merging, ontology consistency check, and subsequent steps are performed in the same way as in Example 1.

[0157] In this embodiment, the subgraph partitioning uses the Leiden algorithm instead of the Louvain algorithm in Embodiment 1. The Leiden algorithm adds a community refinement stage to the Louvain algorithm. After each round of local movement, it performs an internal connectivity check on each community. If a community is not connected internally, it is split into multiple connected components, ensuring that each output community is internally connected. The execution process of the Leiden algorithm includes three stages: the local movement stage is the same as Louvain, traversing each node, calculating the modularity gain, and moving the node to the community with the largest gain; the refinement stage performs an internal BFS check on the connectivity of each community, splitting unconnected communities into connected sub-communities; the graph shrinking stage shrinks each connected sub-community into a super node. The three stages are executed alternately until the modularity no longer increases.

[0158] For the same unified knowledge graph with 50,000 nodes and 180,000 edges, the Leiden algorithm has a resolution parameter... It produces 45 sub-graph domains per hour, with an average of approximately 1111 nodes per sub-graph domain, and a modularity of [missing information]. Slightly higher than the Louvain algorithm in Example 1. The Leiden algorithm produces more subgraph domains than Louvain's 42. This is because Louvain's algorithm may assign several disconnected groups of nodes to the same community, while Leiden's algorithm splits them by checking connectivity. The number of cut edges between subgraphs accounts for 6.5% of the total number of edges, lower than 7.0% in Example 1, reflecting that Leiden's algorithm maintains better partitioning quality while ensuring connectivity within communities.

[0159] The subsequent semantic anchor selection, consistency summary calculation, incremental change detection and impact domain delimitation, local realignment, and boundary consistency propagation are all the same as in Example 1. For example, for the same sensor replacement event, the proportion of affected subgraphs is... The number of affected domain nodes is 12. After realignment, the propagation terminates immediately, and the incremental update effect is consistent with that of Example 1.

[0160] Example 3

[0161] In this embodiment, the difference from Embodiment 1 is that the influence domain delimitation algorithm in the first propagation analysis and the consistency change determination method in the first realignment process are different, while the remaining steps are the same as in Embodiment 1.

[0162] In this embodiment, the first propagation analysis uses a propagation decay method based on personalized PageRank instead of the restricted breadth-first search in Embodiment 1. Personalized PageRank simulates a random walk process starting from the changed node and calculates the importance score of each node in the graph relative to the changed node. Unlike BFS, which truncates with a fixed number of hops, personalized PageRank achieves natural decay of the change's impact through teleport probability; nodes farther from the changed node receive lower PageRank values.

[0163] The personalized PageRank is calculated using a power-law iteration method. Let the set of changing nodes be... Initial distribution vector Change node location All other positions are set to 0. Teleportation probability. Control each random walk to The probability of returning the changed node set, in order to The probability of continuing to traverse along the outgoing edge is given. The iterative formula is:

[0164] In the formula, This is the transpose of the column-normalized adjacency matrix of the graph. Iterate to... Convergence occurs at certain times, and the convergence threshold is... Pick After convergence, the PageRank value exceeding the preset influence threshold is considered. The nodes are included in the influence domain node set. The subgraphs that cover nodes within the influence domain constitute the set of affected subgraphs.

[0165] The transmission probability Values ​​are typically taken in the range of 0.1 to 0.3; this embodiment uses [value missing]. The influence domain threshold The value of needs to match the personalized PageRank distribution and the size of the local subgraph: the PageRank distribution vector obtained by exponential iteration is normalized on the local subgraph, and the uniformly distributed background value is approximately when the local subgraph has about 5200 nodes. , It should be significantly higher than this background value; in this embodiment, it is taken as... (Approximately 2.6 times the uniform background value); a reasonable value range is approximately 2 to 6 times the uniform background value (for example). to (order of magnitude), with values ​​lower than the uniform background value (e.g.) The magnitude of the influence will include almost all local nodes in the influence domain, thus losing its attenuation and bounding effect; values ​​higher than this will result in the loss of attenuation and bounding effect. The magnitude is only retained for the immediate neighboring nodes of the changed node.

[0166] To improve computational efficiency, the exponential iteration is performed only on the subgraph where the changed node is located and on the local subgraphs of its directly adjacent subgraphs, not on the entire graph. For example, for three changed nodes in the same sensor replacement event, the local subgraph contains subgraphs. and its adjacent subgraphs , and The total number of nodes is approximately 5200. The exponential iteration converges after 12 rounds, and the PageRank value exceeds [value missing]. There are 14 nodes in total (approximately 0.27% of the 5200 nodes in the local subgraph), all located in the subgraph. Within this framework, the selection size matches the threshold setting. Compared to the 12 influence domain nodes identified by the BFS method in Example 1, the personalized PageRank method includes two more nodes. This is because PageRank captures indirect influence nodes that might be missed by the single-path truncation of BFS through the multi-path superposition effect. The calculation time for the power iteration is approximately 6 milliseconds, which is comparable to the time taken by BFS in Example 1.

[0167] The technical advantages of the personalized PageRank method compared to the BFS method are as follows: BFS uses a fixed number of hops as the cutoff condition and treats the propagation in all directions equally; while personalized PageRank achieves the natural decay of influence intensity through the transmission probability, so that the direction with high connection density to the changed node gets a higher influence score, and the direction with sparse connection naturally decays to below the threshold. The shape of the influence domain more accurately reflects the actual propagation path of the change.

[0168] In this embodiment, the consistency change determination in the first re-alignment process uses a frequency domain analysis method based on graph signal processing to replace the L2 distance comparison in Embodiment 1. The frequency domain analysis method treats the embedding changes of subgraph boundary nodes as signals defined on the graph, projects the signal from the spatial domain to the frequency domain through graph Fourier transform, distinguishes low-frequency components (corresponding to global structural changes) and high-frequency components (corresponding to local noise fluctuations) in the frequency domain, and determines that the change needs to propagate to adjacent subgraphs only when the energy of the low-frequency component exceeds a preset threshold.

[0169] The graph Fourier transform is based on the graph Laplacian matrix of the boundary subgraph formed by the boundary nodes of the subgraph. Let the subgraph... Boundary node set There is Each node constructs a symmetric normalized Laplacian matrix for the boundary subgraph. ,in Let be the adjacency matrix of the boundary subgraph, and D be a degree diagonal matrix. Perform eigenvalue decomposition to obtain eigenvalues and the corresponding eigenvector matrix U. Embedded changing signal. The graph Fourier transform of (the difference in boundary node embeddings before and after the update) is: ,in The coefficients of each component correspond to different frequency components.

[0170] Low-frequency energy ratio Defined as the proportion of the energy of the frequency components corresponding to the first k smallest eigenvalues ​​to the total energy:

[0171] In the formula, k takes That is, the low-frequency components in the first third. When Exceeding the preset low-frequency threshold At this time, the change is primarily determined by global structural changes, triggering updates to adjacent subgraphs. No more than When the change is determined to be primarily local noise, propagation is terminated. The low-frequency threshold... Values ​​are typically taken in the range of 0.5 to 0.8; this embodiment uses [value missing]. .

[0172] For example, for the same sensor replacement change event, the subgraph The 18 boundary nodes constitute the boundary subgraph. After local realignment, the mean amplitude of each dimension of the embedded changing signal x is calculated to be 0.0012. After performing a graph Fourier transform on x, the first 6 low-frequency components ( Energy percentage The value is far below the threshold of 0.6, indicating that the embedding changes are mainly concentrated on high-frequency local noise components rather than global structural changes, and propagation terminates. This conclusion is consistent with the determination result of L2 distance being far below the threshold in Example 1, but the frequency domain method provides additional diagnostic information on the nature of the change.

[0173] This application also provides a computer-readable storage medium storing a computer program thereon. When executed by a processor, the computer program implements all the steps of the above-described method for dynamic fusion of heterogeneous BIM data throughout the entire engineering lifecycle. The computer-readable storage medium includes, but is not limited to, read-only memory, random access memory, flash memory, magnetic disk, or optical disk. The computer program may be stored in the above-described storage medium in the form of source code, object code, or executable binary code.

[0174] Furthermore, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit described above can be implemented in hardware.

[0175] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any changes or substitutions within the technical scope 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.

Claims

1. A method for dynamic fusion of heterogeneous BIM data throughout the entire engineering lifecycle, characterized in that, include: Acquire multi-source engineering data; Perform a first semantic alignment on the multi-source engineering data to obtain a first knowledge graph, wherein each node in the first knowledge graph is associated with a first confidence score; The first knowledge graph is divided into multiple first subgraph domains. Nodes that meet preset conditions are selected from the cross-subgraph connection nodes between the multiple first subgraph domains and marked as anchors. A first consistency summary for each first subgraph domain is calculated. In response to a first change event from the data source, perform a first propagation analysis on the first change event to determine the boundaries of the subgraph domain affected by the change and obtain a first set of subgraphs; The first realignment process is performed on the first subgraph set. The second consistency digest of the updated boundary node is compared with the first consistency digest of the adjacent subgraph. If the difference exceeds a preset propagation threshold, the adjacent subgraph is updated; otherwise, the propagation is terminated.

2. The method according to claim 1, characterized in that, Performing a first semantic alignment on the multi-source engineering data includes: Embedding vectors are generated for entity nodes from various data sources based on graph neural networks; The similarity between cross-source entity pairs is calculated based on the embedding vectors. Merge entity pairs whose similarity exceeds a preset similarity threshold.

3. The method according to claim 2, characterized in that, Merging entity pairs whose similarity exceeds a preset similarity threshold includes: The first weighting coefficient is determined based on the reliability of the data source and the freshness of the data. Based on the first weighting coefficient, a weighted merge is performed on entities with topological conflicts.

4. The method according to claim 1, characterized in that, In response to a first change event from the data source, performing a first propagation analysis on the first change event includes: A restricted breadth-first search is performed starting from the changed node, and the propagation path is truncated with the anchor point as the stopping condition. If the number of subgraphs in the first subgraph set exceeds a preset ratio, then a full realignment is performed on the first knowledge graph.

5. The method according to claim 1, characterized in that, The first alignment process includes: The embedding vector of the anchor point is frozen as a boundary condition; Perform graph neural network forward propagation on the nodes within the first subgraph set to update the embedding vectors.

6. The method according to claim 1, characterized in that, The triggering of the adjacent subgraph update is subject to a maximum propagation round limit. When the cascading propagation rounds reach the maximum propagation round limit, the propagation is forcibly terminated.

7. A dynamic fusion system for heterogeneous BIM data throughout the entire engineering lifecycle, characterized in that, include: An alignment module is used to acquire multi-source engineering data and perform first semantic alignment on the multi-source engineering data to obtain a first knowledge graph, wherein each node in the first knowledge graph is attached with a first confidence score; The management module is used to divide the first knowledge graph into multiple first subgraph domains, select nodes that meet preset conditions from the cross-subgraph connection nodes between the multiple first subgraph domains and mark them as anchor points, and calculate the first consistency summary of each first subgraph domain. The monitoring module is used to respond to a first change event from the data source, perform a first propagation analysis on the first change event to determine the subgraph domain boundary affected by the change, and obtain a first subgraph set; The fusion module is used to perform a first re-alignment process on the first subgraph set, comparing the updated second consistency digest of the boundary node with the first consistency digest of the adjacent subgraph. If the difference exceeds a preset propagation threshold, the adjacent subgraph is updated; otherwise, the propagation is terminated.

8. The system according to claim 7, characterized in that, The fusion module includes: The first realignment sub-unit is used to freeze the embedding vector of the anchor point as a boundary condition and perform local realignment on the nodes in the affected subgraph. The first propagation subunit is used to compare the updated second consistency summary of the boundary node with the first consistency summary of the adjacent subgraph, and determine whether to trigger boundary consistency propagation based on the comparison result.

9. The system according to claim 7, characterized in that, Performing a first semantic alignment on the multi-source engineering data includes: Embedding vectors are generated for entity nodes from various data sources based on graph neural networks; The similarity between cross-source entity pairs is calculated based on the embedding vectors. Merge entity pairs whose similarity exceeds a preset similarity threshold.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by the processor, it implements the dynamic fusion method of heterogeneous BIM data throughout the entire engineering lifecycle as described in any one of claims 1 to 6.

Images