A method and system for decoupling cross-disciplinary technology capabilities and meta-capability unit intelligent scheduling

Abstract

A method and system for interdisciplinary skill decoupling and intelligent scheduling of meta-capability units, relating to the field of electronic digital data processing, is disclosed. This method obtains entity and action information by semantically parsing user input text, deconstructs requirements into a set of meta-functional units using a meta-functional unit rule base, and constructs a dependency graph. A vector embedding model is used to encode the features of the meta-functional units, and matching nodes are found in a heterogeneous domain logical graph based on cosine similarity and graph topology paths to generate cross-domain logical mappings. Execution resources and virtual agents are allocated to the meta-functional units according to the dependency graph and mapping relationships, and finally, a multimodal generation model is invoked to generate interactive content. This application aims to improve the accuracy of resource recommendation and matching when facing innovative cross-domain tasks.

Description

Technical Field

[0001] This application belongs to the field of electronic digital data processing, and in particular relates to a cross-disciplinary skill decoupling and intelligent scheduling method and system for meta-capability units. Background Technology

[0002] With the deep integration of interdisciplinary engineering technologies, the processing of target tasks is increasingly exhibiting high complexity and comprehensiveness. A typical complex engineering task often requires the coordinated use of multiple technical elements, including mathematical modeling, algorithmic logic, hardware control, and system design, to complete. However, traditional task decomposition and resource organization methods mainly rely on the manual experience of technical personnel to break down task requirements. Operators need to spend a lot of time analyzing task specifications, manually identifying the required cross-domain technical nodes, and filtering and matching corresponding execution scripts and data materials from massive databases. This approach is not only inefficient but also depends on the breadth of prior knowledge of the operators, making it difficult to accurately and dynamically decouple complex task requirements into specific, executable, standardized functional modules under each technical domain, thus reducing the efficiency of responding to large-scale, personalized tasks.

[0003] In related technologies, a resource recommendation method driven by an expert rule base is commonly used. This method constructs a large mapping database by pre-defining association rules between various typical task topics and underlying technical components. When a specific task instruction is received, the system traverses the rule base, automatically retrieves and recommends relevant combinations of execution resources based on the pre-defined mapping relationships. This approach can automate resource matching to a certain extent when handling standardized, existing routine tasks, reducing the burden of manual configuration and improving the accuracy of data resource retrieval under established rules.

[0004] However, when faced with a novel task requirement not included in the rule base (e.g., "optimizing distributed network paths using biological group behavior logic"), the aforementioned technologies attempt to find direct association rules between "biological characteristics" and "network engineering" in the rule base during implementation. Since expert rule bases are built based on historical data, it's difficult to exhaustively cover all emerging cross-domain intersections. When lacking directly corresponding pre-defined rules, the system tends to rely on surface-level semantic tags for retrieval, making it difficult to identify the isomorphism of underlying logic across different domains. This reduces the accuracy of resource recommendation and matching when facing innovative cross-domain tasks. Summary of the Invention

[0005] This application provides a method and system for interdisciplinary skill decoupling and intelligent scheduling of meta-capability units, which can improve the accuracy of resource recommendation and matching when facing innovative cross-domain tasks.

[0006] Firstly, this application provides a method for interdisciplinary skill decoupling and intelligent scheduling of meta-capability units. It performs semantic parsing on user-input task requirement text to obtain a set of key entities and a set of actions, and generates structured requirement description data based on these sets. The structured requirement description data is then input into a pre-set meta-functional unit rule base, which deconstructs the structured requirement description data into a set of meta-functional units through pattern matching. A meta-functional unit dependency graph is constructed based on the data input-output dependencies between the meta-functional units in the meta-functional unit set. Each meta-functional unit in the meta-functional unit set is encoded using a pre-trained vector embedding model, generating a meta-functional unit feature vector corresponding to each meta-functional unit. In the pre-built... In the heterogeneous domain logic graph, reference logical nodes with a cosine similarity greater than a preset threshold to the feature vector of the meta-functional unit are retrieved to obtain a set of candidate reference nodes. The graph topology shortest path between the meta-functional unit and each reference logical node in the candidate reference node set is calculated in the heterogeneous domain logic graph. Based on the cosine similarity and the graph topology shortest path, a homogeneity score is calculated, and a cross-domain logic mapping table is generated according to the homogeneity score. Based on the meta-functional unit dependency graph and the cross-domain logic mapping table, corresponding execution resources and virtual execution agents are matched for each meta-functional unit in the meta-functional unit set to generate a resource scheduling plan containing resource configuration information and agent allocation information. According to the resource scheduling plan, a multimodal generation model is called to generate multimodal interaction content data corresponding to the meta-functional unit set.

[0007] By employing the aforementioned technical solution, semantic parsing of user-input task requirement text is performed and transformed into structured data. Combined with pattern matching using a pre-defined meta-functional unit rule base, complex tasks can be decomposed into basic meta-functional units. Pre-trained vector models are used to encode the features of these meta-functional units. Similar nodes are retrieved in the heterogeneous domain logical graph, and graph topological distances are calculated, establishing a mapping relationship between meta-functional units and heterogeneous domains. Based on the dependency graph and mapping relationships, execution resources and agents are allocated to the meta-functional units, generating multimodal interactive content. This method improves the accuracy of cross-disciplinary knowledge transfer, enhances the granular control of task decomposition, and improves the targeting of resource scheduling. Due to the adoption of a similarity- and graph distance-based mapping mechanism, the error rate of cross-domain knowledge mapping is reduced, the rationality of execution resource allocation is improved, and the system can better adapt to differences in knowledge structures between different domains, thus improving the accuracy of resource recommendation and matching when facing innovative cross-domain tasks.

[0008] In conjunction with some implementation methods of the first aspect, in some implementation methods, the isomorphism score is calculated based on cosine similarity and the shortest path in the graph topology. Specifically, this includes: extracting the input parameter type set and output parameter type set of the meta-functional unit, and defining the combination of the input parameter type set and output parameter type set as the data constraint attribute of the meta-functional unit; traversing the candidate reference node set, and selecting nodes whose input / output attributes are consistent with the data constraint attributes as valid reference sets; determining the task starting node of the meta-functional unit dependency graph, and the domain root node of the heterogeneous domain logic graph; calculating the first shortest path length from the meta-functional unit to the task starting node, and the second shortest path length from each node in the valid reference set to the domain root node; generating a position deviation coefficient based on the absolute value of the difference between the first shortest path length and the second shortest path length; and using the position deviation coefficient to correct the cosine similarity to obtain the isomorphism score.

[0009] By adopting the above technical solution, when calculating the isomorphism score, the input and output parameter types of the meta-functional unit are extracted as data constraint attributes, and reference nodes with consistent data constraints are selected, thereby improving the data compatibility of functional mapping. A positional deviation coefficient is generated to correct the cosine similarity by calculating the difference between the path length from the meta-functional unit to the task starting node and the path length from the reference node to the domain root node, ensuring that the isomorphism score comprehensively considers both the functional and structural similarities of nodes. This improved scoring mechanism enhances the accuracy of cross-domain mapping and reduces the probability of mismatches that may result from relying solely on semantic similarity. Because structural positional information is introduced into the similarity calculation, the context-awareness of knowledge mapping is improved, enabling the system to better maintain the integrity of the original knowledge structure when performing cross-domain functional matching.

[0010] In conjunction with some implementation methods of the first aspect, in some implementation methods, based on the meta-functional unit dependency graph and cross-domain logical mapping table, each meta-functional unit in the meta-functional unit set is matched with corresponding execution resources and virtual execution agents to generate a resource scheduling plan containing resource configuration information and agent allocation information. Specifically, this includes: parsing the topology of the meta-functional unit dependency graph and generating a topology execution sequence of the meta-functional unit set based on the topology; traversing the topology execution sequence, determining the target logical node corresponding to each meta-functional unit according to the cross-domain logical mapping table, and extracting the resource feature tags of the target logical nodes; determining target virtual execution agents that match the resource feature tags in a pre-set virtual execution agent pool, and establishing a mapping binding relationship between the meta-functional unit and the target virtual execution agent; quantifying the computing power and storage space required by the target virtual execution agent according to the resource feature tags; generating resource configuration information based on the computing power and storage space; encapsulating the mapping binding relationship into agent allocation information and aggregating it with the resource configuration information to obtain the resource scheduling plan.

[0011] By employing the above technical solution, an execution sequence is generated by parsing the topology of the dependency graph of the meta-functional units. Based on cross-domain logical mapping, resource feature labels of target nodes are determined, and precise mapping and binding relationships are established in the virtual execution agent pool. The system quantifies the required computing power and storage space according to the resource feature labels, generating detailed resource configuration information and agent allocation information. This scheduling method based on topology sequences and resource features improves the accuracy of resource allocation and enhances the parallel efficiency of task execution. By precisely quantifying resource requirements, the possibility of resource waste is reduced, the stability of system operation is enhanced, and meta-functional units can obtain a more suitable execution environment and computing resource support.

[0012] In conjunction with some implementations of the first aspect, in some implementations, after generating multimodal interaction content data corresponding to the set of meta-functional units by calling a multimodal generation model according to a resource scheduling plan, the method further includes: parsing the multimodal interaction content data to extract the actual execution results of the contained actions and information; calculating a task fidelity score based on the actual execution results and structured requirement description data; determining a target meta-functional unit that causes the task fidelity score to be lower than a preset fidelity threshold when the task fidelity score is determined to be lower than the preset fidelity threshold; reducing the isomorphism score of the reference logical node currently associated with the target meta-functional unit by a preset ratio in the cross-domain logical mapping table to obtain an updated cross-domain logical mapping table; determining a target reference logical node for the target meta-functional unit based on the updated cross-domain logical mapping table, wherein the target reference logical node is the reference logical node with the highest isomorphism score that has not been selected before; generating a modified resource scheduling plan based on the target reference logical node; and generating modified multimodal interaction content data corresponding to the set of meta-functional units by calling a multimodal generation model according to the modified resource scheduling plan.

