Intelligent bionic implementation software architecture design method based on large model group

By using a large model group-based intelligent biomimetic approach, the problems of insufficient requirement analysis and inaccurate component retrieval in existing software architecture designs are solved, resulting in a software architecture design that is more in line with actual needs and global optimization.

CN121578997APending Publication Date: 2026-02-27XIAN RUNHE SOFTWARE INFORMATION TECHNOLOGY CO LTD
View PDF 0 Cites 3 Cited by

Patent Information

Application Number
CN202511738721.7
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2025-11-25
Publication Date
2026-02-27

AI Technical Summary

Technical Problem

Existing software architecture design methods lack the ability to deeply analyze the semantics of requirements, the relevance and completeness of component retrieval results are insufficient, it is difficult to handle dynamic dependency verification in complex contexts, and the optimization and adjustment process is prone to getting stuck in local optima and lacks global rationality.

Method used

We employ an intelligent biomimetic approach based on large model groups. Through multi-level semantic analysis, we generate an initial set of components and a contextual description. We retrieve candidate component knowledge from a distributed knowledge base, perform consistency verification using a dynamic inference engine, generate candidate software architectures by combining an architecture template matching algorithm, and output the target software architecture design through iterative adjustments using optimization strategies.

Benefits of technology

It achieves deep semantic parsing of requirements, improves the accuracy of component retrieval and consistency verification capabilities, and generates an architecture that better meets actual needs, with higher global optimization and adaptability.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN121578997A_ABST
    Figure CN121578997A_ABST
Patent Text Reader

Abstract

The invention relates to the technical field of software architecture design, and discloses a software architecture design method based on intelligent bionic implementation of a large model group. The method comprises the steps of obtaining software design requirement input; performing multi-level semantic analysis on software design requirement input to generate an initial component set and context environment description; based on the context environment description, candidate component knowledge related to the initial component set is retrieved from a distributed knowledge base; performing consistency verification on the candidate component knowledge and the initial component set by utilizing a dynamic inference engine to generate a verified component map; according to the verified component atlas, candidate software architectures are generated through an architecture template matching algorithm; and performing iterative adjustment on the candidate software architecture by adopting an optimization strategy, and outputting a target software architecture design. Through collaborative analysis and intelligent reasoning of the large model group, automation and intelligence of software architecture design are achieved, and the efficiency and quality of software design are improved.
Need to check novelty before this filing date? Find Prior Art

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of software architecture design, in particular to a software architecture design method based on intelligent bionic implementation of a large model group. BACKGROUND

[0002] Current software architecture design mainly relies on artificial experience or template-based methods based on fixed patterns. The analysis of existing technologies on demand mostly stays at the surface level, lacking the ability to analyze the deep semantic of demand, resulting in deviation of initial component division from the actual situation. The component retrieval process is usually based on keyword matching or simple rules, which cannot effectively utilize the associated information in the distributed knowledge base, and the relevance and integrity of the retrieval results are insufficient. The component consistency check mostly adopts static rule checking, which is difficult to deal with dynamic dependency relationship verification in complex context environment. The architecture generation link relies on the mechanical matching of pre-defined templates, lacking the flexibility of adapting to the interaction between components.

[0003] The optimization adjustment process is often based on local heuristic strategies, which is easy to fall into local optimal solution and difficult to ensure the global rationality of architecture design. Software architecture design needs to solve the whole process intelligent problem from demand analysis to architecture generation, especially to realize the integrated method of deep semantic analysis of demand, collaborative use of distributed knowledge, dynamic consistency verification and global optimization adjustment. SUMMARY

[0004] The purpose of the present application is to provide a software architecture design method based on intelligent bionic implementation of a large model group to solve the problems raised in the background art.

[0005] To achieve the above purpose, the present application provides a software architecture design method based on intelligent bionic implementation of a large model group, which comprises: Obtaining software design requirement input; Performing multi-level semantic analysis on the software design requirement input to generate an initial component set and a context environment description; Based on the context environment description, retrieving candidate component knowledge related to the initial component set from the distributed knowledge base; Using a dynamic reasoning engine to perform consistency check on the candidate component knowledge and the initial component set to generate a verified component graph; According to the verified component graph, generating a candidate software architecture through an architecture template matching algorithm; Using an optimization strategy to iteratively adjust the candidate software architecture to output a target software architecture design.

[0006] Preferably, the multi-level semantic analysis of the software design requirement input to generate an initial component set and a context environment description comprises: The software design requirements input is parsed to remove irrelevant characters and generate a standardized text stream. Lexical segmentation is performed on the normalized text stream to identify key terms and relational connectives, forming a lexical network; Based on the vocabulary network, software component identifiers and associated attributes are extracted to construct an initial component set; Simultaneously, environmental constraints and business logic descriptions are separated from the vocabulary network to generate a contextual environment description.

[0007] Preferably, based on the context description, candidate component knowledge related to the initial component set is retrieved from the distributed knowledge base, including: Based on the key constraints in the context description, a retrieval query vector is generated; The retrieval query vector is sent to a distributed knowledge base to perform a parallel index scan and obtain preliminary matching knowledge fragments. Based on the component identifiers in the initial component set, the preliminary matching knowledge fragments are filtered to remove irrelevant entries; The filtered knowledge fragments are reordered to generate candidate component knowledge.

[0008] Preferably, a dynamic inference engine is used to perform consistency verification on the candidate component knowledge and the initial component set to generate a verified component graph, including: The candidate component knowledge is converted into a set of logical assertions; Map the initial set of components to an entity relationship graph; The dynamic reasoning engine is used to perform rule matching on the set of logical assertions and the entity relationship graph to detect conflicting nodes. Correct or replace the detected conflicting nodes to generate consistency verification results; Based on the consistency verification results, the entity relationship graph is updated to generate the verified component graph.

[0009] Preferably, based on the verified component graph, a candidate software architecture is generated using an architecture template matching algorithm, including: Load a collection of predefined architecture templates from the template library; Calculate the similarity score between the verified component graph and each architecture template; Choose the architecture template with the highest similarity score as the basic framework; The verified component graph is injected into the basic framework to fill the component slots and generate a candidate software architecture.

[0010] Preferably, an optimization strategy is used to iteratively adjust the candidate software architecture to output the target software architecture design, including: Define the optimization objective function, including performance metrics and resource constraints; Structural analysis was performed on the candidate software architectures to identify optimization points; The candidate software architectures are mutated and crossovered using a genetic algorithm to generate new architecture variants. Evaluate each new architecture variant against the stated optimization objective function, preserving the optimal solution; Repeat the iterative process until the termination condition is met, and output the target software architecture design.

[0011] Preferably, the normalized text stream is lexically segmented to identify key terms and relational connectives, forming a lexical network, including: The normalized text stream is split into word sequences using a tokenizer; Each word is tagged with its part of speech, and nouns and verbs are filtered out as key terms; Detect conjunction patterns in word sequences and extract relational conjunctions; Construct a vocabulary network with key terms as nodes and relational words as edges.

