Architecture view model completion method and system based on relational graph convolutional network

Abstract

The application provides a kind of based on relationship diagram convolution network's architecture view model completion method and system, it is related to complex system and system engineering technical field, by mapping architecture view model structure into multi-type relationship knowledge graph, the element of multi-view model and its multi-type relationship are mapped into unified knowledge graph structure, not only realize unified data representation and structured input, but also support the analysis and reasoning of architecture, so that nodes and relationships can be directly processed by graph neural networks;Then by combining logical constraint rules and feature enhancement mechanism, improve the prediction accuracy and interpretability of R-GCN for missing nodes and relationships;Finally, through R-GCN model reasoning, the architecture model is realized, and the multi-view architecture is automatically semantically inferred, and finally the intelligent automatic completion of the missing elements of the architecture view model is realized.

Description

Technical Field

[0001] This invention relates to the field of complex systems and architecture engineering technology, and in particular to a method and system for completing an architecture view model based on a relational graph convolutional network. Background Technology

[0002] In complex systems and architecture engineering, the system architecture, as the top-level design, serves as a bridge between requirements analysis and detailed design. System architecture typically uses various view models to represent the relationships between elements such as system functions, activities, capabilities, and resources.

[0003] Traditional system architecture modeling methods rely on expert experience and manual design, mainly including the following steps: requirements analysis, identifying functions, capabilities, and constraints based on system requirements; architecture modeling, creating view models using architecture modeling tools (such as MagicDraw), including functional views, system views, and capability views; and logical verification, checking the model for completeness, consistency, and correctness, and identifying potential omissions or conflicts. However, traditional methods have certain limitations. For example, relying on human experience can easily lead to incomplete models or omissions of complex dependencies; verification methods are limited, lacking automated completion mechanisms, and current methods can only verify basic consistency, making it difficult to identify missing or inaccurate elements in cross-view dependencies or multi-level functional relationships, and there are currently no completion methods available.

[0004] In existing technologies, some studies have utilized knowledge graphs or rule-based reasoning to perform consistency checks on system architecture models. This primarily involves representing architectural elements (functions, activities, capabilities, resources) and their relationships as ontology structures, and then implementing consistency checks through logical rule-based reasoning.

[0005] Currently, there is no automatic completion method; only methods that verify and propose completion suggestions exist. A typical process includes: 1) mapping architectural elements to knowledge graph nodes; 2) defining logical rules or constraints (e.g., "If activity A has a precondition B, then B must exist"); 3) detecting missing relationships through an inference engine; and 4) manual review by designers who provide completion suggestions. However, this approach has the following shortcomings: 1) lack of deep learning capabilities for multi-relation network structures: traditional rule-based inference methods cannot capture high-order dependencies between different relationship types, thus only able to discover missing nodes or relationships based on explicit dependencies; 2) lack of automated completion capabilities: unable to adaptively infer new relationships based on contextual semantics and structural patterns; requires manual intervention for completion, and cannot achieve dynamic, closed-loop model optimization.

[0006] In summary, current technologies suffer from the following shortcomings: 1) Unified representation of system architecture view models: Existing system architecture models typically rely on specific modeling tools, and the differences in model expression between different tools lead to a lack of unified structured representation of system architecture data, making it difficult to form a universal and consistent model description system. 2) Prediction accuracy issues related to missing nodes and relationships: Traditional rule-based reasoning methods struggle to capture the implicit patterns of complex dependencies and lack effective utilization of node and edge features. 3) Logical consistency analysis and automatic completion issues: Existing system architecture analysis methods lack the ability to automatically reason about complex semantic relationships, making it difficult to achieve logical consistency detection and dynamic completion during model evolution. When semantic conflicts or structural omissions exist in the system architecture, traditional methods cannot effectively identify and repair them. Summary of the Invention

[0007] To address the technical problems of existing architecture models lacking a unified structured representation, having low accuracy in predicting missing nodes and relationships, and being unable to automatically complete them, this invention provides an architecture view model completion method and system based on Relational Graph Convolutional Network (R-GCN).

[0008] To achieve the above objectives, the present invention provides the following technical solution: The present invention provides a method for completing an architecture view model based on a relational graph convolutional network in its first aspect, comprising: S1. parsing an input architecture view model file, identifying architecture elements in the model, mapping the architecture elements to entity nodes and edges in a knowledge graph, constructing an initial knowledge graph and outputting it; S2. performing missing detection on the initial knowledge graph based on predefined logical constraint rules, encoding the missing detection results to obtain missing flag encoding, and fusing it with the structural features and logical category semantic features of the nodes to construct an enhanced feature matrix and output it, thereby completing the feature enhancement of the architecture view model; wherein, the structural features of the nodes are used to characterize the dependencies and importance of the nodes in the overall architecture, and the semantic features are used to characterize the logical category to which the nodes or edges belong; S3. constructing a relational graph convolutional network model, taking the enhanced feature matrix as input, realizing message passing and node embedding updates across types of edges through multi-layer relational convolution, using the trained relational graph convolutional network model to perform reasoning and completion of unknown relations, and generating missing nodes or edges as the output of the completed architecture view model.