[0013] By employing the above technical solution, the system extracts actual execution results by parsing multimodal interaction content data, calculates task fidelity scores, and identifies target functional units causing low fidelity. The system dynamically adjusts the isomorphism scores in the cross-domain logical mapping table and selects new reference logical nodes to generate a revised resource scheduling plan. This adaptive adjustment mechanism based on execution feedback improves the accuracy of task execution and enhances the system's responsiveness to execution deviations. By establishing a closed loop of task fidelity evaluation and dynamic correction, the system's self-optimization capability is improved, enabling timely correction of errors during execution.

[0014] In conjunction with some implementation methods of the first aspect, in some implementation methods, a task fidelity score is calculated based on the actual execution results and structured requirement description data. Specifically, this includes: extracting expected function points from the structured requirement description data according to preset parsing rules; each expected function point contains a function identifier and expected parameters, and all expected function points constitute an expected function point set; extracting actual function points corresponding to each actually executed action from the actual execution results according to preset parsing rules; each actual function point contains a function identifier and actual parameters, and all actual function points constitute an actual function point set; comparing the actual function point set with the expected function point set to determine the hit function points corresponding to the function identifiers, the missing function points that exist in the expected function point set but not in the actual function point set, and the redundant function points that exist in the actual function point set but not in the expected function point set; and calculating the task fidelity score based on a preset scoring function and the number of hit function points, missing function points, and redundant function points.

[0015] By adopting the above technical solution, the system establishes a benchmark for functional execution by extracting expected functional points from structured requirement description data and actual functional points from actual execution results. By comparing the set of actual functional points with the set of expected functional points, the system identifies hit functional points, missing functional points, and redundant functional points, and calculates a task fidelity score based on a preset scoring function. This fine-grained functional point analysis method improves the accuracy of task execution quality assessment. By decomposing the functional execution results into specific functional points for comparison, the system's ability to identify task execution deviations is improved, enhancing the objectivity of task fidelity assessment. This functional point-based assessment mechanism enhances the system's measurement accuracy of task execution quality by quantitatively analyzing the distribution of different types of functional points.

[0016] In conjunction with some implementations of the first aspect, in some implementations, in the cross-domain logical mapping table, the isomorphism score of the reference logical nodes currently associated with the target functional unit is reduced by a preset ratio to obtain an updated cross-domain logical mapping table. Specifically, this includes: performing attribution analysis on the deviation between the actual execution result of the target functional unit and the structured requirement description data to determine a failure attribution identifier, which is a preset classification code; updating the global attribution knowledge base based on the failure attribution identifier and the reference logical nodes currently associated with the target functional unit; determining other reference logical nodes from the global attribution knowledge base that, besides the currently associated reference logical nodes, have an association strength with the failure attribution identifier higher than a preset association threshold to obtain a high-risk node set; reducing the isomorphism score of the reference logical nodes currently associated with the target functional unit in the cross-domain logical mapping table by a first preset ratio; and reducing the isomorphism score of each reference logical node in the high-risk node set in the cross-domain logical mapping table by a second preset ratio to obtain an updated cross-domain logical mapping table. The preset ratio includes the first preset ratio and the second preset ratio.

[0017] By adopting the above technical solution, and through attribution analysis of the deviation between the execution results of the target functional unit and the requirement description data, failure attribution identifiers are determined and the global attribution knowledge base is updated, thus establishing a mechanism for tracing the causes of execution failures. Based on the failure attribution identifiers, a set of high-risk nodes is identified, and the isomorphism scores of currently associated nodes and high-risk nodes are differentially reduced. This dynamic scoring adjustment mechanism improves the system's ability to avoid repeating errors. Because the correlation and transitivity of failure causes are considered when updating the mapping relationship, the probability of the system repeatedly selecting nodes with similar failure tendencies in subsequent tasks is reduced. This attribution analysis-based scoring adjustment method enhances the system's error prevention capabilities, improves the reliability of cross-domain mapping, and enables the system to better avoid potential risks when selecting nodes.

[0018] In conjunction with some implementation methods of the first aspect, in some implementation methods, attribution analysis is performed on the deviation between the actual execution result of the target functional unit and the structured requirement description data to determine the failure attribution identifier. Specifically, this includes: determining the deviation features that constitute the deviation based on the actual execution result and the structured requirement description data. The deviation features include missing function points, redundant function points, and parameter deviation function points determined based on the hit function points; taking the missing function points, redundant function points, and parameter deviation function points as a combination of deviation features, and determining the failure attribution identifier corresponding to the combination of deviation features in a preset attribution rule base.

[0019] By adopting the above technical solution, and determining deviation characteristics based on actual execution results and structured requirement description data, missing function points, redundant function points, and parameter deviation function points are combined as deviation features. These features are then matched with corresponding failure attribution identifiers in a pre-defined attribution rule base, enabling the system to accurately classify execution deviations. This multi-dimensional deviation feature analysis method improves the accuracy of failure cause identification and enhances the system's ability to distinguish between different types of execution deviations.

[0020] Secondly, embodiments of this application provide an interdisciplinary skill decoupling and meta-capability unit intelligent scheduling system, which includes: one or more processors and a memory; the memory is coupled to one or more processors, the memory is used to store computer program code, the computer program code includes computer instructions, and one or more processors call the computer instructions to cause the system to perform the method described in the first aspect and any possible implementation of the first aspect.

[0021] Thirdly, embodiments of this application provide a computer-readable storage medium including instructions that, when executed on a system, cause the system to perform the method described in the first aspect and any possible implementation thereof.

[0022] Fourthly, embodiments of this application provide a computer program product that, when run on a system, causes the system to execute the method described in any possible implementation of the first aspect.

[0023] One or more technical solutions provided in the embodiments of this application have at least the following technical effects or advantages:

[0024] 1. This application provides a method for interdisciplinary skill decoupling and intelligent scheduling of meta-capability units. By semantically parsing the user-input task requirement text and converting it into structured data, and combining this with pattern matching using a pre-set meta-functional unit rule base, complex tasks can be decomposed into basic meta-functional units. A pre-trained vector model is used to encode the features of these meta-functional units. Similar nodes are retrieved in the heterogeneous domain logical graph, and graph topological distances are calculated to establish a mapping relationship between meta-functional units and heterogeneous domains. Based on the dependency graph and mapping relationship, execution resources and agents are allocated to the meta-functional units, generating multimodal interactive content. This method improves the accuracy of interdisciplinary knowledge transfer, enhances the granular control of task decomposition, and improves the targeting of resource scheduling. Because it adopts a mapping mechanism based on similarity and graph distance, it reduces the error rate of cross-domain knowledge mapping, improves the rationality of execution resource allocation, enables the system to better adapt to differences in knowledge structures between different domains, and improves the accuracy of resource recommendation and matching when facing innovative cross-domain tasks.

[0025] 2. This application provides a method for interdisciplinary skill decoupling and intelligent scheduling of meta-capability units. It extracts actual execution results by parsing multimodal interaction content data, calculates task fidelity scores, and identifies target meta-functional units causing low fidelity. The system dynamically adjusts the isomorphism scores in the cross-domain logical mapping table and selects new reference logical nodes to generate a revised resource scheduling plan. This adaptive adjustment mechanism based on execution feedback improves the accuracy of task execution and enhances the system's responsiveness to execution deviations. By establishing a closed loop of task fidelity evaluation and dynamic correction, the system's self-optimization capability is improved, enabling timely correction of errors during execution. Attached Figure Description

[0026] Figure 1 This is a flowchart illustrating a cross-disciplinary skill decoupling and meta-capability unit intelligent scheduling method in an embodiment of this application.

[0027] Figure 2 This is another flowchart illustrating a cross-disciplinary skill decoupling and meta-capability unit intelligent scheduling method in the embodiments of this application.

[0028] Figure 3 This is a schematic diagram of the physical device structure of an intelligent scheduling system for interdisciplinary skill decoupling and meta-capability units provided in an embodiment of this application. Detailed Implementation

[0029] The terminology used in the following embodiments of this application is for the purpose of describing particular embodiments only and is not intended to be limiting of this application. As used in the specification and appended claims of this application, the singular expressions “a,” “an,” “the,” “the,” “the,” and “this” are intended to include the plural expressions as well, unless the context clearly indicates otherwise. It should also be understood that the term “and / or” as used in this application refers to any or all possible combinations including one or more of the listed items.

[0030] Hereinafter, the terms "first" and "second" are used for descriptive purposes only and should not be construed as implying or suggesting relative importance or implicitly indicating the number of indicated technical features. Thus, a feature defined as "first" or "second" may explicitly or implicitly include one or more of that feature, and in the description of the embodiments of this application, unless otherwise stated, "multiple" means two or more.

[0031] The following example is used in conjunction with Figure 1 This application describes a method for interdisciplinary skill decoupling and intelligent scheduling of meta-capability units in its embodiments:

[0032] Please see Figure 1This is a flowchart illustrating a cross-disciplinary skill decoupling and meta-capability unit intelligent scheduling method in an embodiment of this application.

[0033] S101. Perform semantic parsing on the task requirement text input by the user to obtain a set of key entities and a set of actions, and generate structured requirement description data based on the set of key entities and the set of actions.

[0034] Task requirement text refers to the raw text input by the user in natural language, describing their intentions or needs. Its form is not limited and can be phrases, sentences, or paragraphs. Semantic parsing is a natural language processing technique aimed at analyzing the deeper meaning of text, not just its grammatical structure, with the goal of extracting the core information elements and their relationships within the text. The key entity set refers to a set of noun phrases identified from the task requirement text that act as recipients, participants, or modifiers of actions, such as names of people, places, objects, and concepts. The action set refers to a set of verbs or verbal phrases identified from the text that represent specific operations, behaviors, or states. Structured requirement description data is a machine-readable data format that organizes the scattered key entities and actions obtained from semantic parsing into a structure with clear logical relationships. Its specific form is not limited and can include JSON, XML, key-value pairs, or graph structures. The overall process of this step can be described as follows: After the system receives the natural language instructions input by the user, it starts the semantic parsing engine. This engine acts like a professional analyst, carefully reading and understanding the text content, accurately identifying the core "what to do" (action) and "to whom / with what" (key entities) of the task. Then, it organizes this scattered information into a standardized "task specification" that the computer can directly process, i.e., structured requirement description data.