[0012] Preferably, the filtered knowledge fragments are reordered to generate candidate component knowledge, including: Calculate the semantic relevance score of each knowledge fragment to the initial set of components; Knowledge fragments are sorted in descending order based on semantic relevance scores; Merge duplicate or overlapping knowledge segments to generate a deduplicated knowledge list; The deduplicated knowledge list is used as candidate component knowledge.

[0013] Preferably, a dynamic inference engine is used to perform rule matching on the logical assertion set and the entity relationship graph to detect conflicting nodes, including: Load the predefined business rule library; The logical assertion set is matched with the business rule base to identify assertions that violate the rules; Traverse the entity relationship graph and check whether the node attributes are consistent with the assertions that violate the rules; Nodes with inconsistent labels are called conflicting nodes.

[0014] Preferably, a genetic algorithm is applied to the candidate software architecture to perform mutation and crossover operations, generating new architecture variants, including: The candidate software architecture is encoded as a chromosome representation; Randomly select chromosomes for point mutation to modify component types or connectivity relationships; Two chromosomes are selected for crossover, exchanging some gene sequences. The resulting new chromosome is decoded as a new architectural variant.

[0015] Compared with the prior art, the beneficial effects of the present invention are: Syntactic analysis identifies key entities and operations in the requirements document; semantic analysis reveals the logical relationships and constraints between entities; and pragmatic analysis understands the implicit goals and priorities of the requirements in specific application scenarios. When generating the initial component set, core functional modules and supporting components are automatically identified based on semantic analysis results, ensuring that component division is highly consistent with the requirements objectives. Contextual environment descriptions record the component's operating environment, performance requirements, and dependencies, providing rich background information for subsequent component retrieval and verification. Based on these contextual environment descriptions, candidate component knowledge is retrieved from a distributed knowledge base, using the environment context as a retrieval condition, significantly improving the accuracy and relevance of the retrieval. A context matching algorithm filters out the candidate components that best fit the current environment from massive amounts of knowledge, avoiding the problem of traditional retrieval methods returning a large number of irrelevant results. The retrieval process considers implicit relationships between components, discovering component combinations that appear not directly related but can actually work together, expanding the possibility space for architectural design.

[0016] A dynamic inference engine is used to verify the consistency between candidate component knowledge and the initial component set, establishing an interaction model between components and simulating runtime scenarios. The inference engine analyzes whether interface protocols match, data formats are compatible, and performance metrics are consistent, identifying potential conflicts and bottlenecks. Dynamic inference can adapt to different operating conditions and load changes, verifying the collaborative capabilities of components in various scenarios. Based on the verified component graph, an architecture template matching algorithm generates candidate software architectures, combining proven architectural patterns with specific component combinations. The template matching algorithm identifies implicit architectural patterns in the component graph, such as layered structures, microservice architectures, or event-driven patterns, selecting the most suitable architectural template. Adaptive adjustments are made based on the template, retaining its advantages while meeting specific needs, improving the maturity and reliability of the architecture. Optimization strategies balance trade-offs between different quality attributes, seeking better solutions through architectural transformation operations such as component merging, splitting, and reorganizing. Attached Figure Description

[0017] Figure 1 This is a schematic diagram illustrating the working principle of the software architecture design method based on large model groups for intelligent biomimetic implementation as described in this invention. Figure 2 A flowchart for generating an initial set of components and a description of the context for multi-level semantic analysis; Figure 3 A flowchart for retrieving candidate component knowledge for a distributed knowledge base; Figure 4A comparison chart showing the efficiency of different retrieval methods in the knowledge retrieval stage; Figure 5 A comparison chart of similarity scores for different architecture patterns during the architecture template matching phase. Detailed Implementation

[0018] 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.

[0019] Please see Figure 1 This invention provides a software architecture design method based on intelligent biomimetic implementation using a large model group. The method includes: acquiring software design requirement input, which can be natural language text or structured data; performing multi-level semantic analysis on the software design requirement input, involving syntax parsing and lexical processing, extracting key elements from the input, and generating an initial component set and a context description. The initial component set contains identified software component identifiers and their attributes, while the context description covers business logic and environmental constraint information. Based on the context description, the system retrieves candidate component knowledge related to the initial component set from a distributed knowledge base. The distributed knowledge base stores extensive software architecture knowledge and patterns, and the retrieval process utilizes query vectors and parallel index scanning to efficiently obtain relevant knowledge fragments. A dynamic inference engine is used to verify the consistency between the candidate component knowledge and the initial component set. The dynamic inference engine converts knowledge into logical assertions and performs rule matching with the component relationship graph, detecting and correcting conflicts, ultimately generating a verified component graph. Based on the verified component graph, a candidate software architecture is generated using an architecture template matching algorithm. This algorithm calculates the similarity between the graph and predefined templates, selects the best template, and injects component data. Finally, an optimization strategy is adopted to iteratively adjust the candidate software architecture. The optimization strategy is based on the objective function and uses techniques such as genetic algorithms to perform mutation and crossover operations, evaluate and select the optimal architecture variant, and output the target software architecture design.

[0020] Example 1: See Figure 2In the multi-level semantic analysis stage, the software design requirements input first undergoes syntax parsing. The parser identifies the grammatical structure in the input and removes irrelevant characters, including special symbols, redundant spaces, or non-text elements, generating a normalized text stream. The syntax parsing process is based on a predefined set of grammar rules, covering common programming languages ​​and natural language patterns, ensuring that the input data is converted to a uniform format. The normalized text stream serves as an intermediate representation, eliminating format noise from the original input and providing a clean data source for subsequent lexical analysis. In practice, syntax parsing can employ recursive descent parsing or regular expression matching, scanning the input stream character by character, applying rules to identify and filter irrelevant content. The normalized text stream is stored in a memory buffer as a string or a sequence of tokens, supporting efficient access. Lexical segmentation is then performed on the normalized text stream. Lexical segmentation uses a tokenizer to split the text stream into word sequences. The tokenizer operates based on a dictionary and rule base. The dictionary contains technical terms and general vocabulary, while the rule base defines segmentation boundaries such as spaces or punctuation marks. When processing compound words and abbreviations, the tokenizer applies a maximum matching algorithm or statistical model to ensure segmentation accuracy. Word sequences serve as the basic units, entering the part-of-speech tagging (POS) stage. POS assigns a grammatical label, such as noun or verb, to each word. The tagging process employs Hidden Markov Models (HMMs) or rule-based matching to filter out nouns and verbs as key terms. Key terms represent software component entities and operational actions; for example, "user" is a noun term, and "query" is a verb term. Simultaneously, conjunction patterns in the word sequence are detected. Conjunctions include coordinating and subordinating conjunctions. Pattern detection is implemented using regular expressions or finite state machines, extracting relational conjunctions such as "and" and "or". When constructing the lexical network, key terms are used as nodes, and relational conjunctions are used as edges. The network structure is stored using a graph database or adjacency list. Node attributes include term type and location information, while edge attributes define relation strength. The lexical network captures the semantic topology of the input text, supporting component extraction. In some embodiments, the POS model can be enhanced with a pre-trained language model to improve accuracy, and conjunction detection can be extended to multi-word phrase recognition. After the lexical network is constructed, redundancy is cleaned up by merging synonym nodes or eliminating ambiguity to improve network consistency.