[0009] The present invention provides a preferred solution in its first aspect. Step S1 specifically includes: reading the system architecture model XML file using an XML parsing tool, traversing all elements in the XML file, and filtering out key architecture elements based on element type, including class elements, instance specification elements, and information flow elements; mapping the filtered key architecture elements to entity nodes in the knowledge graph according to a predefined mapping rule table, wherein class elements are mapped to entity nodes including operational activities, capabilities, resources, or information elements; instance specification elements are mapped to instantiated nodes of their respective classes; and information flow elements are mapped to edges; for each edge, its source node, target node, and relation type are extracted to construct a triple; and all nodes and triples are integrated to generate the initial knowledge graph. Through XML parsing and predefined mapping rules, heterogeneous system architecture models generated by different modeling tools are uniformly converted into the node and edge structure of the knowledge graph, ensuring the structured and computable nature of the input data and providing a standardized data foundation for subsequent reasoning and completion.

[0010] The present invention provides a preferred embodiment in its first aspect. In step S2, the step of performing missing data detection on the initial knowledge graph based on predefined logical constraint rules includes: defining logical constraint rules, including: each operational activity node must be connected to at least one resource node; if two operational activity nodes have an execution dependency relationship, there must be an operation control flow edge or an operation object flow edge connecting them; each capability node must support at least one operational activity node. By defining three types of core logical constraint rules, the domain knowledge in the system architecture design is formalized, providing a quantifiable judgment benchmark for missing data detection. This enables the system to automatically identify logical defects in the model, compensating for the insufficient utilization of domain knowledge in purely data-driven methods.

[0011] The present invention provides a preferred embodiment in its first aspect. In step S2, the step of performing missing detection on the initial knowledge graph based on predefined logical constraint rules further includes: performing missing detection on the initial knowledge graph according to the logical constraint rules, comprising: if an operation activity node is not connected to a resource node, a missing node is detected and recorded in the missing annotation table; if two operation activity nodes have not established operation control flow edges or operation object flow edges, a missing node is detected and recorded in the missing annotation table; if a capability node does not support an operation activity node, a missing node is detected and recorded in the missing annotation table. By traversing the knowledge graph according to the logical constraint rules and recording missing information, automated identification and annotation of potential logical defects are achieved, providing accurate supervision signals for subsequent feature enhancement and improving the model's attention to and targeted repair of missing elements.

[0012] The present invention provides a preferred embodiment in the first aspect. In step S2, the step of encoding the missing detection result to obtain a missing label encoding, and fusing it with the structural features and logical category semantic features of the nodes to construct and output an enhanced feature matrix includes: for each node or edge, if a missing element is detected, it is labeled and encoded to obtain a missing label encoding; the in-degree and out-degree of each node in the knowledge graph are calculated to obtain the node's structural features; the logical category to which the node or edge belongs is one-hot encoded or represented by a low-dimensional embedding vector to obtain logical category semantic features; the structural features, logical category semantic features, and missing label encoding of the node are fused to form a complete node feature matrix as the enhanced feature matrix. Encoding the rule detection result as a logically enhanced feature, and deeply fusing it with the node's structural features (in-degree, out-degree) and semantic features (type embedding), achieves collaborative input of knowledge-driven and data-driven approaches, enabling the relational graph convolutional network to simultaneously utilize domain knowledge and topological information, significantly improving the accuracy and interpretability of missing relationship prediction.

[0013] In its first aspect, this invention provides a preferred embodiment where the initial knowledge graph is represented as: G=(V,E,R), where V is the set of nodes, E is the set of edges, and R is the set of relation types. By formalizing the system architecture model into a mathematical representation of the node set, edge set, and relation type set, a standardized input format is provided for graph neural network processing, the computable data structure boundaries of the model are clarified, and the mathematical definability of subsequent graph convolution operations is supported.

[0014] In its first aspect, the present invention provides a preferred embodiment. In step S3, the relational graph convolutional network model introduces the ability to distinguish edge types based on traditional graph convolutional networks, enabling the network to consider the characteristics of different relationships in node representation learning. By defining an independent transformation matrix for each relationship type, the neighbor information of the node is weighted and aggregated according to the relationship type, thereby generating the embedded representation of the node. By introducing a mechanism to distinguish edge types in traditional graph convolutional networks, the model can perform feature aggregation according to different relationship types (such as execution relationships, support relationships, and consumption relationships), effectively capturing the high-order dependency patterns of multiple types of relationships in the system architecture, and overcoming the limitation of traditional rule-based reasoning in handling complex multi-relationship networks.