[0035] The specific methods and technologies for implementing this step can be implemented in two ways. The first method is a hybrid approach based on rules and dictionaries. First, a domain-related entity dictionary and action dictionary are constructed. The entity dictionary contains common entity names and their synonyms in the domain, while the action dictionary contains core imperative verbs. After receiving the task requirement text, the system first performs word segmentation and part-of-speech tagging. Then, through string matching or regular expression matching, the word segmentation results are matched with the entries in the dictionary to identify candidate entities and actions. To resolve ambiguity, the system uses preset grammatical rules (e.g., verbs are usually followed by noun objects) to filter and confirm the candidate results, ultimately forming a set of key entities and a set of actions. Finally, the extracted sets are filled into a predefined template (e.g., "{action: [action 1], entity: [entity 1, entity 2]}") to generate structured requirement description data in JSON format. The second method is a sequence labeling method based on a pre-trained language model. A sequence labeling model is built using language models (such as BERT and ERNIE) pre-trained on massive amounts of text, specifically for Named Entity Recognition (NER) and intent / action recognition. The model is fine-tuned on a domain corpus with labeled entities and actions to learn to recognize key information in specific tasks. When a new task requirement text is input, the model labels each token in the text, assigning it a predefined label (e.g., B-ENT for the start of an entity, I-ACT for the middle of an action). Based on these label sequences, the system decodes the complete key entities and actions, forming corresponding sets. Finally, these sets can be used to generate structured requirement description data according to a pre-defined data structure, such as a dictionary with actions as primary keys and entities as values.

[0036] S102. Input the structured requirement description data into the preset meta-functional unit rule base, so that the preset meta-functional unit rule base can deconstruct the structured requirement description data into a set of meta-functional units through pattern matching.

[0037] The structured requirement description data refers to the machine-readable task description generated in the previous step S101. The preset meta-functional unit rule base is a knowledge base storing a series of mapping rules, where each rule defines a mapping relationship from one or more structured requirement description patterns to one or more meta-functional units. Pattern matching is a process of checking whether input data conforms to a certain predefined structure or pattern. In this step, it refers to comparing the structured requirement description data with the rule patterns in the rule base. A meta-functional unit is the smallest, indivisible atomic execution unit of a task; it represents a basic functional operation, such as "generate a sphere," "set the material to metal," or "query weather information." The meta-functional unit set is a combination of meta-functional units obtained after deconstruction. The overall process of this step can be described as follows: After receiving the standardized "task specification" (structured requirement description data), the system will consult a "task decomposition manual" (preset meta-functional unit rule base). By finding entries in this manual that match the task specifications (pattern matching), the system can break down a macro-level, complex task instruction into a series of specific, basic, and standardized operational steps (meta-functional units), and compile these steps into a list (meta-functional unit set) to prepare for subsequent execution.

[0038] The specific methods and technologies for implementing this step can be as follows: The first method is a forward inference engine based on the Rete algorithm. Each rule in the metafunctional unit rule base is converted into an "IF-THEN" form, where the IF part is the pattern, corresponding to the specific structure and content of the structured requirement description data; the THEN part is the action, i.e., generating one or more metafunctional units. The system inputs the structured requirement description data generated by S101 as the initial "facts" into the inference engine. The Rete algorithm constructs an efficient matching network. When a fact satisfies the IF condition of a rule, the rule is activated, and its THEN part action is executed, i.e., the corresponding metafunctional unit is added to the result set. This process can continue, and newly generated metafunctional units themselves can also serve as new facts, triggering other rules until no more rules can be activated. This method is very suitable for handling complex scenarios with a large number of rules and inter-dependencies. The second method is based on hierarchical template matching. In this method, the rule base is organized into a tree-like or graph-like hierarchical structure. High-level templates correspond to complex tasks, and low-level templates correspond to basic tasks. For example, a high-level template for "drawing a landscape painting" might contain entities such as "sky," "ground," and "trees." When the input structured data matches this high-level template, the system not only generates meta-functional units related to "drawing a landscape painting," but also recursively matches the next-level sub-templates such as "drawing the sky" and "drawing trees" based on the specific entities present in the data, thus achieving a coarse-to-fine hierarchical decomposition.

[0039] S103. Construct a metafunctional unit dependency graph based on the data input-output dependencies between metafunctional units in the metafunctional unit set;

[0040] The set of meta-functional units is a list of atomic operations obtained from the decomposition of step S102. Data input-output dependencies refer to the fact that the execution of one meta-functional unit requires the output data produced by one or more other meta-functional units as its input data; this sequential order and data flow relationship is the dependency relationship. For example, the "render an image" meta-functional unit requires the output (model data) of the "create a 3D model" meta-functional unit as input. The meta-functional unit dependency graph is a directed acyclic graph (DAG), where the nodes represent the individual meta-functional units in the set, and the directed edges represent the data input-output dependencies between them. If there exists an edge from meta-functional unit A to meta-functional unit B, it means that the execution of A must be completed before B, and the output of A is one of the inputs of B. The overall process of this step can be described as follows: After obtaining a series of basic operation steps (the set of meta-functional units), the system needs to clarify the sequential execution order of these steps. The system checks what "raw materials" (inputs) each step requires and what "finished products" (outputs) it can produce. If the raw material of step B happens to be the finished product of step A, then it is determined that A must be completed before B. By analyzing all the steps in this way, the system finally draws a clear "process flow diagram" (meta-functional unit dependency diagram), which clarifies the execution process and data flow of the entire task.

[0041] The specific methods and techniques for implementing this step can be as follows: The first method is based on explicit input / output parameter annotation. When defining each metafunctional unit, its input and output parameter lists are explicitly and structurally annotated, including parameter names, data types, and semantic descriptions. For example, the output of the metafunctional unit `create_sphere` is annotated as `{name: 'geometry_data', type: '3DModel'}`, while the input of the metafunctional unit `apply_material` is annotated as `{name: 'target_geometry', type: '3DModel'}`. After the system obtains the set of metafunctional units, it iterates through each pair of metafunctional units (A, B). The system checks the output parameter list of A and the input parameter list of B. If it finds that an output parameter of A completely matches an input parameter of B in name and type, or can match through a predefined alias mapping table, it creates a directed edge from A to B in the dependency graph. After traversing all possible unit pairs, the complete dependency graph is constructed. The second method is based on parameter semantic similarity matching. This approach does not require the input and output parameter names to be exactly the same. The system first uses pre-trained word or sentence vector models (such as Word2Vec or Sentence-BERT) to convert the semantic descriptions of the input and output parameters of each metafunctional unit (e.g., "a 3D geometric model data" or "color values ​​used for coloring") into high-dimensional vectors. Then, the system iterates through all unit pairs (A, B) and calculates the cosine similarity between each output parameter vector of A and each input parameter vector of B. If the similarity of a pair of input and output parameters exceeds a preset threshold (e.g., 0.9), and their data types are compatible, the system considers them to have a dependency and creates an edge from A to B.

[0042] S104. Encode each metafunctional unit in the metafunctional unit set using a pre-trained vector embedding model to generate a metafunctional unit feature vector that corresponds one-to-one with each metafunctional unit.

[0043] A pre-trained vector embedding model is a deep learning model pre-trained on massive amounts of data. It maps text, symbols, or other discrete data into a continuous, dense vector space, ensuring that semantically similar inputs are located close together in this space. Without limitation, this model can be a Transformer-based model such as BERT, GPT, or T5, or a word vector model such as Word2Vec or GloVe. A metafunctional unit is an atomic execution unit. Encoding, in this context, refers to transforming non-numerical, symbolic metafunctional unit information into a numerical vector through a vector embedding model. A metafunctional unit feature vector is a high-dimensional mathematical vector obtained after encoding, representing the core semantics and functional characteristics of the metafunctional unit. This vector captures the essence of the metafunctional unit, such as its actions, objects of operation, parameters, and other comprehensive semantic information. The overall process of this step can be described as follows: In order for the computer to "understand" and "compare" different metafunctional units, the system needs to translate each metafunctional unit representing a specific operation into a general, mathematical language. The system uses a powerful "translator" (a pre-trained vector embedding model) to input descriptive information about each metafunctional unit (such as its name, functional description, parameters, etc.) and output a unique "digital fingerprint" (metafunctional unit feature vector). This digital fingerprint not only uniquely identifies the unit, but more importantly, units with similar functions will have mathematically very similar digital fingerprints.

[0044] The specific methods and techniques for implementing this step can be as follows: The first method is encoding based on the metafunctional unit's descriptive text. First, a detailed, standardized descriptive text is created for each metafunctional unit. This text can be concatenated with information such as the metafunctional unit's name, functional annotations, and the names and types of input and output parameters to form a complete sentence or paragraph. For example, for the metafunctional unit "set color," its descriptive text could be "Function: Set color. Input: Target object, color value. Output: Colored object." Then, this descriptive text is input into a pre-trained sentence embedding model (such as Sentence-BERT). The model processes the entire text and outputs a fixed-dimensional vector (e.g., 768-dimensional), which is the feature vector of the metafunctional unit. Because the model has been trained on massive amounts of text and can deeply understand the semantics of the text, the generated vector can well represent the comprehensive function of the metafunctional unit. The second method is combined encoding based on structured information. This method encodes the different components of the metafunctional unit separately and then combines them into the final feature vector. For example, a metafunctional unit can be viewed as composed of structured parts such as "action," "entity / object," and "attribute." The system can extract the core words (such as set, color, object, value) for each part separately, and then use a pre-trained word vector model (such as GloVe or FastText) to obtain the word vector for each core word. Finally, these independent word vectors are merged into a single feature vector representing the entire meta-functional unit through an aggregation strategy (such as averaging all word vectors, max pooling, or using weighted summation). This method allows for finer control over the contribution of different parts to the final vector representation.

[0045] S105. In the pre-constructed heterogeneous domain logic graph, retrieve reference logic nodes whose cosine similarity with the feature vector of the meta-functional unit is greater than a preset threshold, and obtain a set of candidate reference nodes.