[0021] Software component identifiers and associated attributes are extracted based on a lexical network. The extraction process traverses network nodes, identifying terms that conform to component patterns, including class names, method names, or module identifiers. Associated attributes are inferred from the node context; for example, adjacent verbs represent operations, and attributes are stored as key-value pairs. An initial component set is constructed as a list or set data structure, containing component identifiers and attribute pairs; for example, the component "database" has the attribute "type=SQL". Simultaneously, environmental constraints and business logic descriptions are separated from the lexical network. Environmental constraints include performance requirements or platform limitations, inferred from connecting word edges and node relationships. Business logic descriptions involve process rules, extracted through subgraph matching. A contextual environment description is generated, output in a structured document format, such as a JSON object, containing constraints and logical rules. In practice, component extraction can use template filling methods, while environment separation can utilize a rule engine. The initial component set and contextual environment description are passed as semantic analysis output to the subsequent knowledge retrieval module. Optionally, the lexical network can be persistently stored for debugging or iterative analysis.

[0022] In the detailed implementation of lexical segmentation, the segmenter employs a segmentation algorithm based on a double-array Trie tree when processing the normalized text stream, supporting efficient dictionary lookup and out-of-vocabulary word recognition. After word sequence generation, the part-of-speech tagging module loads a pre-trained part-of-speech tagging model. This model, based on a conditional random field or deep learning architecture, outputs a probabilistic label for each word. When filtering key terms, noun and verb labels are retained, while auxiliary parts of speech such as adjectives and adverbs are ignored, ensuring the term set focuses on core entities. Relationship connector detection is extended to semantic role labeling, identifying the function of connectors in sentences, such as subject or object relationships. The lexical network is constructed using graph theory algorithms to calculate node centrality or community structure and optimize network representation. In practice, segmentation errors can be corrected through a backtracking mechanism, and part-of-speech tagging ambiguities are resolved through a context window. The lexical network can be serialized into a standard format for easy cross-module exchange. It is understandable that the accuracy of lexical segmentation directly affects the extraction of subsequent components, thus requiring multiple rounds of verification and adjustment.

[0023] Another approach to lexical segmentation of normalized text streams involves incremental processing. When the input stream is large, a sliding window segmentation method is used to reduce memory usage. The word segmenter integrates a domain-specific dictionary to improve the recognition rate of technical terms. Part-of-speech tagging combines rules and statistical methods to handle new domain terms. Relational connector detection incorporates syntactic dependency analysis to identify long-distance connection patterns. During lexical network construction, a weighting mechanism can be introduced to adjust edge strength based on term frequency. After the initial component set is generated, a consistency check is performed to eliminate conflicting entries. Contextual descriptions can be hierarchically represented to distinguish between hard and soft constraints. In practice, the entire multi-level semantic analysis module can be deployed as a pipeline, with checkpoints output at each stage, supporting fault tolerance and retries. Optionally, semantic analysis can integrate a user feedback loop to dynamically optimize the rule set.

[0024] Example 2: See Figure 3When retrieving candidate component knowledge based on contextual descriptions, the system generates retrieval query vectors according to key constraints in the contextual descriptions. These key constraints include performance metrics, technology stack requirements, or business rules. The retrieval query vectors are converted from textual constraints into high-dimensional numerical vectors using an embedding model trained on a neural network architecture to capture the semantic features of the constraints. After generating the retrieval query vectors, they are sent to a distributed knowledge base. The distributed knowledge base consists of multiple physical or logical nodes, which store software architecture patterns, component libraries, and best practice knowledge fragments. These knowledge fragments exist in structured formats such as knowledge graph triples or documents. Parallel index scanning is performed in the distributed knowledge base, using either an inverted index or a vector index. The inverted index maps keywords to knowledge fragment positions, while the vector index supports similarity searches. Parallel index scanning utilizes distributed computing frameworks such as MapReduce, initiating queries simultaneously on multiple knowledge base nodes to reduce retrieval latency. The scan results return preliminary matching knowledge fragments. This preliminary matching knowledge fragment set may contain a large number of entries and needs to be filtered based on component identifiers in the initial component set. The filtering process compares component identifiers with metadata fields of knowledge fragments, such as component name, version number, or type, eliminating irrelevant or low-priority entries. The filtering algorithm applies exact matching or fuzzy matching rules. After filtering, the knowledge fragments are reordered. The reordering calculates the semantic relevance score of each knowledge fragment to the initial component set. The semantic relevance score is calculated using a cosine similarity or semantic distance model, which maps knowledge fragments and the initial component set to the same vector space. The knowledge fragments are then sorted in descending order based on their semantic relevance scores, ensuring highly relevant entries are at the top of the list. Duplicate or overlapping knowledge fragments are merged. The merging process identifies identical or similar content and uses hash fingerprinting or text similarity algorithms to remove duplicates, generating a deduplicated knowledge list. This deduplicated knowledge list is output as candidate component knowledge, containing component interface specifications, dependencies, or implementation code examples, stored in a standardized format such as JSON-LD. In practical implementation, attention mechanisms and weighted importance constraints can be incorporated into the retrieval query vector generation. Nodes of the distributed knowledge base can be deployed across regions, maintaining data synchronization through consistency protocols such as Raft. Parallel index scanning can adaptively adjust the scanning granularity to balance load and accuracy. The filtering phase can incorporate Boolean queries to combine multiple component identifier conditions. The re-ranking model can be fine-tuned based on supervised learning to improve the accuracy of relevance assessment. The merging algorithm can apply clustering techniques to group similar segments. Format validation is performed before outputting candidate component knowledge to ensure data structure integrity.

[0025] In the specific process of generating retrieval query vectors, the embedding model receives text input describing the context environment. This text input is segmented and vectorized, converting it into a fixed-dimensional query vector. The embedding model can be a pre-trained model, and its output vector captures the semantic essence of the constraints. The retrieval query vector serves as the search key, performing an approximate nearest neighbor query in the vector index of the distributed knowledge base to quickly locate potentially relevant knowledge points. In some embodiments, the retrieval query vector can be normalized to reduce the impact of dimensionality bias. The distributed knowledge base maintains an incremental update mechanism for its index, periodically incorporating new knowledge fragments to keep the knowledge fresh. During parallel index scanning, the query routing strategy dynamically allocates query tasks based on node load, avoiding hotspot issues. After the initial matching of knowledge fragments is returned, a preliminary quality assessment is performed, filtering out low-confidence fragments. The filtering stage uses component identifiers as filters, aligned with the labeling system of the knowledge fragments, such as through Uniform Resource Identifier (URI) matching. The filtering algorithm can be configured with sensitivity thresholds to control the strictness of filtering. In the re-ranking stage, semantic relevance score calculation combines multi-feature fusion, including text similarity and popularity weights. The deduplication process uses a minimum hash algorithm to efficiently identify duplicate content. The candidate component knowledge list is ultimately serialized into files or database records for consumption by downstream consistency verification modules. It's understandable that the efficiency of the retrieval process depends on index quality and distributed coordination, requiring optimization of network communication and computing resources.