[0015] In a first aspect, the present invention provides a preferred embodiment in which, in step S3, the propagation formula of the relational graph convolutional network model is: ; in, For the first Layer nodes i Embedded representation, It is a non-linear activation function. For a set of relation types, For a specific relation type, For nodes i In relation types r The set of neighboring nodes below, For the first Correspondence type in layer The weight transformation matrix, For the first Layer neighbor nodes j Embedded representation, For the first The weight transformation matrix of the self-loop in the layer. For the first Layer nodes i The embedding representation is defined. By defining the propagation mechanism of relation-specific transformation matrix and self-loop matrix, the layer-by-layer feature aggregation and update of nodes on multi-relation graphs are realized, providing a trainable and optimizable mathematical framework for the model to learn the node embedding representation, and supporting the efficient solution of subsequent link prediction tasks.

[0016] In a first aspect, the present invention provides a preferred embodiment in step S3, wherein during the training process of the relation graph convolutional network model, known relation triples are used as positive samples, and pseudo-missing samples are generated through negative sampling to minimize the link prediction loss function. By using known relations as positive samples, generating negative samples through negative sampling, and minimizing the binary cross-entropy loss, supervised learning of edge existence is achieved, enabling the model to effectively distinguish between real relations and missing relations. After training, the model possesses a high-confidence prediction and completion capability for unknown relations.

[0017] In a second aspect, this invention provides an architecture view model completion system based on a relational graph convolutional network, used to execute the method, comprising: a structure extraction and graph generation module, used to parse the input architecture view model file, identify the architecture elements in the model, map the architecture elements to entity nodes and edges in a knowledge graph, construct an initial knowledge graph and output it; and a missing detection and feature enhancement module, used to perform missing detection on the initial knowledge graph based on predefined logical constraint rules, encode the missing detection results to obtain missing flag codes, and fuse them with the structural features and logical category semantic features of the nodes to construct an enhanced feature matrix and output it, thereby completing the feature enhancement of the architecture view model; wherein, the structural features of the nodes are used to characterize the dependencies and importance of the nodes in the overall architecture, and the semantic features are used to characterize the logical categories to which the nodes or edges belong; The view model reasoning and completion module is used to construct a relational graph convolutional network model. The enhanced feature matrix is ​​used as input, and message passing and node embedding updates of cross-type edges are realized through multi-layer relational convolution. The trained relational graph convolutional network model is used to reason and complete unknown relations, and the missing nodes or edges are generated as the output of the completed system architecture view model.

[0018] Compared with the prior art, the present invention has the following advantages: This invention structures and maps the architecture view model into a multi-type relational knowledge graph. It maps the elements (capabilities, operations, systems, etc.) of the multi-view model and their various relationships into a unified knowledge graph structure. This not only achieves unified data representation and structured input but also supports the analysis and reasoning of the architecture, enabling nodes and relationships to be directly processed by graph neural networks. Then, by combining logical constraint rules and feature enhancement mechanisms, the prediction accuracy and interpretability of R-GCN for missing nodes and relationships are improved. Finally, a Relational Graph Convolutional Network (R-GCN) is introduced to perform feature aggregation and node representation learning on the multi-relational knowledge graph. The architecture model is then implemented through R-GCN model reasoning, automating semantic reasoning of the multi-view architecture, ultimately achieving intelligent automatic completion of missing elements in the architecture view model. This process significantly reduces the burden of manual modeling and inspection while forming a data-driven design closed loop, supporting the continuous evolution and intelligent optimization of the architecture. Attached Figure Description

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

[0020] Figure 1 This is a flowchart illustrating the steps of a method for completing an architecture view model based on a relational graph convolutional network according to an embodiment of the present invention. Figure 2 A flowchart illustrating an embodiment of the present invention for a method to complete an architecture view model based on a relational graph convolutional network; Figure 3 This is an architecture diagram of a system for completing a relational graph convolutional network-based architecture view model, provided in one embodiment of the present invention. Figure 4 The graph shows the training convergence curve of the R-GCN model in the architecture view model completion method based on relational graph convolutional networks provided in one embodiment of the present invention. Detailed Implementation

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

[0022] Please refer to Figure 1 and Figure 2 In one optional implementation, an architecture view model completion method based on relational graph convolutional networks is provided, which is mainly implemented through steps S1 to S3.

[0023] (1) Extraction of system architecture view model structure and generation of knowledge graph (step one) This embodiment proposes a structure extraction and knowledge graph generation process for a system architecture view model, the steps of which are as follows: 1) Model parsing and node (element) recognition In one optional implementation, the DoDAF architecture model XML file is first used as input, implemented through step S1. S1. Parse the input architecture view model file, identify the architecture elements in the model, map the architecture elements to entity nodes and edges in the knowledge graph, construct the initial knowledge graph, and output it. Step S1 specifically includes the following sub-steps: ① XML file reading and node traversal and filtering: S11. Read the system architecture model XML file through an XML parsing tool (such as lxml), identify the nested structure of packagedElement (encapsulated element, refers to the structured element in the XML file used to encapsulate the system architecture model), traverse all elements in the XML file, and filter out key architecture elements according to the element type (xmi:type), including class elements, instance specification elements and information flow elements.

[0024] • uml:Class → Class element (logical category element), including: OperationalActivity, Capability, Resource, System, InformationElement, etc.