[0046] The pre-built heterogeneous domain logical graph is a large-scale knowledge graph that integrates knowledge from different domains (such as painting, music, programming, and physics simulation). Nodes (logical nodes) in the graph represent concepts, functions, APIs, algorithms, or operational units in various domains, and edges represent relationships between them (such as "is-a", "has-property", "depends-on"). Each logical node is also pre-encoded as a feature vector using a method similar to S104. Retrieval refers to searching within the graph. The meta-functional unit feature vector is a mathematical vector representing a meta-functional unit generated by S104. Cosine similarity is a mathematical method for measuring the similarity of two vectors in a direction, with a value range of [-1, 1]. The closer the value is to 1, the more similar the two vectors are. The preset threshold is a numerical threshold used for filtering (e.g., 0.8); only nodes with similarity exceeding this value are considered valid matches. Reference logical nodes are nodes in the graph that are functionally similar to a certain meta-functional unit. The candidate reference node set is the set of all reference logical nodes that have passed the cosine similarity threshold filtering. The overall process of this step can be described as follows: The system takes the "digital fingerprint" (feature vector) of a meta-functional unit and searches for functionally similar entries in a vast "interdisciplinary capability encyclopedia" (heterogeneous domain logical graph). The system calculates the "directional consistency" (cosine similarity) between the fingerprint and the pre-stored digital fingerprint of each entry in the encyclopedia, and selects all entries with sufficiently high consistency (greater than a preset threshold) to form a "potential matching list" (a set of candidate reference nodes).

[0047] The specific methods and techniques for implementing this step can be as follows: The first method is brute-force full computation. This method is very straightforward. After receiving the feature vector of a meta-functional unit, the system traverses every logical node in the heterogeneous domain logical graph. During the traversal, it obtains the pre-stored feature vector of each logical node and calculates its cosine similarity with the feature vector of the input meta-functional unit. If the calculated similarity value is greater than a preset threshold, the logical node is added to the candidate reference node set. This process continues until all logical nodes in the graph have been compared. While this method is simple and easy to understand, guaranteeing the discovery of all nodes that meet the conditions, its computational cost is very high and its retrieval efficiency is low when the graph is very large. The second method is efficient retrieval based on Approximate Nearest Neighbor (ANN) search. To avoid full computation, the system can pre-construct an ANN index using the feature vectors of all logical nodes. Commonly used ANN algorithms include tree-based methods (such as Annoy), hash-based methods (such as LSH), or graph-based methods (such as HNSW). After indexing, when searching for similar nodes for a new metafunctional unit feature vector, the system no longer performs a full comparison but instead performs an efficient search within this index structure. The ANN algorithm can return the K most similar neighbors at an order-of-magnitude speed higher than brute-force search, sacrificing a minimal recall rate (potentially missing a very small number of nodes that meet the criteria). The system then calculates the precise cosine similarity only for these K returned neighbors and selects nodes with similarities greater than a preset threshold to form a candidate reference node set. This approach significantly improves retrieval efficiency, enabling it to handle massive logistic graphs.

[0048] S106. Computational metafunctional unit and the shortest path of each reference logic node in the candidate reference node set in the heterogeneous domain logic graph.

[0049] The meta-functional unit refers to the atomic task currently being processed. The candidate reference node set is a list of graph nodes selected in step S105 that are semantically similar to the meta-functional unit. The heterogeneous domain logic graph is a graph structure containing interdisciplinary knowledge. The graph topological shortest path refers to the minimum number of edges required to travel from one node to another in the graph structure. This path length reflects the "distance" or "degree of association" between two nodes in the graph's topological structure. This step is purely computational; its overall process can be described as follows: after finding semantically similar candidate nodes, the system also needs to measure the "structural relevance" of these candidate nodes to the current task. To do this, the system first needs to determine a reference point in both the meta-functional unit dependency graph (representing the current task structure) and the heterogeneous domain logic graph (representing the general knowledge structure). Then, for each candidate reference node, the system calculates two distances: one is the position of the current meta-functional unit in its own task flow graph (distance to the task's starting point), and the other is the position of the candidate node in the general knowledge graph (distance to the starting point of its domain). The purpose of this step is to calculate the distance between these two locations, preparing for the next step of comprehensive scoring. Note that the original text only specifies the start and end points of the path in the detailed description of S107. This step, S106, only refers to calculating the shortest path in the original text, but for logical completeness, its specific calculation content is elaborated in S107. Therefore, the core of this step is to execute the graph path calculation algorithm.

[0050] The specific methods and techniques for implementing this step can be as follows: The first method is based on breadth-first search (BFS) for single-source shortest path calculation. BFS is the standard and most efficient algorithm for calculating the single-source shortest path in an unweighted graph. To calculate the first shortest path length from the meta-functional unit to the task's starting node, the system first locates the task's starting node (a node with an in-degree of 0) on the meta-functional unit dependency graph (a directed acyclic graph). Then, BFS is executed from this starting node, traversing the graph until the target meta-functional unit is found. The levels or distances recorded during the traversal are the shortest path lengths. Similarly, to calculate the second shortest path length from a candidate reference node to the domain root node, the system locates the candidate node and its domain root node (a predefined domain entry point) in the heterogeneous domain logical graph. Then, BFS is executed from the root node to find the shortest path length to the candidate node. This process is repeated for each node in the candidate reference node set. The second method utilizes a pre-computed distance matrix. If the heterogeneous domain logical graph is relatively static, to accelerate repeated queries, the system can pre-calculate and store the shortest path lengths between all node pairs in the graph, forming a large distance matrix. This can be achieved by performing a BFS on each node, or by using a more advanced Floyd-Warshall algorithm (suitable for dense graphs) or Johnson algorithm (suitable for sparse graphs) to calculate the shortest path for all node pairs at once. When it is necessary to query the distance from a candidate reference node to its neighborhood root node, the system can directly search in this pre-calculated matrix with a time complexity of O(1), greatly improving computational efficiency. For dynamically changing metafunctional unit dependency graphs, since their size is usually small, BFS can still be used for computation in real time.

[0051] S107. Calculate the isomorphism score based on cosine similarity and graph topological shortest path, and generate a cross-domain logical mapping table based on the isomorphism score;

[0052] The system calculates isomorphism scores based on cosine similarity and graph topological shortest path, and generates a cross-domain logical mapping table based on the isomorphism scores. Specifically, the calculation of isomorphism scores based on cosine similarity and graph topological shortest path includes: extracting the input parameter type set and output parameter type set of the meta-functional unit, and defining the combination of these sets as the data constraint attribute of the meta-functional unit; traversing the candidate reference node set, selecting nodes whose input / output attributes match the data constraint attribute as valid reference sets; determining the task starting node of the meta-functional unit's dependency graph, and the domain root node of the heterogeneous domain logical graph; calculating the first shortest path length from the meta-functional unit to the task starting node, and the second shortest path length from each node in the valid reference set to the domain root node; generating a positional deviation coefficient based on the absolute value of the difference between the first and second shortest path lengths; and using the positional deviation coefficient to correct the cosine similarity to obtain the isomorphism score.

[0053] The isomorphism score is a comprehensive evaluation that considers both the functional semantic similarity (reflected by cosine similarity) and the positional similarity (reflected by graph topology paths) between the meta-functional unit and the reference logical node. The cross-domain logical mapping table is the final mapping result, assigning the best-matching logical node in the heterogeneous domain logical graph to each meta-functional unit. The input parameter type set and output parameter type set refer to the sets of data types required before and generated after execution by the meta-functional unit, respectively. The data constraint attribute is the union of the input and output parameter type sets, representing the unit's complete requirements for data types. The effective reference set is a subset of nodes further filtered from the candidate reference node set whose input and output data types completely match those of the meta-functional unit. The task starting node is a node in the meta-functional unit dependency graph with no input dependencies (in-degree of 0). The domain root node is a predefined node in the heterogeneous domain logical graph representing a domain entry point or core concept. The first shortest path length refers to the distance from the meta-functional unit to the task starting node. The second shortest path length refers to the distance from a valid reference node to its domain root node. The positional deviation coefficient is a correction factor calculated based on the difference between the two shortest path lengths, used to adjust the cosine similarity. The overall process of this step is as follows: the system performs a double review on each candidate match. First, there is a "qualification review" (data constraint attribute matching), filtering out candidates with incompatible interfaces. Then, the "valid candidates" that pass the review are given a "comprehensive score" (calculating the isomorphism score). When scoring, not only are their functional descriptions similar (cosine similarity), but also whether their "hierarchy" in their respective "organizational structures" (dependency graph and logical graph) is equivalent (positional deviation). Finally, the system selects the candidate with the highest score for each meta-functional unit, forming a formal "work docking list" (cross-domain logical mapping table).

[0054] Specifically, the detailed technical solution and its implementation methods can be disclosed in two ways. The first method is based on a calculation process of set operations and weighted correction. 1) Data constraint attribute construction and screening: For a meta-functional unit, the system extracts its input parameter type (e.g., string, integer) and output parameter type (e.g., image_data) to form a set {string, integer, image_data} as its data constraint attribute. For each node in the candidate reference node set, the system also obtains its predefined input and output type set. Through the equality judgment of the sets, nodes whose type sets are completely consistent with the data constraint attributes of the meta-functional unit are screened out to form a valid reference set. 2) Path length calculation and position deviation coefficient generation: The system uses the BFS algorithm to calculate the path length L1 from the meta-functional unit to the starting node (the node with an in-degree of 0) in its dependency graph, and the path length L2 from each node in the valid reference set to the root node of its domain. Then, using a decay function, such as a Gaussian function or an exponential decay function, the absolute value of the difference between the two path lengths, |L1-L2|, is mapped to a position deviation coefficient P in the interval [0, 1]. The larger the difference, the smaller the value of P. 3) Isomorphism score calculation and mapping table generation: For each valid reference node, its isomorphism score S is calculated using a correction formula, such as S=CosineSimilarity*P, or S=w1*CosineSimilarity+w2*P, where w1 and w2 are weights. The system calculates the isomorphism scores of all valid reference nodes for each metafunctional unit and selects the node with the highest score as its final mapping. The pairing relationships of all metafunctional units and their best mapping nodes are summarized to generate a cross-domain logical mapping table.