[0026] The implementation details of reordering the filtered knowledge fragments involve the computation of a semantic relevance model. This model represents the initial component set and knowledge fragments as feature vectors, extracted from text content or metadata. When calculating semantic relevance scores, a vector space model or deep learning model is applied to measure the distance or similarity between feature vectors. After score calculation, sorting algorithms such as quicksort or priority queues arrange the knowledge fragments in descending order, ensuring high-scoring fragments are processed first. When merging duplicate or overlapping knowledge fragments, the semantic fingerprints of the fragments are compared. These fingerprints are generated using a hash function to identify content overlap. The deduplicated knowledge list integrates fragment content, eliminating redundant information. In practice, the semantic relevance model can integrate domain-specific knowledge to enhance scoring accuracy. The sorting process can be performed in multiple rounds, gradually refining the order. The merging algorithm can retain fragment version information and handle conflicting content. The output format of candidate component knowledge can be customized, supporting various downstream applications. Optionally, a user feedback mechanism can be introduced into the reordering process to dynamically adjust model parameters.

[0027] In another implementation, query vector generation can incorporate multimodal data, such as converting charts or code snippets into vector representations. The distributed knowledge base index supports hybrid queries, combining keyword and vector searches. Parallel index scanning employs a pipelined approach, overlapping query and transmission stages. The filtering stage applies a machine learning classifier to distinguish between relevant and irrelevant snippets. The re-ranking model uses a ranking learning algorithm to optimize the list order. The merging process maintains snippet source information, supporting audit trails. In practice, the entire retrieval module can be deployed as a microservice, providing a highly available interface. Optionally, the retrieval process can cache frequently queried results to improve response speed. It is understood that the quality of candidate component knowledge directly impacts subsequent architecture generation, thus requiring a rigorous quality control loop.

[0028] The specific operations for filtering preliminarily matched knowledge fragments based on component identifiers in the initial component set include identifier parsing and matching execution. Identifier parsing normalizes component identifiers into a standard form, such as unifying capitalization or parsing aliases. During matching execution, the normalized identifiers are compared with the index fields of the knowledge fragments, and exact matching or similarity thresholds are applied to filter out non-matching fragments. The filtered fragment set enters the re-ranking stage, where semantic relevance scores are calculated based on the co-occurrence statistics or semantic embeddings of identifiers and fragments. After score calculation, a stable ranking algorithm is used to maintain the relative order between fragments. When merging duplicate fragments, text normalization techniques, such as stemming, are applied to identify semantic repetition. The deduplicated knowledge list serves as the final output, and the list structure supports random access and batch processing. In specific implementations, filtering rules can be configured as whitelists or blacklists to adapt to different scenarios. The re-ranking model can be trained offline and served online to ensure performance. The merging process can be parallelized to handle large-scale fragment sets. Candidate component knowledge can be compressed for storage to reduce storage overhead. It can be understood that the collaborative work of filtering and re-ranking ensures the accuracy and efficiency of knowledge retrieval.

[0029] See Figure 4 This figure illustrates the difference in retrieval time between traditional keyword retrieval and distributed vector retrieval in the knowledge retrieval stage of a software architecture design method based on large model groups, under different component library sizes. The horizontal axis represents the component library size, and the vertical axis represents the retrieval time. The distributed knowledge base, employing parallel index scanning and vector retrieval techniques, maintains high efficiency even when handling large-scale component libraries; traditional keyword retrieval, relying on linear matching, experiences a dramatic increase in time consumption as the scale increases. This figure visually demonstrates the technical advantages of the distributed vector retrieval method used in this invention during the knowledge retrieval stage. Through an efficient retrieval mechanism, it significantly improves retrieval efficiency while ensuring the knowledge relevance of candidate components, avoiding the performance drop issues of traditional retrieval methods in large-scale knowledge bases, and providing efficient and timely knowledge support for subsequent consistency verification and architecture generation stages.

[0030] Example 3: When using a dynamic inference engine for consistency verification, the system converts candidate component knowledge into a set of logical assertions. This conversion is based on a knowledge representation framework such as a resource description framework or first-order logic. Logical assertions express facts and rules in triples, for example, (component A, has an attribute, value X). The set of logical assertions serves as a formal representation, capturing component relationships, constraints, and behavioral specifications from the candidate component knowledge. Simultaneously, the initial component set is mapped to an entity relationship graph. This graph uses a graph structure, where nodes correspond to software component entities, and edges correspond to relationships between components, such as dependencies or calls. The entity relationship graph is constructed by parsing the attributes and associations of the initial component set. The graph structure is stored in a graph database or in-memory data structure, supporting traversal and query operations. The dynamic inference engine loads a predefined business rule base, which contains constraint rules from the software architecture design, such as component compatibility rules, performance constraint rules, or security policy rules. These business rules are encoded in the form of logical formulas or production rules. The dynamic inference engine performs rule matching on the logical assertion set and entity relationship graph. The rule matching process compares the logical assertions with rules in the business rule base, applying inference algorithms such as forward chaining or table-driven inference to detect logical assertions that violate rules. Logical assertions that violate rules are marked as anomalies, and the specific rule violated and its context are recorded. The entity relationship graph is traversed, checking whether the node attributes in the graph are consistent with the logical assertions that violate rules. Node attributes include component type, interface version, or resource configuration. The checking process compares the node attribute values ​​with the propositions in the logical assertions, marking inconsistent nodes as conflict nodes. Detected conflict nodes are corrected or replaced. Correction operations may involve adjusting component parameters, updating component versions, or selecting alternative components. Replacement operations retrieve compatible components from the knowledge base for replacement. After correction or replacement, a consistency verification result is generated, containing a list of components that passed verification, conflict resolution records, and the corrected assertion set. Based on the consistency verification result, the entity relationship graph is updated. Update operations include adding new nodes, deleting invalid edges, or modifying node attributes, generating a verified component graph. The validated component graph serves as the output for consistency verification. The graph structure ensures logical consistency and architectural integrity among components. In implementation, logical assertion transformations can use standardized serialization formats, and entity relationship graph mapping can employ attribute graph models. Rules in the business rule base can be categorized by domain, supporting modular loading. Rule matching algorithms can be optimized for incremental inference, reducing computational overhead. Conflict node correction can integrate automated decision trees or manual review interfaces. The validated component graph can be exported to a standard exchange format for subsequent architecture generation.