[0025] • uml:InstanceSpecification → Instance specification element, representing a modeling element in UML used to define the characteristics of an object instance; • uml:InformationFlow → Information flow element used for relation extraction.

[0026] Ignore unstructured or invalid information, such as auxiliary labels or redundant nodes generated by modeling tools.

[0027] ② Element Mapping and Transformation: S12. Based on the predefined mapping rule table, the selected key architectural elements are mapped to entity nodes and edges in the knowledge graph. Specifically, class elements are mapped to entity nodes that include operational activities, capabilities, resources, or information elements; instance specification elements are mapped to instantiation nodes of their respective classes; and information flow elements are mapped to edges.

[0028] Specifically, for the selected key architectural elements, they are mapped to entity nodes in the knowledge graph according to a predefined mapping rule table. The mapping rule table includes: • Map UML classes (uml:Class) to entity nodes such as OperationalActivity, Capability, Resource, System, and InformationElement in the knowledge graph; • Map the UML instance specification (uml:InstanceSpecification) to the instance node of its class; • Map the information flow as edges (relationships) for subsequent relation extraction and knowledge graph construction.

[0029] ③ Element attribute extraction: Extract relevant attribute information of elements, such as name, hierarchical position, port or component attributes, and store them in a temporary data structure for easy vectorization processing later.

[0030] By following the steps above, the identification of elements in the system architecture model and the mapping of knowledge graph entity nodes / edges can be completed.

[0031] 2) Relation Extraction and Semantic Mapping S13. For each edge (relation), extract its source node, target node, and relation type to construct a triple. Integrate all nodes and triples to generate the initial knowledge graph. More specifically, for the logical relations defined in the model, the specific steps are as follows: ① Relationship type identification Parse and identify the relationship types in the XML model, such as IsCapableToPerform, Implements, Exhibits, MapsToCapability, etc.

[0032] ② Construction of relational triples For each edge (relation), extract its source node (subject), target node (object), and relation type (predicate) to construct an RDF triple (subject, predicate, object).

[0033] ③ Preliminary knowledge graph generation Integrate all nodes with triples to generate an initial knowledge graph G=(V,E,R), where V is the set of nodes, E is the set of edges, and R is the set of relation types.

[0034] ④ Relationship attribute records Record relevant attributes for each edge (relationship), such as directionality, weight, and logical constraint identifiers, to provide a foundation for subsequent feature enhancement and graph neural network input.

[0035] Through the above steps, the extraction and semantic mapping of edges (relationships) in the system architecture model can be completed, laying the foundation for the construction of knowledge graphs.

[0036] (2) Preliminary confirmation detection and feature enhancement based on rules or logical constraints (Step 2) This embodiment addresses the logical defects and element omissions in the system architecture view model by proposing a processing mechanism combining rule-based reasoning and feature enhancement, implemented through S2. S2. Based on predefined logical constraint rules, the initial knowledge graph undergoes missing detection. The missing detection results are encoded to obtain missing flag codes, which are then fused with the structural features and logical category semantic features of nodes to construct and output an enhanced feature matrix, thereby enhancing the features of the system architecture view model. The structural features of nodes characterize their dependencies and importance within the overall system architecture, while the semantic features characterize the logical category to which a node or edge belongs. Furthermore, step S2, which involves missing detection of the initial knowledge graph based on predefined logical constraint rules, further includes: performing missing detection on the initial knowledge graph according to the logical constraint rules, including: if an operational node is not connected to a resource node, a missing node is detected and recorded in the missing label table; if two operational nodes have not established an operational control flow edge or an operational object flow edge, a missing node is detected and recorded in the missing label table; if a capability node does not support an operational node, a missing node is detected and recorded in the missing label table. Specifically, this can be achieved through the following steps: To detect potential logical defects or missing elements in the system architecture model, this invention defines the following logical constraint rules: 1) Logical rule definition and missing detection ① Activity resource consumption rules Each operational node must be connected to at least one resource node. Specifically: Each OperationalActivity node must be connected to at least one Resource node, represented by a PerformedBy relationship. If a node does not meet this condition, MissingResourceFlag=True is recorded in the Missing Label table. For example, the nodes Detect Target and Engage Target must consume at least one resource node, such as Radar Sensor or Weapon System.

[0037] ② Rules for Prerequisites of the Activity If two operation activity nodes have an execution dependency, then there must be an operation control flow edge or an operation object flow edge to connect them. Specifically: If two OperationalActivity nodes have an execution dependency, they must be connected by an OperationalControlFlow or OperationalObjectFlow edge. If this edge is not established, MissingOperationalFlow=True is recorded in the missing annotation table. For example, Track Target must be a prerequisite for Engage Target.

[0038] ③ Capability Support Rules Each capability node must support at least one active node. Specifically: Each Capability node must support at least one OperationalActivity node. If no Supports edge is established, MissingSupportsFlag=True is recorded in the Missing Labels table. For example, ISR Capability must be associated with Detect Target activity.