[0055] The second implementation method is based on feature vectorization and ensemble learning model scoring. 1) Vectorized matching of data constraint attributes: The system does not use strict set equality judgment, but also vectorizes the input and output type sets. For example, a vector can be predefined for each data type (string, image_data, etc.), and then the data constraint attribute vector of a unit can be obtained by averaging or concatenating all its type vectors. During screening, the cosine similarity between the data constraint attribute vectors of the meta-functional unit and the candidate reference node is calculated, and nodes with similarity greater than a high threshold (such as 0.99) are retained as valid reference sets, which is more flexible than strict equality judgment. 2) Path and similarity feature engineering: The system uses cosine similarity, the first shortest path length L1, the second shortest path length L2, and their difference L1-L2, ratio L1 / L2, etc., as a set of numerical features. 3) Ensemble model scoring: The system pre-trains a learning-to-rank model, such as LambdaMART or a simple gradient boosting decision tree (GBDT) model. The training data for this model consists of historical metafunctional unit-candidate node pairs, characterized by the numerical features constructed above, with labels indicating the quality of the pairing (e.g., manually labeled or evaluated based on final task performance). During runtime, for a metafunctional unit and each of its valid reference nodes, the system extracts this set of features and inputs it into the trained model, which directly outputs an isomorphism score. This method automatically learns the complex nonlinear relationship between cosine similarity and positional bias, potentially achieving superior performance compared to manually designed correction formulas. Finally, the node with the highest score is selected to generate the mapping table.

[0056] S108. Based on the meta-functional unit dependency graph and cross-domain logical mapping table, match the corresponding execution resources and virtual execution agents for each meta-functional unit in the meta-functional unit set to generate a resource scheduling plan containing resource configuration information and agent allocation information.

[0057] The system, based on a meta-functional unit dependency graph and a cross-domain logical mapping table, matches corresponding execution resources and virtual execution agents for each meta-functional unit in the meta-functional unit set to generate a resource scheduling plan containing resource configuration information and agent allocation information. Specifically, this includes: parsing the topology of the meta-functional unit dependency graph; generating a topology execution sequence for the meta-functional unit set based on the topology; traversing the topology execution sequence, determining the target logical nodes corresponding to each meta-functional unit according to the cross-domain logical mapping table, and extracting resource feature tags from the target logical nodes; identifying target virtual execution agents that match the resource feature tags in a pre-set virtual execution agent pool, and establishing a mapping and binding relationship between the meta-functional units and the target virtual execution agents; quantifying the computing power and storage space required by the target virtual execution agents based on the resource feature tags; generating resource configuration information based on the computing power and storage space; and encapsulating the mapping and binding relationship into agent allocation information, aggregating it with the resource configuration information to obtain the resource scheduling plan.

[0058] Execution resources refer to the physical or virtualized hardware required to execute computational tasks, such as CPUs, GPUs, memory, and storage space. A virtual execution agent is a software entity or service that encapsulates the ability to execute specific types of meta-functional units; it can be understood as a "virtual worker" or microservice with specific skills. Resource configuration information is the specification of the specific computing resources that need to be allocated for task execution, such as "2 CPU cores, 8GB memory." Agent allocation information is a mapping relationship specifying which meta-functional unit will be executed by which virtual execution agent. The resource scheduling plan is the final, complete execution scheme that includes all resource configurations and agent allocations. The topology execution sequence is a linear execution order generated based on the topology of the meta-functional unit dependency graph, ensuring that all dependencies are satisfied. Resource feature tags are labels attached to logical graph nodes that describe the resource characteristics required for their execution, such as {device: 'GPU', framework: 'TensorFlow', memory: '16GB'}. The virtual execution agent pool is a central repository that registers all available virtual execution agents and their capabilities. Computing power and storage space are quantitative descriptions of resource requirements.

[0059] The specific implementation methods and technologies of this refined technical solution can be disclosed in the following two ways. The first method is a scheduling method based on sequence traversal and greedy matching. 1) Generate topology execution sequence: The system applies the Kahn algorithm or a topology sorting algorithm based on depth-first search to the dependency graph of the meta-functional units to generate one or more legal linear execution sequences. 2) Traversal and matching: The system processes each meta-functional unit one by one in the order of the topology sequence. For the current unit, it first queries the cross-domain logical mapping table generated by S107 to find its corresponding target logical node. Then, it extracts the resource feature tag from the target logical node. The system uses this tag to query the virtual execution agent pool. Each agent in the pool has pre-registered its own capability tag. The system adopts a greedy strategy to select the first available agent whose capability tag completely matches the resource feature tag, and establishes a mapping binding relationship between the meta-functional unit and this target virtual execution agent. 3) Resource quantification and plan generation: The system parses the resource feature tag and converts the descriptive requirements (such as memory: '16GB') into specific resource configuration requests. For example, 'GPU' is converted into a request for a GPU card. The quantified resource allocation information is then aggregated with the mapping and binding relationship (proxy allocation information) established in the previous step to form a scheduling sub-plan for the current meta-functional unit. After traversing the entire topology sequence, all sub-plans are combined to form a complete resource scheduling plan.

[0060] The second implementation is a global scheduling method based on constraint satisfaction optimization. 1) Generate topology execution sequence: Similar to the first method, obtain the topology sequence. 2) Construct constraint satisfaction problem (CSP): The system models the entire scheduling problem as a CSP. The variable is the virtual execution agent to be assigned to each meta-functional unit. The domain of each variable is the set of capable agents in the virtual execution agent pool. Constraints include: a) Capability constraint: The capability label of the agent assigned to the meta-functional unit must match the resource feature label corresponding to the unit. b) Resource constraint: On any parallel path in the dependency graph, the sum of similar resources (e.g., number of GPUs, total memory) requested by concurrently executing meta-functional units cannot exceed the total available resources of the system. c) Affinity / anti-affinity constraint (optional): Some tasks may want to be assigned to the same physical node (affinity) or must be executed separately (anti-affinity); these can be additional constraints. 3) Solving and plan generation: The system uses a CSP solver (such as Minion or or-tools) to find one or more solutions that satisfy all constraints. Each solution represents a complete proxy allocation scheme. The system can choose one (e.g., the first solution found) or select the optimal solution from multiple solutions based on an optimization objective (such as minimizing expected execution time or minimizing resource costs). Once the proxy allocation scheme is determined, the subsequent resource quantification and plan generation processes are similar to the first method. Although this method is more complex, it can find a globally better resource scheduling scheme, especially under resource constraints or high task parallelism.

[0061] S109. According to the resource scheduling plan, call the multimodal generation model to generate multimodal interactive content data corresponding to the set of meta-functional units.

[0062] A multimodal generative model is an AI model capable of processing and generating multiple types of data (such as text, images, sound, and video). Without limitation, this can be a single, large model capable of simultaneously outputting multiple modalities, or a combination of multiple collaborative models, each responsible for generating different modalities. The set of meta-functional units is a list of atomic operations after task decomposition. Multimodal interactive content data is the final, user-perceptible output, which can take various forms, such as images, text descriptions, animations, or combinations thereof. This step is the endpoint of the entire process, which can be described as follows: The system, holding the final "construction plan" (resource scheduling plan), begins directing various "virtual workers" (virtual execution agents) to perform their tasks. Each virtual agent, on its allocated computing resources, drives its underlying core capability engine (multimodal generative model) to execute the basic operations (meta-functional units) assigned to it. All workers collaborate according to the flowchart (dependency graph), ultimately transforming the user's initial abstract needs into a concrete, rich result containing multiple media formats (multimodal interactive content data), which is then presented to the user.

[0063] The specific methods and technologies for implementing this step can be as follows: The first method is distributed execution based on a microservice architecture. In this architecture, each virtual execution agent runs as an independent microservice. Multimodal generation capabilities are also decomposed into different model services, such as a dedicated text generation service (based on GPT, etc.), an image generation service (based on Stable Diffusion or DALL-E, etc.), and an audio generation service. The system acts as the orchestrator, coordinating the invocation of these services according to the resource scheduling plan and the metafunctional unit dependency graph. It sends the metafunctional units and their input data (possibly from the output of the preceding unit) to the designated agent microservices in the plan, following the topological order. After receiving the request, the agent transforms it into an API call to its underlying specific generation model service. For example, a `generate_image` metafunctional unit would be transformed by its agent into a call to the image generation service, with the parameter "a cat". After the service completes execution and returns image data, the agent then passes this data to the orchestrator, which, according to the dependency graph, uses it as the input to the next metafunctional unit. The entire process resembles a data processing pipeline, ultimately converging all outputs to form multimodal content. The second approach is centralized generation based on a unified multimodal model. This employs a powerful, single, end-to-end multimodal generation model (such as some cutting-edge unified multimodal models). This model can receive inputs that mix multiple modalities, including text and images, and directly generate multimodal outputs based on instructions. In this approach, the system first transforms the entire set of meta-functional units and their dependencies into a structured prompt that is friendly to the large model. This prompt details the final scene to be generated, including its elements, their attributes, relationships, and the desired output format. Then, the system calls this large model once; the model internally understands this complex prompt and generates the final multimodal content in one step.

[0064] In the above embodiments, by semantically parsing the user-input task requirement text and converting it into structured data, and combining this with pattern matching using a pre-defined meta-functional unit rule base, complex tasks can be decomposed into basic meta-functional units. Using a pre-trained vector model to encode the features of these meta-functional units, similar nodes are retrieved in the heterogeneous domain logical graph, and graph topological distances are calculated, establishing a mapping relationship between meta-functional units and heterogeneous domains. Based on the dependency graph and mapping relationship, execution resources and proxies are allocated to the meta-functional units, generating multimodal interactive content. This method improves the accuracy of cross-disciplinary knowledge transfer, enhances the granular control of task decomposition, and improves the targeting of resource scheduling. Because a similarity- and graph distance-based mapping mechanism is adopted, the error rate of cross-domain knowledge mapping is reduced, the rationality of execution resource allocation is improved, and the system can better adapt to differences in knowledge structures between different domains, improving the accuracy of resource recommendation and matching when facing innovative cross-domain tasks.

[0065] After completing basic task deconstruction, cross-domain mapping, and resource scheduling, this application also provides another cross-disciplinary skill decoupling and meta-capability unit intelligent scheduling method to further improve the reliability of system execution. This method forms a closed-loop quality control process by evaluating the fidelity of task execution and making timely adjustments when the execution effect is unsatisfactory. The following section combines... Figure 2 Another method for interdisciplinary skill decoupling and intelligent scheduling of meta-capability units in the embodiments of this application is described:

[0066] Please see Figure 2 This is another flowchart illustrating a cross-disciplinary skill decoupling and meta-capability unit intelligent scheduling method in an embodiment of this application.

[0067] S201. Analyze the multimodal interaction content data to extract the actual execution results of the contained actions and information;

[0068] Actions and information refer to the specific operations performed by the system, such as calling a function, requesting a network interface, and the data generated or processed by these operations. The actual execution result is not the raw multimodal data itself, but rather a structured data set that clearly describes "what" the system actually did, obtained after parsing and structuring this raw data. This structured data accurately records the functions executed, the parameters used, and the outputs obtained, serving as the factual basis for subsequent performance evaluation. The core of this process lies in transforming the mixed and diverse raw outputs generated by the system during task execution into a unified, organized, and machine-analyzable execution list, faithfully reflecting the details and results of each specific operation.

[0069] One specific approach to this step is rule-based parsing. The system predefines parsing rules for different data modalities. For example, for text-based execution logs, regular expressions can be configured to match and extract key information, such as function call identifiers, passed parameter values, and return results. For JSON or XML data, standard parsing libraries can be used to traverse the data structure and extract the required fields. For file operations, file system metadata, such as file creation time, size, and path, can be checked to confirm the completion of file generation actions. This method is fast and accurate for data sources with stable formats and well-defined structures. Another approach is machine learning-based parsing. The system can train one or more models to automatically extract information from unstructured or semi-structured data. For example, Named Entity Recognition (NER) models can be used to automatically identify entities such as "actions," "parameters," and "results" in logs described in natural language. For more complex scenarios, a Sequence-to-Sequence (Seq2Seq) model can be used to directly convert a raw, messy log text into a structured JSON object that fully describes the executed actions and results. This approach is more flexible, can adapt to slight changes in log format, and can handle edge cases that are difficult for some rules to cover.

[0070] S202. Calculate the task fidelity score based on the actual execution results and structured requirement description data;

[0071] The system calculates a task fidelity score based on actual execution results and structured requirement description data. Specifically, this includes: extracting expected function points from the structured requirement description data according to preset parsing rules; each expected function point contains a function identifier and expected parameters, and all expected function points constitute an expected function point set; extracting actual function points corresponding to each actually executed action from the actual execution results according to preset parsing rules; each actual function point contains a function identifier and actual parameters, and all actual function points constitute an actual function point set; comparing the actual function point set with the expected function point set to determine the hit function points corresponding to the function identifiers, missing function points that exist in the expected function point set but not in the actual function point set, and redundant function points that exist in the actual function point set but not in the expected function point set; and calculating the task fidelity score based on a preset scoring function and the number of hit, missing, and redundant function points.

[0072] Task fidelity score is a quantitative metric used to measure the degree to which the actual execution result matches the standard answer. A higher score indicates better and more accurate execution. An expected function point is a specific function defined in the requirements list that the system should execute; it consists of a unique function identifier and a set of expected parameters. An actual function point is a function recorded in the actual execution result that the system actually executed; it also consists of a function identifier and the parameters actually used. A hit function point is a function point that exists in both the requirements list and the actual execution result, indicating that this function was executed as planned. A missing function point is a function point that exists in the requirements list but did not occur during actual execution, representing an omitted function. A redundant function point is a function point that exists during actual execution but was not required in the requirements list, representing redundant or erroneous operations. The preset scoring function is a predefined calculation formula that combines the number of hit, missing, and redundant function points to arrive at an overall task fidelity score. The essence of this step is a quantitative comparison and evaluation process. The system identifies execution deviations (missed executions, over-executions) by checking the "plan" and "reality" item by item, and uses a unified numerical score to summarize the overall quality of the task execution.

[0073] One specific approach to implementing this refined technical solution is based on set operations and weighted scoring. First, through key-value extraction or specific format parsing, the expected function point set and the actual function point set are extracted from the structured requirement description data and the actual execution results, respectively. Each function point can be represented as a data structure containing a function identifier and parameters. Then, these two sets are converted into hash sets to leverage their efficient computational characteristics. By calculating the intersection of the two hash sets, the set of hit function points can be obtained; by calculating the difference between the expected and actual function point sets, the set of missing function points can be obtained; conversely, by calculating the difference between the actual and expected function point sets, the set of redundant function points is obtained. Finally, a pre-defined weighted linear function is applied to calculate the fidelity score, for example: Score = (Number of hits × Weight 1) - (Number of missing points × Weight 2) - (Number of redundancies × Weight 3), where the weight values ​​are constants pre-set based on business importance. A second implementation method is based on graph matching and semantic similarity. The system can construct structured requirements and actual execution results as directed acyclic graphs (DAGs), where nodes represent functional points and edges represent dependencies or execution order. During the comparison phase, instead of simple identifier matching, a graph matching algorithm is used to find the maximum common subgraph between two graphs. This allows for more flexible handling of situations such as changes in the order of functional points. For parameter comparison of matched functional points, exact equality of parameter values ​​is not required. Instead, semantic similarity algorithms (such as using word embedding models to calculate the similarity of text parameters or using distance functions to calculate the difference in numerical parameters) are used to evaluate the degree of parameter matching. The final fidelity score can be calculated based on graph edit distance, representing the cost of adding or deleting nodes for missing and redundant functional points, and the cost of replacing nodes for parameter mismatches. The smaller the total edit distance, the higher the fidelity score.

[0074] S203. If the task fidelity score is determined to be lower than the preset fidelity threshold, determine the target functional unit that causes the task fidelity score to be lower than the preset fidelity threshold.

[0075] The target meta-functional unit is the "culprit" identified in this situation that leads to the low overall score. A meta-functional unit is a higher-level abstract concept than a function point; it represents a relatively independent functional module or subtask. The execution of a meta-functional unit may correspond to one or more specific function points. The process of identifying the target meta-functional unit is essentially a tracing process from "phenomenon" to "root cause." The system doesn't simply judge "task failure," but rather aims to further pinpoint which specific step in the plan went wrong. By analyzing the missing and redundant function points causing the low score, and tracing these specific execution errors back to the original meta-functional unit responsible for executing them, that unit is identified as the "target" that needs correction.

[0076] One specific approach to implementing this step is based on direct mapping and contribution analysis. When initially formulating the execution plan, the system establishes and maintains a clear mapping relationship, recording the list of expected functional points that each meta-functional unit is responsible for executing. While calculating the overall fidelity score in step S202, the system also calculates an independent sub-score for each meta-functional unit. This sub-score is calculated similarly to the total score, but only considers hit, missing, and redundant functional points related to that meta-functional unit. When the total score is below a threshold, the system iterates through the sub-scores of all meta-functional units, identifying the meta-functional unit with the lowest sub-score or the most significant effect on lowering the total score (e.g., the highest proportion of missing functional points among its responsible functional points) as the target meta-functional unit. This method is simple and direct, suitable for tasks with low coupling between meta-functional units. Another implementation approach is based on dependency graph backtracking analysis. The system represents the entire task as a dependency graph composed of meta-functional units, where nodes are meta-functional units and edges represent their execution order or data dependencies. Missing or redundant functional points identified in S202 are associated with the corresponding leaf nodes or execution nodes in this graph. When it is necessary to determine the target meta-functional unit, the system starts from these "error points" and backtracks through the dependency graph. The node where all error paths eventually converge, or the upstream node that carries the most downstream errors on the backtracking path, is identified as the root cause of the problem, i.e., the target meta-functional unit. This method is more suitable for tasks with complex dependencies between units.

[0077] A new technical challenge in identifying target meta-functional units is that apparent errors may be caused by deeper, latent failures occurring in other meta-functional units. For example, the failure of a meta-functional unit B (manifested as a missing function point) might be due to its upstream meta-functional unit A, which, although executed, outputs incorrect results. Attributing this chain of failures solely to B fails to address the root cause. To address this, the system can construct and analyze a causal dependency graph containing data flows. This graph not only represents the execution order between meta-functional units but also explicitly shows how the output data of one unit serves as the input of another. When low fidelity is detected, the system traces upstream along the causal dependency graph, starting from the erroneous meta-functional unit (such as B). It examines not only the execution of B but also the source of the input data that B depends on (i.e., the output of A) and assesses the quality of that data. In this way, the system can trace the chain of failures until it finds the meta-functional unit (A) that initially produced the incorrect data or state and identifies it as the fundamental target meta-functional unit. This ensures that corrective measures address the true root cause of the problem.

[0078] S204. In the cross-domain logic mapping table, the isomorphism score of the reference logic node currently associated with the target element functional unit is reduced by a preset ratio to obtain an updated cross-domain logic mapping table.

[0079] In the cross-domain logical mapping table, the system reduces the isomorphism score of the reference logical nodes currently associated with the target functional unit by a preset ratio to obtain an updated cross-domain logical mapping table. Specifically, this includes: performing attribution analysis on the deviation between the actual execution result of the target functional unit and the structured requirement description data to determine a failure attribution identifier, which is a preset classification code; updating the global attribution knowledge base based on the failure attribution identifier and the reference logical nodes currently associated with the target functional unit; identifying other reference logical nodes from the global attribution knowledge base that, besides the currently associated reference logical nodes, have an association strength with the failure attribution identifier higher than a preset association threshold to obtain a high-risk node set; reducing the isomorphism score of the reference logical nodes currently associated with the target functional unit in the cross-domain logical mapping table by a first preset ratio; and reducing the isomorphism score of each reference logical node in the high-risk node set in the cross-domain logical mapping table by a second preset ratio to obtain an updated cross-domain logical mapping table. The preset ratios include the first preset ratio and the second preset ratio.

[0080] Specifically, the attribution analysis is performed on the deviation between the actual execution result of the target functional unit and the structured requirement description data to determine the failure attribution identifier. This includes: determining the deviation features that constitute the deviation based on the actual execution result and the structured requirement description data. The deviation features include missing functional points, redundant functional points, and parameter deviation functional points determined based on the hit functional points; and combining the missing functional points, redundant functional points, and parameter deviation functional points as deviation feature combinations, and determining the failure attribution identifier corresponding to the deviation feature combination in the preset attribution rule base.