[0031] When performing rule matching, the dynamic inference engine employs a rule-based inference system. The system loads the logical assertion set and business rule base into its working memory and uses a pattern matching algorithm to identify assertion instances that satisfy the rule prerequisites. The rule matching process involves a unification algorithm, which binds rule patterns to assertion instances and detects matching conditions. For a matched rule instance, the inference engine triggers a rule action, which may include asserting new facts or marking conflicts. When detecting conflict nodes, the entity relationship graph is traversed using graph traversal algorithms such as breadth-first search or depth-first search, visiting each node and evaluating the consistency of its attributes with the relevant logical assertions. The consistency evaluation function can be defined as calculating the semantic distance between attribute values ​​and assertion propositions; when the distance exceeds a threshold, it is marked as inconsistent. Conflict node correction strategies can be based on priority rules, such as prioritizing the correction of high-severity conflicts. Correction operations may call external component library query services to obtain alternatives. The updated process of the verified component graph ensures the connectivity and constraint satisfaction of the graph structure. In some embodiments, the dynamic inference engine can support non-monotonic inference to handle uncertain knowledge. The business rule base can be dynamically updated to adapt to new architectural constraints. Rule matching can be executed in parallel, improving the processing efficiency of large-scale graphs. Conflict resolution can record decision logs, supporting traceability and auditing.

[0032] The specific process of using a dynamic inference engine to perform rule matching on a set of logical assertions and an entity relationship graph includes two stages: rule compilation and runtime inference. In the rule compilation stage, natural language or semi-formal rules in the business rule base are converted into executable internal code, which can be bytecode or an intermediate representation. In the runtime inference stage, the engine loads the set of logical assertions into the inference context, and the set of logical assertions, as a fact base, is matched against the compiled rules. The matching algorithm uses the Rete algorithm or the Tre algorithm to optimize pattern matching performance and establishes a partially matching state network. When all rule conditions are met, the rule is triggered and the corresponding action is executed. The action may include adding conflict markers to nodes in the entity relationship graph. When traversing the entity relationship graph, the engine visits nodes in graph topological order. For each node, it retrieves its associated logical assertions and applies consistency check rules. Consistency check rules can be encoded as Horn clauses or descriptive logical axioms, such as checking whether component types match interface requirements. After marking conflicting nodes, the engine enters the conflict resolution stage. The conflict resolution strategy may be based on rule priority or a cost model. The correction operation generates new logical assertions or graph update instructions, which are applied to the entity-relationship graph to produce an updated graph. The validated component graph undergoes a final validation loop to ensure all conflicts are resolved and rules are fully satisfied. In practice, rule compilation can be optimized to just-in-time compilation, reducing startup latency. Runtime inference can have a timeout mechanism to prevent infinite loops. Graph traversal can be indexed to accelerate node access. Conflict resolution can integrate machine learning models to predict the optimal correction scheme. The validation loop can iterate multiple times, gradually converging to a consistent state.

[0033] The formal representation of rules in the business rule base can use first-order logic formulas. For example, for component compatibility checks, the rules can be expressed as:

[0034] in: and Represents a software component instance. It is a component type predicate. Predicates indicating dependency relationships This represents a compatibility predicate. During rule matching, the engine binds instances from the logical assertion set to variables. and Check if the preconditions are met and derive the conclusion. For instances that are not met, mark them as rule violations. In the entity relationship diagram, the corresponding node... and Dependency edges are checked for compatibility attributes; if an attribute is missing or mismatched, the node is marked as a conflict node. Correction operations may involve querying the knowledge base to add compatibility declarations or replacing incompatible components. In some embodiments, the rule base can be extended to support probabilistic rules to handle partial compatibility cases. The rule engine can be configured with conflict resolution strategies, such as automatic repair or prompting user intervention. It is understood that the degree of formalization of rules directly affects the accuracy and efficiency of inference.

[0035] In other implementations of rule matching, the dynamic inference engine can employ ontology-based reasoning techniques. The business rule base is constructed as a domain ontology, and the set of logical assertions is loaded as instance data into the ontology inference engine. The inference engine uses a descriptive logic inferencer to calculate ontology consistency and classify instances. Conflict detection is achieved by checking whether instances satisfy ontology constraints, such as whether a component belongs to an allowed type hierarchy. The mapping between the entity relationship graph and the ontology is established through annotations or links, with graph nodes corresponding to ontology instances and edges corresponding to object attributes. Conflict nodes correct the suggestions based on ontology reasoning, such as automatic classification or constraint relaxation. When the validated component graph is exported, ontology annotations are retained, supporting semantic queries. In specific implementations, ontology reasoning can handle complex inheritance relationships, improving the validation depth. Graph updates can be synchronized to the ontology library to maintain knowledge consistency. Optionally, intermediate results can be cached during the reasoning process to optimize performance. It is understood that ontology-based methods enhance the semantic capabilities of validation, but the quality of the ontology model needs to be maintained.

[0036] When traversing the entity relationship graph to check node attributes, the engine visits nodes in dependency order or random order, retrieving attribute key-value pairs for each node and comparing them with relevant logical assertions. The comparison function is defined according to the attribute type; for example, numeric attributes are compared for range, and text attributes for semantic equivalence. For detected inconsistencies, the engine records the conflict type and location information. After a conflicting node is marked, the correction phase begins. The correction strategy may be based on a preset correction rule base, which contains repair templates for common conflicts. The correction operation generates new attribute values ​​or relationship adjustment instructions and applies them to the entity relationship graph. The updated graph is then re-matched with rules to ensure the effectiveness of the correction. The final output of the verified component graph is in a standardized graph format. In practical implementation, the node access order can be optimized to prioritize the critical path, reducing redundant checks. Attribute comparison can introduce fuzzy matching to handle near-consistent cases. The correction rule base can learn from historical amendments to improve automation. The graph output can be compressed to reduce storage space. It can be understood that the iterative processing of traversal and correction ensures that the graph gradually converges to a consistent state.

[0037] Example 4: When generating candidate software architectures based on the verified component graph, the system loads a predefined set of architecture templates from a template library. The template library stores common architecture patterns such as the model-view-controller pattern, microservice pattern, or layered architecture pattern. The predefined set of architecture templates describes component slots and connection rules in a structured format such as XML or YAML. Component slots define the positions where components can be inserted, and connection rules specify the interaction protocols between components. The loading of the predefined set of architecture templates is achieved through a file system interface or database query. The template library may be stored locally or accessed remotely to ensure the integrity and accessibility of the template data. The similarity score between the verified component graph and each architecture template is calculated. The similarity score is calculated using a graph matching algorithm. The graph matching algorithm compares the correspondence between the nodes and edges of the verified component graph and the slots and rules of the predefined architecture template set. The algorithm may be based on graph isomorphism detection or feature vector distance. The similarity score quantifies the degree of matching between the verified component graph and each architecture template, with a score range from 0 to 1, where 1 represents a perfect match. The architecture template with the highest similarity score is selected as the basic framework. This basic framework provides the skeleton structure of the software architecture, including component layout and communication mechanisms. The validated component graph is injected into the basic framework, filling component slots during the injection process. Component entities from the validated component graph are assigned to their corresponding slots in the basic framework, ensuring type compatibility and constraint satisfaction. After filling the component slots, candidate software architectures are generated. These candidate software architectures serve as the initial design output, including component instantiation and relationship configuration. In implementation, the template library loading can cache frequently used templates to improve loading efficiency. The graph matching algorithm can be optimized to approximate matching to handle large-scale graphs. Similarity score calculation can weight different graph features, such as node degree or path length. The selection of the basic framework can consider the fusion of multiple high-scoring templates. The injection process can verify slot constraints to prevent runtime errors. Candidate software architectures can be serialized into a standard format for easy subsequent optimization.