[0039] 2) Feature enhancement of the view model After completing rule reasoning and missing data detection, this embodiment further enhances the features of nodes and edges (relationships) by explicitly encoding logical information into numerical vectors. Specifically, in step S2, the step of encoding the missing data detection results to obtain missing data flag encoding, fusing it with the structural features and logical category semantic features of the nodes, constructing an enhanced feature matrix, and outputting it is achieved through sub-steps such as missing data flag encoding, topological dependency counting, logical category embedding, and feature matrix construction. The specific operation steps are as follows: ① Missing flag encoding (missing_flag) For each node or edge, if a missing node is detected, it is labeled and encoded to obtain a missing node flag code. Specifically: For each node or edge, if rule inference detects a potential missing element—for example, if an OperationalActivity does not consume any resources or a Capability is not associated with any activity—then the missing_flag is set to 1; otherwise, it is 0. This feature can serve as a key area of ​​focus for the model, guiding R-GCN to assign higher weights to potentially missing elements during training.

[0040] ②Topology dependency counting (dependency_count) By calculating the in-degree and out-degree of each node in the knowledge graph, we can obtain the structural features of the nodes. Specifically: By calculating the in-degree (number of times a node is depended on) and out-degree (number of times it depends on others) of each node in the knowledge graph, we obtain the structural characteristics of the node. These characteristics reflect the node's dependencies and importance in the overall system architecture, helping the model understand the role of the node in the network structure.

[0041] ③ Logical type embedding (logic_type_embedding) The logical category to which a node or edge belongs is represented by one-hot encoding or low-dimensional embedding vector to obtain the semantic features of the logical category. Specifically: The logical category (such as OperationalActivity, Capability, etc.) to which a node or edge (relationship) belongs is represented by one-hot encoding or a low-dimensional embedding vector. For edges (relationships), embeddings can also be constructed based on the relationship type (such as IsCapableToPerform, Implements). This vectorization approach enables the model to distinguish different logical categories, improving prediction accuracy.

[0042] ④ Construction of feature matrix The structural features, logical category semantic features, and missing value encoding of nodes are fused to form a complete node feature matrix as the enhanced feature matrix: The structural features (in-degree, out-degree), logical category semantic features (type encoding), and missing flag encoding of nodes are fused to form a complete node feature matrix. Finally, this feature matrix serves as the input to the R-GCN model.

[0043] Through the above steps, the model can not only understand the topological and type information of nodes, but also pay more attention to potential missing elements by utilizing logical constraint information, thereby improving completion performance.

[0044] (3) View model reasoning completion based on R-GCN (Step 3) This embodiment proposes a method for automatically completing the architecture view model using Relational Graph Convolutional Networks (R-GCN). R-GCN is a type of graph neural network model specifically designed for processing multi-relational graphs. It introduces the ability to distinguish edge types on the basis of traditional graph convolutional networks, enabling the network to consider the characteristics of different relationships in node representation learning. R-GCN generates the node's embedding representation by defining an independent transformation matrix for each relationship type and weighting and aggregating the node's neighbor information according to the relationship type. This mechanism enables it to effectively model graph structures with multiple relationship types, such as knowledge graphs, supporting tasks such as node classification, link prediction, and graph completion. Specifically, this is achieved through step S3. S3. Construct a relational graph convolutional network model, using the enhanced feature matrix as input, and implement message passing and node embedding updates across edge types through multi-layer relational convolution. The trained relational graph convolutional network model is used to infer and complete unknown relationships, generating missing nodes or edges as the output of the completed architecture view model. More specifically, step S3 is implemented through the following key sub-steps: 1) R-GCN Model Construction The input includes a node feature matrix and a set of relation types. The R-GCN model achieves message passing and node embedding updates across different edge types through multi-layer relation convolution.

[0045] The core propagation formula of the R-GCN model is: ; in, For the first Layer nodes i Embedded representation, It is a non-linear activation function. For a set of relation types, For a specific relation type, For nodesi In relation types The set of neighboring nodes below, For the first Correspondence type in layer The weight matrix, For the first Layer neighbor nodes j Embedded representation, For the first The weight matrix of a self-looping layer. For the first Layer nodes i Embedded representation.

[0046] 2) Model training and prediction The training phase uses known relation triples. As positive samples, pseudo-missing samples are generated through negative sampling. Minimize the link prediction loss function:

[0047] in, The loss value. For positive sample triples, For the positive sample set, For negative sample triples For the negative sample set, For the scoring function, this embodiment uses the sigmoid function to obtain the predicted probability value of the triple. h , r , t These represent the source node (subject), the relation type (predicate), and the target node (object), respectively.

[0048] After training, the R-GCN model can perform inference completion for unknown relationships. During the inference phase, if the predicted probability... (Confidence threshold) If 0.8 is usually used, then missing relationships or node completion results will be automatically generated.