[0081] A reference logical node is a concrete entity capable of executing a meta-functional unit, such as a specific API interface, an algorithm library, a software service, or a hardware module. The isomorphism score is a numerical value stored in this table that quantifies the suitability or matching degree of a reference logical node for a particular meta-functional unit; a higher score indicates a more recommended use. The preset ratio is a percentage used to reduce the score; it contains two values: a first preset ratio penalizes nodes that have just failed, and a second preset ratio penalizes other potentially risky nodes. The failure attribution identifier is a standardized code used to classify the causes of failure, such as "network timeout" or "incorrect parameter format." The global attribution knowledge base is a historical database that accumulates attribution information for each failure, recording which reference logical node failed under what circumstances. The high-risk node set is obtained by querying the knowledge base and refers to other reference logical nodes that, besides the currently failed node, have historically frequently caused the same type of failure. The preset association threshold is a standard used to filter high-risk nodes; only nodes with an association strength with a failure cause exceeding this threshold are considered high-risk.

[0082] One specific approach to implementing this refined technical solution is to utilize a rule engine for attribution analysis and a relational database to manage the knowledge base. First, deviation features (missing, redundant, and parameter-biased function points) are input into a pre-defined rule engine. The engine maps specific deviation combinations to a failure attribution identifier based on the "IF-THEN" rule. Next, in the relational database serving as the global attribution knowledge base, a table records the associations of (reference logical node ID, failure attribution identifier, number of failures). After a failure occurs, the failure count for the corresponding node and attribution identifier is incremented. Then, the system queries this table to find other nodes associated with the current failure attribution identifier whose failure count exceeds a preset association threshold, forming a high-risk node set. Finally, in the cross-domain logical mapping table, the system uses an SQL UPDATE statement to multiply the isomorphism score of the failed node by (1 - a first preset ratio) and multiply the isomorphism score of each node in the high-risk set by (1 - a second preset ratio). A second implementation method is to use a machine learning classifier for attribution and a graph database to build the knowledge base. The system can train a multi-classification model (such as a decision tree or neural network). The model's input is a quantized bias feature vector, and its output is a failure attribution label. This approach can learn more complex patterns than rules. The global attribution knowledge base is implemented using a graph database, with reference logical nodes and failure attribution labels as nodes in the graph. The weights of the edges between them represent the strength of the association. When a failure occurs, the weight of the corresponding edge increases. Finding high-risk nodes involves starting from the failure attribution node in the graph and searching for neighboring logical nodes whose weights exceed a threshold. The reduction in score is achieved by updating the attributes of graph nodes or edges.

[0083] S205. Based on updating the cross-domain logical mapping table, determine the target reference logical node for the target meta-functional unit;

[0084] The system determines target reference logical nodes for the target meta-functional unit based on an updated cross-domain logic mapping table. Target reference logical nodes are those with the highest isomorphism score that have not yet been selected. Unselected reference logical nodes refer to the set of all alternative reference logical nodes that can be used to implement the meta-functional unit but have not yet been tried during the retry cycle of the current task execution. The logic of this step is very clear: after the old path becomes impassable (the original node fails), the system needs to find a new path. It consults the updated "map" (i.e., the updated cross-domain logic mapping table) and selects the seemingly flattest and widest path (the node with the highest isomorphism score) from all untraveled paths leading to the destination (unselected reference logical nodes). This process ensures that the system's corrective behavior is directional, always choosing the optimal alternative under the current understanding, and avoids repeatedly trying the same failed solution in the same task.

[0085] One specific approach to this step is deterministic selection based on a sorted list. The system first retrieves all associated reference logic nodes and their corresponding isomorphism scores from the updated cross-domain logic mapping table based on the target functional unit's identifier. Simultaneously, the system maintains a list of nodes already tried in this task. From the retrieved node list, all tried nodes are filtered out. Then, the remaining candidate nodes are sorted in descending order of their isomorphism scores. The top node in the sorted list is determined as the new target reference logic node. This method is simple to implement, highly efficient, and ensures that the current optimal solution is always selected. Another approach is probabilistic selection based on a Softmax function. To strike a balance between "utilizing" the current optimal solution and "exploring" other potential solutions, the system doesn't always select the node with the highest score. It takes the isomorphism scores of all unselected candidate reference logic nodes as input and processes them through a Softmax function. This function converts these scores into a probability distribution, where nodes with higher scores have a greater probability of being selected, but nodes with lower scores also have a chance of being selected. The system then samples based on this probability distribution to determine the target reference logical node. This method introduces randomness, which helps the system discover "dark horse" solutions that initially have low scores but may actually perform well, thus increasing the system's exploratory capabilities.

[0086] S206. Generate a revised resource scheduling plan based on the target reference logical node;

[0087] Revising the resource scheduling plan is a partial or global update to the original task execution plan. The core change lies in replacing the execution entities (i.e., failed reference logical nodes) allocated to the target functional units in the original plan with newly determined target reference logical nodes from the previous step. This process is not merely a simple "replacement"; it must also consider the potential chain reactions brought about by the new node. For example, the new reference logical node may require different input data, produce output in different formats, or have different execution times and resource consumption compared to the old node. Therefore, generating a revised plan means adjusting subsequent task steps accordingly to ensure data flow continuity, reasonable execution order, and effective resource allocation, ultimately forming a logically consistent and executable new plan.

[0088] One specific way to achieve this step is through a partial plan "patching" approach. This method aims to minimize changes to the original plan. The system locates the part of the original plan corresponding to the target functional unit and replaces the old reference logical node with a new target reference logical node. Then, the system checks the interface between the new node and its direct predecessor and successor tasks. If the input and output data types and formats of the new node are completely consistent with the old node, no other changes are needed. If inconsistencies exist, the system can automatically insert some "adapters" or small data transformation steps before and after the new node to bridge the differences. This method is fast and suitable for highly modular and loosely coupled tasks. Another more robust approach is partial replanning based on failure points. The system treats the newly selected target reference logical node as a new constraint that must be satisfied. It marks all parts of the original plan from the failure point onwards as failed. Then, the system calls its core planner algorithm, but the planning scope is limited to the remaining part of the task. The planner's goal is to generate a sub-plan that optimally completes all remaining task objectives starting from the new node, while satisfying the new node constraints. This approach better handles complex dependencies and resource changes caused by node replacements, resulting in a more globally consistent new plan. For example, a hierarchical task network planner can be used to complete this replanning process starting from an intermediate state.

[0089] S207. According to the revised resource scheduling plan, call the multimodal generation model to generate revised multimodal interaction content data corresponding to the set of meta-functional units.

[0090] The revised multimodal interaction content data is a completely new set of specific execution instructions generated based on the revised plan. This data is the direct carrier for the system's "second attempt," and it will be sent to the corresponding execution environment for execution. This step is the final link in the entire closed-loop revision process, namely "re-execution."

[0091] One specific approach to this step is template-based generation. The system predefines execution templates for each reference logical node in the knowledge base. For example, for a node that needs to call a RESTful API, its template could be a URL string containing placeholders. When interactive content needs to be generated, the system finds the corresponding template based on the target reference logical node in the correction plan, then retrieves parameter values ​​(such as the value of user_id) from the plan's context and fills them into the template's placeholders, thereby generating a complete, directly executable HTTP request. This method is fast and produces accurate and reliable results for structured, standardized interactions (such as API calls and SQL queries). Another more flexible approach is generation based on large-scale generative AI models. The system can utilize a large language model or a similar multimodal generative model. The model's input is a description of a meta-functional unit in the correction plan, its selected reference logical nodes, and a natural language or structured description of the required parameters. Then, the system guides the model to generate the required executable content through pre-designed prompts.

[0092] In the above embodiments, the actual execution results are extracted by parsing multimodal interaction content data, the task fidelity score is calculated, and the target functional units causing low fidelity are identified. The system dynamically adjusts the isomorphism score in the cross-domain logical mapping table and selects a new reference logical node to generate a revised resource scheduling plan. This adaptive adjustment mechanism based on execution feedback improves the accuracy of task execution and enhances the system's responsiveness to execution deviations. By establishing a closed loop of task fidelity evaluation and dynamic correction, the system's self-optimization capability is improved, enabling timely correction of errors during execution.

[0093] The system in the embodiments of this invention is described below from the perspective of hardware processing. Please refer to [link / reference needed]. Figure 3 This is a schematic diagram of the physical device structure of an intelligent scheduling system for interdisciplinary skill decoupling and meta-capability units provided in an embodiment of this application.

[0094] It should be noted that, Figure 3 The structure of the system shown is merely an example and should not impose any limitations on the functionality and scope of use of the embodiments of the present invention.

[0095] like Figure 3As shown, the system includes a Central Processing Unit (CPU) 301, which can perform various appropriate actions and processes based on a program stored in Read-Only Memory (ROM) 302 or a program loaded from storage portion 308 into Random Access Memory (RAM) 303, such as executing the methods described in the above embodiments. The RAM 303 also stores various programs and data required for system operation. The CPU 301, ROM 302, and RAM 303 are interconnected via a bus 304. An Input / Output (I / O) interface 305 is also connected to the bus 304.

[0096] The following components are connected to I / O interface 305: input section 306 including a camera, infrared sensor, etc.; output section 307 including a liquid crystal display (LCD) and speakers, etc.; storage section 308 including a hard disk, etc.; and communication section 309 including a network interface card such as a LAN (Local Area Network) card and a modem, etc. Communication section 309 performs communication processing via a network such as the Internet. Drive 310 is also connected to I / O interface 305 as needed. Removable media 311, such as a disk, optical disk, magneto-optical disk, semiconductor memory, etc., are installed on drive 310 as needed so that computer programs read from them can be installed into storage section 308 as needed.

[0097] In particular, according to embodiments of the present invention, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments of the present invention include a computer program product comprising a computer program carried on a computer-readable medium, the computer program containing computer programs for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via communication section 309, and / or installed from removable medium 311. When the computer program is executed by central processing unit (CPU) 301, it performs the various functions defined in the present invention.