[0038] When calculating the similarity score between the validated component graph and each architecture template, the graph matching algorithm first converts the validated component graph and the predefined set of architecture templates into graph representations, using adjacency matrices or attribute graph models. The algorithm iterates through each template in the predefined set of architecture templates, calculating a similarity metric with the validated component graph. Similarity metrics may include node matching rate, edge overlap, or structural similarity. Node matching rate compares the consistency of labels and attributes between graph nodes and template slots; edge overlap assesses the commonality of relational paths. Structural similarity is calculated using a graph kernel function or edit distance. The similarity score is derived by combining these metrics through weighted summation or a machine learning model. See Table 1 for an example of an architecture template similarity score table.

[0039] Table 1: Architecture Template Similarity Score Table

[0040] After score calculation, the system sorts the scores and selects the template with the highest score. In practice, the graph matching algorithm can process multiple templates in parallel, reducing computation time. Similarity metrics can be calibrated to avoid bias. Efficient algorithms such as quicksort are used for score sorting. When selecting the base framework, a score threshold can be set, considering only templates above the threshold. When injecting validated component graphs, mapping components to slots is based on name matching or semantic alignment. Optionally, similarity score calculation can incorporate dynamically adjusted weights to adapt to different architectural styles. The base framework selection can support a fallback mechanism, using a default template when no high-scoring template is available.

[0041] When injecting the validated component graph into the base framework, the system parses the slot definitions of the base framework, which specify the allowed component types and interface requirements. Component entities in the validated component graph are matched against slots, comparing component attributes such as type, version, or functional description. For each matched slot, the system instantiates the component entity and configures its attributes and dependencies. The injection operation may involve transforming component representations to conform to the base framework's format. After populating the component slots, architectural consistency is verified, checking whether the connections between components meet the rules of the base framework. Candidate software architectures are generated and output as model files or code skeletons. In practice, the injection process can be phased, first populating core slots and then processing optional slots. The matching algorithm can handle many-to-one mappings, aggregating components when multiple components correspond to a single slot. Consistency verification uses rule checks to ensure no conflicts. Candidate software architectures can be appended with metadata, recording the generation source and similarity score. Optionally, the injection process can be logged in detail to support debugging and auditing. It is understandable that the architecture template matching algorithm depends on the quality of the template library and the accuracy of graph matching, therefore the template library needs to be updated and maintained regularly.

[0042] In some embodiments, the predefined set of architecture templates in the template library can be categorized by domain, such as web application templates or embedded system templates, with categorization supporting targeted matching. When calculating similarity scores, domain-specific features can be introduced to enhance score relevance. Basic framework selection can incorporate historical data, prioritizing templates from successful cases. When injecting validated component graphs, partial matching can be supported, adapting to situations where slots do not fully match. After generating candidate software architectures, preliminary simulation evaluation can be performed to predict performance metrics. In specific implementations, domain classification uses a tagging system, and template loading filters for relevant domains. Historical data is stored in a knowledge base, influencing score calculation. Partial matching uses interpolation or default values ​​to handle missing slots. Simulation evaluation uses a lightweight model for rapid feedback. Optionally, the template matching algorithm can integrate user feedback to adjust matching parameters. The candidate software architecture output format is configurable to adapt to different downstream tools.

[0043] In the detailed implementation of similarity score calculation, the graph matching algorithm specifically employs either graph edit distance or the maximum common subgraph algorithm. Graph edit distance calculation converts the verified component graph into a predefined set of architectural templates, requiring only the minimum number of operations. Operations include adding, deleting, or modifying nodes and edges. The maximum common subgraph algorithm finds the maximum shared structure between two graphs, with the size of the shared structure serving as the basis for similarity. Scores are normalized to a standard range to ensure comparability. During algorithm implementation, dynamic programming or heuristic search is used to optimize computational efficiency. For large-scale graphs, sampling or hierarchical matching is employed to reduce complexity. Similarity score results are stored in a cache for repeated use. In specific implementations, graph edit distance can be weighted according to different operation types to reflect architectural constraints. The maximum common subgraph algorithm can be extended to handle attribute graphs. Normalization methods use minimum-maximum scaling or Z-score. The caching mechanism uses an LRU strategy to manage memory usage. Optionally, score calculation can be preprocessed offline to improve real-time performance. It is understandable that algorithm selection affects matching accuracy and speed, requiring a trade-off between accuracy and resource consumption.

[0044] When populating component slots, the system traverses all slots in the basic framework. For each slot, it queries the validated component graph for matching component entities. Matching is based on semantic similarity or exact identifier comparison. For a matching component, the system maps its attributes to the slot specification, such as setting component configuration parameters or binding interfaces. When multiple components are candidates, the best match is selected based on similarity score or priority rules. After population, a complete description of the candidate software architecture is generated, including a list of components, a connection graph, and constraints. In practice, slot traversal uses depth-first or breadth-first order. Semantic similarity calculation uses a word embedding model. The mapping process automatically handles data type conversion. The best match uses voting or optimization algorithms. The candidate software architecture is exported in a standardized format. Optionally, the population process can be interactive, allowing users to confirm key slots. After generating the architecture, documentation or diagrams can be generated to enhance readability.

[0045] See Figure 5 This figure illustrates the similarity scores between different architectural patterns and the validated component graphs during the architecture template matching stage of a software architecture design method based on large model groups. The figure covers five architectural templates: "Pipeline-Filter," "Event-Driven," "Layered Architecture," "Microservices," and "MVC." A template library stores predefined architectural templates such as MVC, microservices, and layered architecture. The similarity between the validated component graph and each template is calculated using a graph matching algorithm. This chart clearly presents the matching performance of each architectural template, providing a quantitative basis for selecting the basic framework. It is a direct demonstration of how this invention efficiently selects the optimal architectural skeleton during the architecture template matching stage, ensuring the accuracy and reliability of the generated candidate software architectures.