[0049] Please refer to Figure 3 Corresponding to this specific embodiment, an architecture view model completion system based on relational graph convolutional networks is provided for executing the above method, and mainly consists of the following modules: The structure extraction and graph generation module 1 is used to parse the input system architecture view model file, identify the architecture elements in the model, map the architecture elements to entity nodes and edges in the knowledge graph, construct the initial knowledge graph and output it. The missing detection and feature enhancement module 2 is used to perform missing detection on the initial knowledge graph based on predefined logical constraint rules, encode the missing detection results to obtain missing flag codes, and fuse them with the structural features and logical category semantic features of the nodes to construct an enhanced feature matrix and output it, so as to complete the feature enhancement of the system architecture view model; wherein, the structural features of the nodes are used to characterize the dependencies and importance of the nodes in the overall system architecture, and the semantic features are used to characterize the logical category to which the nodes or edges belong; The view model reasoning and completion module 3 is used to construct a relational graph convolutional network model. The enhanced feature matrix is ​​used as input, and message passing and node embedding update of cross-type edges are realized through multi-layer relational convolution. The trained relational graph convolutional network model is used to reason and complete unknown relations, and the missing nodes or edges are generated as the output of the completed system architecture view model.

[0050] To further illustrate and verify the effectiveness of the above-described embodiments of the present invention, a specific application scenario example will be given below: The effectiveness and feasibility of the proposed method are verified using a maritime search and rescue (SAR) system as a validation scenario. The SAR system aims to achieve collaboration among command centers, unmanned surface vessels, drones, helicopters, and other mission units to complete the search, identification, location, and rescue of distressed targets. The system achieves cross-platform data exchange and functional coordination through information links. Its complex architecture model is prone to logical inconsistencies and missing elements, affecting the completeness of the system design.

[0051] An initial SAR system DoDAF model was constructed as input data, mainly including the Operational Activity Model (OV-5b) and the System Interface Description (SV-1). This model contains the elements shown in Table 1.

[0052] Table 1: Element Types Included in the Model

[0053] To verify the completion capability, the following logical defects are pre-defined in the model: Defect 1: The OperationalActivity "Helicopter Precise Positioning" does not define its Resource; Defect 2: The System "Unmanned Surface Vessel" and OperationalActivity "Surface Confirmation" lack the IsCapableToPerform relationship; Defect 3: The Capability "Resource Delivery Capability" does not have a Supports relationship with any OperationalActivity.

[0054] (1) Model analysis and graph conversion The XML parsing module is used to extract elements and relationships from the DoDAF model file. Elements are mapped to nodes, and relationships are mapped to directed edges, forming a structured knowledge graph.

[0055] The unified coding for node categories is shown in Table 2.

[0056] Table 2: Node Type Encoding

[0057] (2) Node feature construction A feature vector is constructed for each node, fusing structural features, logical category semantic features, and missing information (missing information flag encoding) to form an input matrix. Finally, a feature matrix fusing logical and structural features is generated. Node feature types are shown in Table 3.

[0058] Table 3: Node Feature Types

[0059] (3) Execute logical reasoning rules The system uses SWRL to define logical completeness rules and performs inference through the OWL inference engine Pellet to automatically identify logical defects in the model. The rules are shown in Table 4.

[0060] Table 4: Logical Reasoning Rules

[0061] The inference results output a defect annotation table, as shown in Table 5. After the annotation table is generated, the system sets the missing_flag of the defect node to 1 for subsequent feature enhancement.

[0062] Table 5: Output Defect (Missing) Labeling Table

[0063] The defect annotations output by logical reasoning are used as additional semantic signals and fused with the structural feature matrix. The enhanced features include: • missing_flag (0 / 1) dependency_count (node ​​degree information) • logic_type_embedding (Logical category embedding) (4) Training of relational graph convolutional network model The R-GCN model was used to train and infer the enhanced knowledge graph. The model structure parameters are shown in Table 6.

[0064] Table 6: R-GCN Model Structural Parameters

[0065] The resulting convergence curve is as follows Figure 4 As shown in the figure, the training convergence curves reveal that the loss function significantly decreases and stabilizes after approximately 300 training epochs, indicating that the R-GCN model successfully learned the structural patterns and relational features in the knowledge graph. The loss value gradually decreased from an initial 1.09 to around 0.02, validating the effectiveness of the training process and the convergence of the model parameters.

[0066] (5) Complete the results and verify them During the inference phase, the model output high-confidence completion relations, successfully repairing two of the three pre-set defects, achieving a completion rate of 66.7%. Specific results are shown in Figure 7 below.

[0067] Table 7: Completion Results

[0068] The completion rate in this experiment was 66.7%, failing to reach 100%. The main reason for this shortfall was insufficient learning of the relationship between "helicopter precise positioning - consumption - high-resolution imagery". Analysis shows that the lack of sufficient training samples of similar activity consumption imagery resources in the atlas makes it difficult for the model to accurately infer this specific pattern. This reflects that in practical applications, the coverage and pattern diversity of the training data have a significant impact on the completion effect. Future performance can be further improved by increasing the number of training instances with similar relationships.