[0098] It should be noted that the computer-readable medium shown in the embodiments of the present invention can be a computer-readable signal medium or a computer-readable storage medium, or any combination thereof. A computer-readable storage medium can be, for example,—but not limited to—an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples of a computer-readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer disk, a hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM), flash memory, optical fiber, portable compact disc read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination thereof. In the present invention, a computer-readable storage medium can be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system, apparatus, or device. In the present invention, a computer-readable signal medium can include a data signal propagated in baseband or as part of a carrier wave, wherein a computer-readable computer program is carried. The transmitted data signal can take many forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof.

[0099] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. Each block in a flowchart or block diagram may represent a module, segment, or portion of code, which contains one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in a block diagram or flowchart, and combinations of blocks in a block diagram or flowchart, may be implemented using a dedicated hardware-based system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.

[0100] In another aspect, the present invention also provides a computer-readable storage medium, which may be included in the system described in the above embodiments; or it may exist independently and not assembled into the system. The storage medium carries one or more computer programs that, when executed by a processor of a system, cause the system to implement the methods provided in the above embodiments.

[0101] The above-described embodiments are only used to illustrate the technical solutions of this application, and are not intended to limit it. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of this application.

[0102] As used in the above embodiments, depending on the context, the term "when..." can be interpreted as "if...", "after...", "in response to determining...", or "in response to detecting...". Similarly, depending on the context, the phrase "when determining..." or "if (the stated condition or event) is interpreted as "if determining...", "in response to determining...", "when (the stated condition or event) is detected", or "in response to detecting (the stated condition or event)".

[0103] In the above embodiments, implementation can be achieved entirely or partially through software, hardware, firmware, or any combination thereof. When implemented using software, it can be implemented entirely or partially in the form of a computer program product. The computer program product includes one or more computer instructions. When the computer program instructions are loaded and executed on a computer, all or part of the processes or functions described in the embodiments of this application are generated. The computer can be a general-purpose computer, a special-purpose computer, a computer network, or other programmable device. The computer instructions can be stored in a computer-readable storage medium or transmitted from one computer-readable storage medium to another. For example, the computer instructions can be transmitted from one website, computer, server, or data center to another website, computer, server, or data center via wired (e.g., coaxial cable, fiber optic, digital subscriber line) or wireless (e.g., infrared, wireless, microwave, etc.) means. The computer-readable storage medium can be any available medium that a computer can access or a data storage device such as a server or data center that integrates one or more available media. The available medium can be a magnetic medium (e.g., floppy disk, hard disk, magnetic tape), an optical medium (e.g., DVD), or a semiconductor medium (e.g., solid-state drive), etc.

[0104] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. This program can be stored in a computer-readable storage medium, and when executed, it can include the processes described in the above method embodiments. The aforementioned storage medium includes various media capable of storing program code, such as ROM or random access memory (RAM), magnetic disks, or optical disks.

Claims

1. A method for interdisciplinary skill decoupling and intelligent scheduling of meta-capability units, characterized in that, include: Semantic parsing is performed on the task requirement text input by the user to obtain a set of key entities and a set of actions, and structured requirement description data is generated based on the set of key entities and the set of actions. The structured requirement description data is input into a preset meta-functional unit rule base, which then deconstructs the structured requirement description data into a set of meta-functional units through pattern matching. Construct a metafunctional unit dependency graph based on the data input-output dependencies between each metafunctional unit in the metafunctional unit set; Each metafunctional unit in the set of metafunctional units is encoded using a pre-trained vector embedding model to generate a metafunctional unit feature vector that corresponds one-to-one with each metafunctional unit. In the pre-constructed heterogeneous domain logic graph, reference logic nodes whose cosine similarity to the feature vector of the meta-functional unit is greater than a preset threshold are retrieved to obtain a set of candidate reference nodes. Calculate the shortest graph topology path between the metafunctional unit and each reference logical node in the candidate reference node set in the heterogeneous domain logic graph; The isomorphism score is calculated based on the cosine similarity and the shortest path in the graph topology, and a cross-domain logical mapping table is generated based on the isomorphism score. Based on the meta-functional unit dependency graph and the cross-domain logical mapping table, each meta-functional unit in the meta-functional unit set is matched with corresponding execution resources and virtual execution agents to generate a resource scheduling plan containing resource configuration information and agent allocation information. According to the resource scheduling plan, the multimodal generation model is invoked to generate multimodal interactive content data corresponding to the set of meta-functional units.

2. The method according to claim 1, characterized in that, The calculation of the isomorphism score based on the cosine similarity and the shortest path in the graph topology specifically includes: Extract the set of input parameter types and the set of output parameter types of the meta-functional unit, and combine the set of input parameter types and the set of output parameter types to define the data constraint attribute of the meta-functional unit; Traverse the candidate reference node set and filter out nodes whose input / output attributes are consistent with the data constraint attributes as valid reference sets; Determine the task start node of the meta-functional unit dependency graph and the domain root node of the heterogeneous domain logic graph; Calculate the first shortest path length from the meta-functional unit to the task start node, and the second shortest path length from each node in the valid reference set to the domain root node; A position deviation coefficient is generated based on the absolute value of the difference between the first shortest path length and the second shortest path length. The cosine similarity is corrected using the positional deviation coefficient to obtain the isomorphism score.

3. The method according to claim 1, characterized in that, The step of matching corresponding execution resources and virtual execution agents for each meta-functional unit in the meta-functional unit set based on the meta-functional unit dependency graph and the cross-domain logical mapping table to generate a resource scheduling plan containing resource configuration information and agent allocation information specifically includes: The topological structure of the meta-functional unit dependency graph is parsed, and a topological execution sequence of the meta-functional unit set is generated based on the topological structure. Traverse the topology execution sequence, determine the target logical node corresponding to each of the meta-functional units according to the cross-domain logical mapping table, and extract the resource feature tags of the target logical nodes; In the pre-set virtual execution agent pool, a target virtual execution agent that matches the resource feature tag is identified, and a mapping and binding relationship between the meta-functional unit and the target virtual execution agent is established; The computing power and storage space required by the target virtual execution agent are quantified based on the resource feature tags. Resource configuration information is generated based on the computing power and the storage space. The mapping binding relationship is encapsulated into proxy allocation information and aggregated with the resource configuration information to obtain a resource scheduling plan.

4. The method according to claim 1, characterized in that, After generating multimodal interaction content data corresponding to the set of meta-functional units by calling the multimodal generation model according to the resource scheduling plan, the method further includes: The multimodal interaction content data is parsed to extract the actual execution results of the contained actions and information; Based on the actual execution results and the structured requirement description data, calculate the task fidelity score; If it is determined that the task fidelity score is lower than a preset fidelity threshold, a target meta-functional unit is determined that causes the task fidelity score to be lower than the preset fidelity threshold. In the cross-domain logic mapping table, the isomorphism score of the reference logic node currently associated with the target element functional unit is reduced by a preset ratio to obtain an updated cross-domain logic mapping table. Based on the updated cross-domain logical mapping table, a target reference logical node is determined for the target meta-functional unit. The target reference logical node is the reference logical node with the highest isomorphism score that has not been selected before. Based on the target reference logical node, a revised resource scheduling plan is generated; According to the revised resource scheduling plan, the multimodal generation model is invoked to generate revised multimodal interaction content data corresponding to the set of meta-functional units.

5. The method according to claim 4, characterized in that, The calculation of the task fidelity score based on the actual execution results and the structured requirement description data specifically includes: From the structured requirement description data, expected functional points are extracted according to preset parsing rules. The expected functional points include functional identifiers and expected parameters. All the expected functional points constitute an expected functional point set. From the actual execution results, actual functional points corresponding to each actual executed action are extracted according to the preset parsing rules. The actual functional points include functional identifiers and actual parameters. All the actual functional points constitute an actual functional point set. The actual function point set is compared with the expected function point set to determine the hit function point corresponding to the function identifier, the missing function point that exists in the expected function point set but not in the actual function point set, and the redundant function point that exists in the actual function point set but not in the expected function point set. Based on a preset scoring function, the task fidelity score is calculated by combining the number of hit function points, missing function points, and redundant function points.

6. The method according to claim 4, characterized in that, In the cross-domain logical mapping table, the isomorphism score of the reference logical node currently associated with the target functional unit is reduced by a preset ratio to obtain an updated cross-domain logical mapping table, specifically including: Attribution analysis is performed on the deviation between the actual execution result of the target functional unit and the structured requirement description data to determine the failure attribution identifier, which is a preset classification code; Update the global attribution knowledge base based on the failure attribution identifier and the reference logical node currently associated with the target element functional unit; From the global attribution knowledge base, other reference logical nodes besides the currently associated reference logical node that have an association strength with the failure attribution identifier higher than a preset association threshold are identified to obtain a high-risk node set. The isomorphism score of the reference logical node currently associated with the target functional unit in the cross-domain logical mapping table is reduced by a first preset ratio; the isomorphism score of each reference logical node in the high-risk node set in the cross-domain logical mapping table is reduced by a second preset ratio to obtain an updated cross-domain logical mapping table, wherein the preset ratio includes the first preset ratio and the second preset ratio.

7. The method according to claim 5 or 6, characterized in that, The attribution analysis of the deviation between the actual execution result of the target functional unit and the structured requirement description data, and the determination of failure attribution identifiers, specifically includes: Based on the actual execution results and the structured requirement description data, the deviation features constituting the deviation are determined. The deviation features include missing function points, redundant function points, and parameter deviation function points determined based on the hit function points. The missing function points, the redundant function points, and the parameter deviation function points are used as a combination of deviation features, and the failure attribution identifier corresponding to the combination of deviation features is determined in the preset attribution rule base.

8. A cross-disciplinary skill decoupling and meta-capability unit intelligent scheduling system, characterized in that, The system includes: One or more processors and a memory; the memory is coupled to the one or more processors, the memory being used to store computer program code, the computer program code including computer instructions, the one or more processors invoking the computer instructions to cause the system to perform the method as described in any one of claims 1-7.

9. A computer-readable storage medium comprising instructions, characterized in that, When the instructions are executed on the system, the system performs the method as described in any one of claims 1-7.

10. A computer program product, characterized in that, When the computer program product is run on the system, the system performs the method as described in any one of claims 1-7.

Images