[0046] Example 5: When iteratively adjusting candidate software architectures using optimization strategies, the system sets an optimization objective function. This objective function includes performance metrics and resource constraints. Performance metrics cover response time, throughput, or reliability measures, while resource constraints include memory usage, CPU consumption, or network bandwidth limitations. The optimization objective function is defined mathematically, such as a weighted sum or constraint satisfaction problem, and is used to evaluate the quality of architecture variants. Structural analysis is performed on the candidate software architecture to identify optimization points such as performance bottlenecks, single points of failure, or redundant components. Static analysis techniques are used to traverse the architecture model and detect structural features that do not conform to the optimization objective function. A genetic algorithm is applied to perform mutation and crossover operations on the candidate software architecture. The genetic algorithm encodes the candidate software architecture as a chromosome representation. Chromosome strings consist of gene sequences, with each gene representing an architectural element such as a component type or connection relationship. Chromosomes are randomly selected for point mutation, which modifies gene values ​​with a certain probability, such as changing the implementation technology of components or adjusting the calling protocol between modules. Two chromosomes are selected for crossover, exchanging parts of the gene sequences of the two chromosomes to generate a new chromosome. The new chromosome is decoded into a new architecture variant. The decoding process maps the gene sequences back to the software architecture model, instantiating components and connections. Each new architecture variant is evaluated against the optimization objective function. The evaluation process derives a fitness score through simulation or metric calculation, quantifying the degree to which the architecture variant satisfies the optimization objective function. The architecture variant with the highest fitness score is retained as the current optimal solution. The iterative process is repeated until a termination condition is met, including reaching the maximum number of iterations, fitness score convergence, or time budget exhaustion. The final target software architecture design is output as the optimization result, satisfying all performance metrics and resource constraints. In practice, the weights of the optimization objective function can be dynamically adjusted to reflect the importance of different metrics. Structural analysis can integrate pattern recognition algorithms to automatically detect common optimization points. Genetic algorithm parameters such as mutation rate and crossover rate can be adaptively set to balance exploration and utilization. The evaluation process can be parallelized to accelerate fitness calculation. Multiple termination conditions can be combined to ensure optimization efficiency and quality.

[0047] When applying genetic algorithms to perform mutation and crossover operations on candidate software architectures, the system first encodes the candidate software architecture as a chromosome representation. The encoding scheme maps architectural elements to discrete or continuous gene values. For example, for a simple web application architecture, a chromosome might encode the types and connection methods of front-end components, business logic components, and data storage components, while gene values ​​represent specific technology choices. Point mutation randomly selects one or more gene positions on the chromosome, modifying the gene values; for example, mutating a front-end component from React to Vue.js, or a database from MySQL to PostgreSQL. Crossover selects two parent chromosomes, randomly chooses a crossover point, and swaps the gene sequences after the crossover point to generate two offspring chromosomes. The offspring chromosomes are decoded into new architectural variants. The decoding process reconstructs the architectural model according to the encoding rules, ensuring that gene values ​​correspond to valid components and connections. In practice, the encoding scheme can be based on graph encoding or vector encoding, covering all architectural dimensions. Point mutation can use uniform mutation or Gaussian mutation to control the magnitude of change. Crossover can use single-point crossover, multi-point crossover, or uniform crossover to increase diversity. The decoder verifies the validity of gene values ​​and handles invalid mappings. After the new architectural variants are generated, they are added to the population for subsequent evaluation. Optionally, mutation and crossover operations can record history to avoid duplicate variants. It is understandable that the operational design of a genetic algorithm affects its ability to explore the search space.

[0048] When evaluating new architecture variants against the optimization objective function, the system performs a fitness evaluation for each variant. This evaluation is achieved through an architecture simulator or a static analyzer. The architecture simulator runs a workload model, measuring performance metrics such as response time and throughput. The static analyzer parses the architecture model, estimating resource usage such as memory consumption. The fitness score is calculated by combining all metrics and deriving a comprehensive score based on the formula for the optimization objective function. For example, if the optimization objective function is defined as minimizing response time while satisfying memory constraints, the fitness score can be expressed as the reciprocal of the response time multiplied by a constraint satisfaction indicator. After evaluation, the fitness score is used to compare the merits of different architecture variants, guiding the selection of operations. In practice, the simulator can be configured with typical load scenarios to ensure representativeness of the evaluation. Static analysis can use code generation or model transformation to quickly estimate resources. The fitness score calculation can be normalized to avoid the influence of units. Evaluation results are cached to avoid duplicate calculations. Optionally, uncertainty handling, such as Monte Carlo simulation, can be introduced into the evaluation process. It is understood that the accuracy of the evaluation directly determines the effectiveness of the optimization direction.

[0049] During the iterative process, the genetic algorithm maintains a population architecture variant, performing selection, mutation, and crossover operations in each generation. Selection is based on fitness scores, using roulette wheel selection or tournament selection to select superior variants for the next generation. Mutation and crossover are applied to the selected variants, generating offspring. The offspring population is merged with the parent population for environmental selection, retaining individuals with high fitness. The iterative process continues until a termination condition is met, such as when the fitness score no longer significantly improves in consecutive iterations. The final output is the target software architecture design, which is the variant with the highest fitness in the population. In practice, the population size can be dynamically adjusted to control computational costs. Selection pressure can be adjusted to prevent premature convergence. The merging strategy can employ elitism to ensure that the optimal solution is not lost. Termination condition detection uses a sliding window or statistical tests. When outputting the target software architecture design, detailed design documents and model files are generated. Optionally, the iterative process can be visualized to monitor optimization progress. It can be understood that iterative optimization balances global search and local refinement, gradually approaching the optimal architecture.

[0050] In some embodiments, the optimization objective function can be extended to multi-objective optimization, considering performance, cost, and security metrics, and using Pareto front methods to handle objective conflicts. Structural analysis can be combined with machine learning models to predict architectural properties not explicitly modeled. Genetic algorithm encoding can be enhanced to hierarchical encoding, supporting complex architectural layers. Mutation operations can incorporate domain knowledge, such as mutating only compatible component combinations. Crossover operations can be constrained by architectural constraints to avoid generating invalid variants. The evaluation process can be executed in a distributed manner, utilizing computing clusters. Termination conditions can include user interaction, allowing for human intervention. In a specific implementation, multi-objective optimization uses the NSGA-II algorithm to maintain the solution set. Machine learning models are trained using historical data to improve prediction accuracy. Hierarchical encoding decomposes the architecture into subsystems, independently encoding genes. Domain knowledge is integrated in the form of a rule base to guide mutation direction. Constraint handling checks gene compatibility during crossover. Distributed evaluation uses a task scheduler to allocate evaluation tasks. User interaction provides a graphical interface for reviewing intermediate results. Optionally, the optimization strategy can be configured for multi-round optimization, progressively refining the architectural design.