[0069] This experiment verifies the feasibility and effectiveness of the automatic completion method for architecture view models based on R-GCN. In the case of a maritime search and rescue system, the method achieved a completion rate of 66.7% for three preset logical defects, accurately predicting two missing relationships: "unmanned surface vessel performs surface confirmation" and "supply delivery capability supports the delivery of life-saving equipment." This demonstrates that the model can effectively learn semantic patterns and logical constraints in the architecture. Although the relationship "helicopter precise positioning consumes high-resolution imagery" was not successfully completed, reflecting the impact of data coverage on model performance, the overall results show that the method has significant application value in quality assurance and automated completion of architecture models, providing an effective technical approach for the integrity verification of complex system architectures.

[0070] Based on the above embodiments and verification examples, the system and method for completing the architecture view model based on relational graph convolutional networks provided by the present invention have the following beneficial technical effects compared with the prior art: 1. Implement a unified structured representation of the system architecture view model. This invention constructs a unified and computable structured data representation by mapping architectural elements and their relationships in a system architecture view model (including but not limited to OV-5b, SV-1, CV-6, etc. under the DoDAF framework) to entity nodes and edges in a knowledge graph. This mapping mechanism is compatible with various modeling tools (such as MagicDraw) and various data formats (such as XML, JSON, XMI), overcoming the inconsistency in model representation caused by differences in modeling tools in existing technologies, and laying a data foundation for automated analysis and reasoning of system architectures.

[0071] 2. Improve the prediction accuracy of missing nodes and relationships. This invention introduces logical constraint rules (such as activity resource consumption rules and capability support rules) into the knowledge graph reasoning stage to perform preliminary detection of potential missing elements. The detection results are encoded into feature vectors (such as missing node flags, topological dependency counts, and logical category embeddings), which are then fused with node structural features and input into the relational graph convolutional network. This feature enhancement mechanism achieves a deep integration of data-driven and knowledge-driven approaches, enabling the model to effectively utilize the domain knowledge and structural patterns of the system architecture. Compared to traditional rule-based reasoning methods, it significantly improves the prediction accuracy and interpretability for missing nodes and relationships.

[0072] 3. Achieve automated completion and closed-loop optimization of the system architecture model. This invention utilizes a relational graph convolutional network to perform feature aggregation and node representation learning on a multi-relational knowledge graph. Through a link prediction task, it achieves automatic reasoning and completion of missing nodes and relationships without manual intervention. The model supports continuous learning, iteratively updating node representations and relationship weights with new data to form a data-driven design loop, supporting continuous evolution and intelligent optimization of the system architecture. Experimental verification using a maritime search and rescue system as an example shows that this method achieves a completion rate of 66.7% for pre-defined logical defects, successfully predicting missing relationships such as "unmanned surface vessel performs surface confirmation" and "supply delivery capability supports the delivery of life-saving equipment," verifying the feasibility and effectiveness of the method.

[0073] 4. Reduce the burden of manual modeling and inspection, and improve design efficiency. This invention, through an automated completion mechanism, frees designers from tedious model integrity checks and manual completion work, effectively reducing reliance on expert experience in the system architecture design process, reducing model incompleteness caused by human negligence, and significantly improving the design efficiency and quality assurance level of complex system architectures.

[0074] Those skilled in the art will understand that all or part of the processes in the above embodiments can be implemented by a computer program instructing related hardware. The program can be stored in a computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. The storage medium can be a magnetic disk, optical disk, read-only memory (ROM), or random access memory (RAM), etc.

[0075] The technical features of the above embodiments can be combined arbitrarily. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as the combination of these technical features does not contradict each other, it should be considered within the scope of this specification. Furthermore, the above embodiments only illustrate several implementation methods of the present invention, and their descriptions are relatively specific and detailed, but they should not be construed as limiting the scope of the present invention. For those skilled in the art, several modifications and improvements can be made without departing from the concept of the present invention, and these all fall within the protection scope of the present invention.

Claims

1. A method for completing an architecture view model based on a relational graph convolutional network, characterized in that, include: S1. Parse the input system architecture view model file, identify the architecture elements in the model, map the architecture elements to entity nodes and edges in the knowledge graph, construct the initial knowledge graph and output it; S2. Based on predefined logical constraint rules, perform missing detection on the initial knowledge graph, encode the missing detection results to obtain missing flag codes, and fuse them with the structural features and logical category semantic features of the nodes to construct an enhanced feature matrix and output it to complete the feature enhancement of the system architecture view model; wherein, the structural features of the nodes are used to characterize the dependencies and importance of the nodes in the overall system architecture, and the semantic features are used to characterize the logical category to which the nodes or edges belong; S3. Construct a relational graph convolutional network model, take the enhanced feature matrix as input, realize message passing and node embedding update of cross-type edges through multi-layer relational convolution, use the trained relational graph convolutional network model to infer and complete unknown relations, and generate missing nodes or edges as the output of the completed system architecture view model.

2. The method for completing the architecture view model based on relational graph convolutional networks according to claim 1, characterized in that, Step S1 specifically includes: The system architecture model XML file is read using an XML parsing tool. All elements in the XML file are traversed, and key architecture elements are selected based on element type, including class elements, instance specification elements, and information flow elements. Based on a predefined mapping rule table, the selected key architectural elements are mapped to entity nodes in the knowledge graph. Specifically, class elements are mapped to entity nodes that include operational activities, capabilities, resources, or information elements; instance specification elements are mapped to instantiation nodes of their respective classes; and information flow elements are mapped to edges. For each edge, extract its source node, target node, and relation type to construct a triple, and integrate all nodes and triples to generate the initial knowledge graph.

3. The method for completing the architecture view model based on relational graph convolutional networks according to claim 2, characterized in that, In step S2, the step of performing missing detection on the initial knowledge graph based on predefined logical constraint rules includes: Define logical constraint rules, including: Each operational node must be connected to at least one resource node; If two operation activity nodes have an execution dependency, then there must be an operation control flow edge or an operation object flow edge to connect them; Each capability node must support at least one operational node.

4. The method for completing the architecture view model based on relational graph convolutional networks according to claim 3, characterized in that, In step S2, the step of performing missing detection on the initial knowledge graph based on predefined logical constraint rules further includes: performing missing detection on the initial knowledge graph according to the logical constraint rules, including: If an active node is not connected to a resource node, a missing node is detected and recorded in the missing node label table. If two operation activity nodes have not established operation control flow edges or operation object flow edges, a missing node is detected and recorded in the missing node label table. If a capability node does not support an operational activity node, a missing node is detected and recorded in the missing node label table.

5. The method for completing the architecture view model based on relational graph convolutional networks according to claim 1, characterized in that, In step S2, the step of encoding the missing detection result to obtain the missing flag encoding, fusing it with the structural features and logical category semantic features of the node, constructing an enhanced feature matrix, and outputting it includes: For each node or edge, if a missing node is detected, it is labeled and encoded to obtain the missing node label code. By calculating the in-degree and out-degree of each node in the knowledge graph, the structural features of the nodes can be obtained. The logical category to which a node or edge belongs is represented by one-hot encoding or low-dimensional embedding vector to obtain the semantic features of the logical category; The structural features, logical category semantic features, and missing flag encoding of nodes are fused to form a complete node feature matrix as the enhanced feature matrix.

6. The method for completing the architecture view model based on relational graph convolutional networks according to claim 2, characterized in that, The initial knowledge graph is represented as: G=(V,E,R), where V is the set of nodes, E is the set of edges, and R is the set of relation types.

7. The method for completing the architecture view model based on relational graph convolutional networks according to claim 6, characterized in that, In step S3, the relational graph convolutional network model introduces the ability to distinguish edge types on the basis of traditional graph convolutional networks, enabling the network to consider the characteristics of different relations in node representation learning; by defining an independent transformation matrix for each relation type, the neighbor information of the node is weighted and aggregated according to the relation type, thereby generating the embedded representation of the node.

8. The method for completing the architecture view model based on relational graph convolutional networks according to claim 7, characterized in that, In step S3, the propagation formula of the relational graph convolutional network model is: ； in, For the first Layer nodes i Embedded representation, It is a non-linear activation function. For a set of relation types, For a specific relation type, For nodes i In relation types r The set of neighboring nodes below, For the first Correspondence type in layer The weight transformation matrix, For the first Layer neighbor nodes j Embedded representation, For the first The weight transformation matrix of the self-loop in the layer. For the first Layer nodes i Embedded representation.

9. The method for completing the architecture view model based on relational graph convolutional networks according to claim 2, characterized in that, In step S3, during the training process, the relation graph convolutional network model uses triples of known relations as positive samples and generates pseudo-missing samples through negative sampling to minimize the link prediction loss function.

10. A system for completing an architecture view model based on a relational graph convolutional network, used to perform the method described in any one of claims 1 to 9, characterized in that, include: The structure extraction and graph generation module is used to parse the input system architecture view model file, identify the architecture elements in the model, map the architecture elements to entity nodes and edges in the knowledge graph, construct the initial knowledge graph and output it. The missing detection and feature enhancement module is used to perform missing detection on the initial knowledge graph based on predefined logical constraint rules, encode the missing detection results to obtain missing flag codes, and fuse them with the structural features and logical category semantic features of the nodes to construct an enhanced feature matrix and output it, so as to complete the feature enhancement of the system architecture view model; wherein, the structural features of the nodes are used to characterize the dependencies and importance of the nodes in the overall system architecture, and the semantic features are used to characterize the logical category to which the nodes or edges belong; The view model reasoning and completion module is used to construct a relational graph convolutional network model. The enhanced feature matrix is ​​used as input, and message passing and node embedding updates of cross-type edges are realized through multi-layer relational convolution. The trained relational graph convolutional network model is used to reason and complete unknown relations, and the missing nodes or edges are generated as the output of the completed system architecture view model.

Images