[0051] When performing structural analysis on candidate software architectures, the system parses the architecture model and constructs internal representations such as dependency graphs or call graphs. It traverses these internal representations and applies detection rules to identify optimization points, such as circular dependencies, highly coupled modules, or unused components. These detection rules are based on software engineering best practices, such as the Single Responsibility Principle or the Dependency Inversion Principle. After identifying optimization points, their type and location are recorded for use as mutation heuristics by genetic algorithms. In practice, structural analysis can use graph algorithms such as strongly connected component analysis to detect circular dependencies, and metric calculations such as fan-out analysis to analyze high coupling. Optimization point priority can be based on severity scoring to focus on key issues. Detection results are stored as annotations and associated with the architecture model. Optionally, structural analysis can be performed incrementally, analyzing only the changed parts. It can be understood that structural analysis provides targeted mutations, improving optimization efficiency.

[0052] In the example of the iterative process of the genetic algorithm, the initial population contains random variants of candidate software architectures. In each iteration, the fitness score of each variant is calculated, and variants with high scores are selected for propagation. Point mutation might change the technology stack of service A in a microservice architecture from Java to Go, and crossover operations might swap the database dependencies of services B and C. After evaluation, the low-scoring variants are replaced. After several generations of iteration, the population converges to an optimized architecture where all services meet performance goals and resource usage is balanced. The output target software architecture design includes complete component specifications and deployment diagrams. In practical implementation, example parameters such as population size and number of iterations can be preset based on architectural complexity. Mutation and crossover operations are logged to support tracing the optimization path. The final output can verify constraint satisfaction and ensure feasibility. Optionally, the example can be extended to handle dynamic loads and optimize a resilient architecture.

[0053] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the appended claims and their equivalents.

Claims

1. A software architecture design method for intelligent biomimetic implementation based on large model groups, characterized in that, The method includes: Obtain software design requirements input; Perform multi-level semantic analysis on the software design requirements input to generate an initial component set and context description; Based on the aforementioned context description, candidate component knowledge related to the initial component set is retrieved from the distributed knowledge base; The dynamic reasoning engine is used to perform consistency verification between the candidate component knowledge and the initial component set, and a verified component graph is generated. Based on the verified component graph, candidate software architectures are generated using an architecture template matching algorithm. The candidate software architecture is iteratively adjusted using an optimization strategy to output the target software architecture design.

2. The software architecture design method for intelligent biomimetic implementation based on large model groups according to claim 1, characterized in that, Multi-level semantic analysis is performed on the software design requirements input to generate an initial component set and context description, including: The software design requirements input is parsed to remove irrelevant characters and generate a standardized text stream. Lexical segmentation is performed on the normalized text stream to identify key terms and relational connectives, forming a lexical network; Based on the vocabulary network, software component identifiers and associated attributes are extracted to construct an initial component set; Simultaneously, environmental constraints and business logic descriptions are separated from the vocabulary network to generate a contextual environment description.

3. The software architecture design method for intelligent biomimetic implementation based on large model groups according to claim 2, characterized in that, Based on the aforementioned context description, candidate component knowledge related to the initial component set is retrieved from the distributed knowledge base, including: Based on the key constraints in the context description, a retrieval query vector is generated; The retrieval query vector is sent to a distributed knowledge base to perform a parallel index scan and obtain preliminary matching knowledge fragments. Based on the component identifiers in the initial component set, the preliminary matching knowledge fragments are filtered to remove irrelevant entries; The filtered knowledge fragments are reordered to generate candidate component knowledge.

4. The software architecture design method for intelligent biomimetic implementation based on large model groups according to claim 3, characterized in that, The dynamic inference engine is used to perform consistency verification between the candidate component knowledge and the initial component set, generating a verified component graph, including: The candidate component knowledge is converted into a set of logical assertions; Map the initial set of components to an entity relationship graph; The dynamic reasoning engine is used to perform rule matching on the set of logical assertions and the entity relationship graph to detect conflicting nodes. Correct or replace the detected conflicting nodes to generate consistency verification results; Based on the consistency verification results, the entity relationship graph is updated to generate the verified component graph.

5. The software architecture design method for intelligent biomimetic implementation based on large model groups according to claim 4, characterized in that, Based on the verified component graph, candidate software architectures are generated using an architecture template matching algorithm, including: Load a collection of predefined architecture templates from the template library; Calculate the similarity score between the verified component graph and each architecture template; Choose the architecture template with the highest similarity score as the basic framework; The verified component graph is injected into the basic framework to fill the component slots and generate a candidate software architecture.

6. The software architecture design method for intelligent biomimetic implementation based on large model groups according to claim 5, characterized in that, The candidate software architecture is iteratively adjusted using an optimization strategy to output the target software architecture design, including: Define the optimization objective function, including performance metrics and resource constraints; Structural analysis was performed on the candidate software architectures to identify optimization points; The candidate software architectures are mutated and crossovered using a genetic algorithm to generate new architecture variants. Evaluate each new architecture variant against the stated optimization objective function, preserving the optimal solution; Repeat the iterative process until the termination condition is met, and output the target software architecture design.

7. The software architecture design method for intelligent biomimetic implementation based on large model groups according to claim 2, characterized in that, Lexical segmentation is performed on the normalized text stream to identify key terms and relational connectives, forming a lexical network, including: The normalized text stream is split into word sequences using a tokenizer; Each word is tagged with its part of speech, and nouns and verbs are filtered out as key terms; Detect conjunction patterns in word sequences and extract relational conjunctions; Construct a vocabulary network with key terms as nodes and relational words as edges.

8. The software architecture design method for intelligent biomimetic implementation based on large model groups according to claim 3, characterized in that, The filtered knowledge fragments are reordered to generate candidate component knowledge, including: Calculate the semantic relevance score of each knowledge fragment to the initial set of components; The knowledge fragments are sorted in descending order based on their semantic relevance scores. Merge duplicate or overlapping knowledge segments to generate a deduplicated knowledge list; The deduplicated knowledge list is used as candidate component knowledge.

9. The software architecture design method for intelligent biomimetic implementation based on large model groups according to claim 4, characterized in that, The dynamic inference engine is used to perform rule matching on the set of logical assertions and the entity relationship graph to detect conflict nodes, including: Load the predefined business rule library; The logical assertion set is matched with the business rule base to identify assertions that violate the rules; Traverse the entity relationship graph and check whether the node attributes are consistent with the assertions that violate the rules; Nodes with inconsistent labels are called conflicting nodes.

10. The software architecture design method for intelligent biomimetic implementation based on large model groups according to claim 6, characterized in that, Genetic algorithms are applied to the candidate software architectures to perform mutation and crossover operations, generating new architectural variants, including: The candidate software architecture is encoded as a chromosome representation; Randomly select chromosomes for point mutation to modify component types or connectivity relationships; Two chromosomes are selected for crossover, exchanging some gene sequences. The resulting new chromosome is decoded as a new architectural variant.

Citation Information

Cited By

  • Big data direct-drive application generation and adaptation method of semantic reasoning engine

    CN122021655A

  • An airport digital twin semantic enhancement method driven by connotation logic generation

    CN122388126A

  • An airport digital twin semantic enhancement method driven by connotation logic generation

    CN122388126B