Large model data governance method based on expert agent

Abstract

The invention relates to the technical field of data processing and artificial intelligence, and discloses an expert agent-based large model data governance method, which comprises the following steps of: querying a dynamic expert agent capability map, and evaluating performance, cost and quality indexes of candidate agents by utilizing a multi-objective optimization strategy so as to determine an execution unit. The execution unit processes the task and generates a structured result including the confidence score and the attribution path. And then, the system performs conflict detection on a multi-source result, triggers a hierarchical intelligent arbitration mechanism including confidence comparison, heuristic rule reasoning and secondary challenge for detected conflicts to determine an effective conclusion, and generates a final result in combination with a decision fusion algorithm. According to the method, dynamic scheduling of governance resources is achieved, decision transparency is guaranteed through an attribution path, self-adaptive evolution of the system is achieved through a feedback closed loop, and the precision and efficiency of data governance are remarkably improved.

Description

Technical Field

[0001] This invention relates to the fields of data processing and artificial intelligence technology, specifically to a method for large-scale model data governance based on expert intelligent agents. Background Technology

[0002] With the deepening of digital transformation, data has become a core asset for enterprises, and data quality directly determines the effectiveness of downstream business analysis and decision-making. Traditional data governance methods mostly rely on predefined rule bases, regular expressions, or fixed ETL scripts. While these methods have deterministic logic when processing structured data, they often exhibit limitations such as insufficient flexibility, high rule maintenance costs, and weak generalization ability when dealing with unstructured text, multimodal data, or semantically complex dirty data.

[0003] In recent years, the emergence of large-scale language models has provided a new technological path for data governance. Large models possess powerful semantic understanding and generation capabilities, enabling them to handle fuzzy matching and logical inference tasks that traditional rules struggle to cover. However, in practical engineering applications, directly relying on a single, general-purpose language model to perform end-to-end data governance tasks still presents many challenges. While general-purpose large models have broad knowledge coverage, their expertise in specific vertical domains often falls short of dedicated models or targeted rule engines, making them prone to content fabrication or logical inconsistencies, and failing to meet the stringent accuracy requirements of industrial-grade data governance.

[0004] Furthermore, existing large-scale model application architectures typically employ static task orchestration, lacking dynamic evaluation mechanisms for computational resources and governance costs. Regardless of task difficulty, they invariably call upon models of the same scale, leading to wasted computational resources or response delays. Simultaneously, existing governance systems lack effective multi-source verification and conflict arbitration mechanisms when facing uncertainties in model outputs, making it difficult to determine the reliability of model outputs. More critically, most model-based governance systems lack interpretable attribution capabilities and adaptive feedback evolution mechanisms. Users struggle to trace the basis for erroneous data assessments, and the system cannot utilize historical governance data to automatically optimize subsequent task assignment strategies, resulting in long-term performance bottlenecks. Summary of the Invention

[0005] To address the shortcomings of existing technologies, this invention provides a large-scale model data governance method based on expert intelligent agents. This method solves the problems of insufficient accuracy of single-model processing, lack of dynamic optimization of resource scheduling, and lack of interpretability and adaptive evolution capability of the governance process when dealing with complex heterogeneous data.

[0006] To achieve the above objectives, the present invention provides the following technical solution: a large model data governance method based on expert intelligent agents, comprising the following steps:

[0007] S1: The central coordinator queries the dynamic expert agent capability graph based on the characteristics of the received data governance sub-tasks to obtain candidate expert agents and their dynamic attributes.

[0008] S2: Execute a multi-objective optimization-based agent selection strategy to evaluate the dynamic attributes of the candidate expert agents, thereby determining one or more execution units;

[0009] S3: The execution unit uses its internal decision core module to process the data governance sub-task and generate structured results; the structured results include core processing conclusions, confidence scores, and attribution paths;

[0010] S4: Perform conflict detection on multiple structured results for the same data governance subtask; if a conflict is detected, trigger a hierarchical intelligent arbitration mechanism to determine a valid conclusion; if no conflict is detected or arbitration has been completed, execute a decision fusion algorithm to generate the final governance result.

[0011] S5: Based on the comparison between the final governance result and the structured results of each execution unit, generate a governance process log, and use the governance process log to update the dynamic attributes in the dynamic expert agent capability graph.

[0012] Preferably, in S1, the dynamic attributes include at least performance indicators, cost indicators, and quality indicators; the updating of the dynamic attributes in the dynamic expert agent capability map specifically includes:

[0013] The dynamic attributes are updated based on an exponentially weighted moving average algorithm; wherein, the quality index is updated by calculating using the quality score of the previous time step, the reward value obtained in the current time step, and a preset decay factor; the reward value is determined based on the win or loss status of the structured result of the execution unit in the hierarchical intelligent arbitration mechanism or its consistency with the final governance result.

[0014] Preferably, in S2, the agent selection strategy based on multi-objective optimization specifically includes:

[0015] The dynamic attributes of the candidate expert agents are normalized; wherein, for benefit-type attributes, a maximum-minimum normalization mapping is used, and for cost-type attributes, inverse normalization or reciprocal transformation is used; the comprehensive score of each candidate expert agent is calculated according to the preset preference weights; based on the comprehensive score, a single optimal expert agent is selected as the sole execution unit, or multiple expert agents with comprehensive scores higher than a preset threshold are selected as a common execution unit to form a redundant execution environment.

[0016] Preferably, in S3, the calculation logic for the confidence score is determined based on the technology type of the decision core module:

[0017] If the decision core module is a probability-based machine learning model, the confidence score is taken from the class probability value of the model output layer or the statistical average of the probabilities of each word in the sequence label; if the decision core module is a rule-based inference engine, the confidence score is a static weight preset when the rule is defined; if the decision core module is a script program that executes specific logic, the confidence score is dynamically calculated based on the number of verification checkpoints passed during script execution.

[0018] Preferably, in S3, the attribution path is a structured data object used to record the decision basis for the core processing conclusion; the attribution path includes: a unique identifier of the expert agent performing the task, the version number of the core decision module, the original data fragment used as the decision basis, and a decision logic identifier; wherein, the decision logic identifier corresponds to the feature dimension that contributes the most in the machine learning model, the specific rule ID triggered in the rule inference engine, or the logical branch identifier executed in the script program.

[0019] Preferably, in S4, the collision detection specifically includes:

[0020] The structured results are grouped according to the unique identifier of the processed data item; a value consistency comparison is performed on the results within the group to check whether the value or label of the core processing conclusion is equal; a boundary consistency comparison is performed on the results within the group to check whether the position range of the core processing conclusion in the original data overlaps but does not completely coincide; if any of the above inconsistencies are detected, a conflict is determined to exist.

[0021] Preferably, in S4, the hierarchical intelligent arbitration mechanism includes the following levels in sequence:

[0022] Level 1 arbitration: Calculate the difference in confidence scores between the conflicting parties. If the difference between the highest confidence score and the second highest confidence score exceeds a preset significance threshold, the conclusion of the highest confidence score is deemed valid.

[0023] Second-level arbitration: If the first-level arbitration is unresolved, the attribution paths of the conflicting parties are analyzed, and predefined heuristic rules are applied to make a ruling; the heuristic rules include prioritizing the conclusions generated by the deterministic rule engine over those generated by the probabilistic model;

[0024] Third-level arbitration: If the second-level arbitration is unresolved, a second-level inquiry task is constructed, which combines the original data, the conclusions of the conflicting parties and their attribution paths into a prompt message and sends it to the pre-set advanced arbitration agent to obtain the final ruling.

[0025] Preferably, in S4, the decision fusion algorithm specifically includes:

[0026] When the core processing conclusion is a numerical or probability vector, a weighted model averaging algorithm is used to calculate the final governance result. The fusion weight of each execution unit is determined based on the weighted sum of the historical quality index of the execution unit in the dynamic expert agent capability graph and the confidence score output in this task. When the final governance result is composed of multiple sub-parts, a global confidence index is calculated, which is the harmonic mean of the confidence scores of all sub-part conclusions.

[0027] Preferably, in S5, updating the dynamic expert agent capability graph using the governance process log further includes performing context-based contextualized meta-learning:

[0028] A contextual multi-armed slot machine algorithm is used to establish a mapping relationship between data features and expert agent performance. The input data feature fingerprint of the data governance subtask is used as the context vector, the candidate expert agent is used as the selectable arm, and the reward value obtained by the structured result in S4 is used as the reward. The bias weights in the dynamic expert agent capability map under specific situations are updated according to the mapping relationship.

[0029] Preferably, the method further includes constructing a data lineage topology network based on the governance process logs:

[0030] Based on the task decomposition structure and the tracking identifiers in the governance process log, reconstruct the directed acyclic graph of task execution; attach the attribution path and the arbitration metadata generated by S4 to the corresponding nodes in the directed acyclic graph; in response to a query request, traverse the directed acyclic graph backwards from the node corresponding to the final governance result to generate an evidence object containing a complete processing logic chain; or traverse the directed acyclic graph forwards from a specific expert agent node to identify downstream results influenced by that expert agent.

[0031] In summary, this application includes at least one of the following beneficial technical effects:

[0032] 1. This invention achieves dynamic and refined scheduling of governance resources by constructing a dynamic expert agent capability graph and combining it with a multi-objective optimization selection strategy. Unlike traditional static task allocation methods, this invention can comprehensively evaluate each agent based on its historical quality indicators, real-time resource consumption, and response speed. This allows it to find the optimal balance between quality, cost, and timeliness while ensuring data processing accuracy, effectively solving the problem of low efficiency or resource waste of single models when facing complex heterogeneous data governance tasks.

[0033] 2. The hierarchical intelligent arbitration mechanism based on attribution paths proposed in this invention significantly improves the accuracy and robustness of automated governance. By sequentially applying a three-level arbitration process—confidence threshold determination, heuristic rule reasoning, and advanced model secondary challenge—the system can automatically and cost-effectively resolve conflicts in multi-source conclusions, reducing reliance on manual review. Simultaneously, the structured attribution path fully records the decision-making logic and data sources, providing auditable transparency and interpretability for the data governance results.

[0034] 3. This invention utilizes feedback learning based on governance logs and a context-based multi-armed slot machine algorithm to endow the system with adaptive evolution capabilities. The system can automatically capture the nonlinear correlation between specific data features and agent performance through closed-loop feedback, and dynamically update the bias weights in the capability graph accordingly. This enables the governance system to continuously optimize the allocation strategy for specific data scenarios during long-term operation, and continuously improve the processing effect on long-tail data or difficult cases. Attached Figure Description

[0035] Figure 1 This is a flowchart of the method of the present invention;

[0036] Figure 2 This is a system architecture diagram of the present invention. Detailed Implementation

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

[0038] Example:

[0039] Please see the appendix Figure 1 -Appendix Figure 2 This invention provides a method for large model data governance based on expert intelligent agents, comprising the following steps:

[0040] S1, the system receives macro-data governance tasks through the task receiving interface, and a semantic decomposition module parses and decomposes the task into a task graph containing multiple sub-task nodes and their dependencies.

[0041] S2, the system uses the agent selection module to search and match in the pre-built expert agent capability map based on the capability requirements of each sub-task in the aforementioned task map, and assigns one or more expert agents as execution units for each sub-task.

[0042] S3, after completing the data processing, the assigned execution unit generates a structured processing result for each data item. The result includes the processing conclusion, a confidence score that quantifies the credibility of the conclusion, and an attribution path that records the basis for the decision.

[0043] S4, a central coordinator of the system, collects structured results. When its built-in conflict detection module identifies a conflict in the conclusions, the arbitration module is activated to adjudicate. Subsequently, the decision fusion module aggregates all non-conflicting or arbitration-winning conclusions to form the final authoritative governance conclusion.

[0044] S5, the logging module records the entire governance process, and the feedback learning module uses these records to optimize system strategies. Simultaneously, the traceability chain construction module establishes a complete and auditable traceability chain for this governance operation based on the final comprehensive attribution path.

[0045] Macro-level data governance tasks are received through a task receiving interface. This interface can be implemented in various forms to suit different application scenarios.

[0046] In one embodiment, the interface is a text input box in a graphical user interface through which users can submit governance instructions in natural language.

[0047] Regardless of the interface used to receive the data, the content of macro-level data governance tasks can be unstructured natural language text, or semi-structured or structured data that follows a specific pattern.

[0048] A task preprocessing module processes the received macro-level data governance tasks to generate a standardized formal task object. This preprocessing module is a component of the semantic decomposition module. This formal task object provides a unified, machine-readable input for subsequent task decomposition steps.

[0049] Formal task object, denoted as Its data structure can be defined as:

[0050] ;

[0051] in:

[0052] This represents a unique identifier generated for this task.

[0053] It stores the raw task description received from the task receiving interface, whether it is a text string or a JSON object.

[0054] It is a data source descriptor used to specify the location and access method of the data to be processed in this governance task, such as a database connection string, file system path, or cloud storage Uniform Resource Identifier.

[0055] It is a set of high-level governance objectives initially extracted from the original task description, and its form is as follows: Each element It is a label that represents a specific governance intention.

[0056] It contains metadata related to the task, such as the task submission time and the identity of the submitting user.

[0057] When the received raw task is natural language, the task preprocessing module uses natural language processing techniques to fill in the blanks. The field.

[0058] Specifically, this module can use an intent recognition model to extract the set of governance objectives. It employs a named entity recognition model to identify data source identifiers. For the specific implementation of the intent recognition and named entity recognition model.

[0059] When the received raw task is predefined structured data, the task preprocessing module performs data validation and mapping operations, that is, checks whether the format and fields of the input data conform to the specifications, and accurately maps its field content to the formalized task object. In the corresponding attributes.

[0060] The system will uniformly convert user input from different channels and in different forms into formalized task objects with a consistent structure. This laid the foundation for subsequent, more complex semantic decomposition processes.

[0061] The semantic decomposition module transforms the standardized formalized task objects generated in the preceding steps into a structured task graph. This task graph provides precise, machine-readable instructions for subsequent agent selection and allocation (S2).

[0062] In one embodiment, the core of the semantic decomposition module is a large language model. This large language model can be a pre-trained language model based on a transformer architecture. To improve the accuracy of task decomposition and the ability to understand domain-specific terms, this large language model can be fine-tuned on a specific instruction dataset. The instruction dataset contains multiple sets of paired samples, each sample consisting of a simulated data governance task description and a corresponding standard task graph predefined by domain experts.

[0063] During execution, the semantic decomposition module first dynamically constructs structured hints based on the formalized task object. These hints are then provided as input to the large language model. The hint construction process specifically includes:

[0064] The original task description and the initially extracted governance objectives in the formalized task object are combined into the task description part in the prompt.

[0065] The instruction and constraint section is generated and merged with the task description section to form a complete prompt. This instruction and constraint section provides the necessary contextual information to the large language model to ensure the standardization and accuracy of its output.

[0066] The semantic decomposition module sends the completed prompts to a large language model for processing via a network interface and receives the text response returned by the model.

[0067] This module further includes an output parser that processes the received text response. The system transforms the high-level task description into a precise, machine-executable task graph containing multiple specific operational steps and their interdependencies, providing structured input for subsequent steps.

[0068] Based on the output of the aforementioned large-scale language model, a structured task graph is generated. This task graph is a directed acyclic graph that precisely describes, in a machine-readable manner, a series of sub-tasks required to complete macro-level data governance tasks and their inter-task dependencies.

[0069] In one embodiment, the task graph consists of a set of subtask nodes and a set of edges that define the relationships between these nodes.

[0070] Each subtask node in the task graph contains a set of predefined attributes that fully describe an atomic data processing operation.

[0071] The edges in the task graph define the execution order and data flow relationships between subtask nodes. An edge from subtask node A to subtask node B indicates that the execution of B depends on the successful execution of A, and that some or all of B's ​​input parameters come from A's output parameters. This directed edge design ensures the correctness of the task flow.

[0072] In one embodiment, each expert agent is an independently deployable and executable software entity. To enable the central coordinator to recognize, understand, and invoke these expert agents, each agent is configured to execute a registration process during system initialization or its own startup. The core of this registration process is submitting a standardized capability description file to the central coordinator. This capability description file, in a machine-readable format, fully characterizes the expert agent's identity, functions, and invocation method.

[0073] Through the aforementioned capability representation and registration mechanism, the method of this invention ensures that the central coordinator can grasp the capability list of all available expert agents in the system and their invocation methods in real time and accurately, laying the foundation for subsequent dynamic and efficient task allocation.

[0074] In the selection and allocation of expert agents (S2), a key component is the construction and querying of the expert agent capability graph. This capability graph is the core data structure for the central coordinator to make task allocation decisions.

[0075] The initial construction of this capability graph was based on the aforementioned agent registration mechanism. Once an expert agent successfully registers, the information in its capability description file is parsed and stored in the capability graph.

[0076] In one embodiment, the capability graph can be implemented as a knowledge graph. In this knowledge graph, expert agents and capability tags are both represented as nodes, while the relationship between an agent and its capability tags is represented as edges.

[0077] The core characteristic of a capability graph lies in its dynamic nature, which is reflected in the nodes or edges of the graph. In addition to storing static capability attribution relationships, these dynamic attributes quantify the historical performance of expert agents when performing specific capabilities.

[0078] The updating of dynamic attributes is implemented in the feedback learning and traceability construction S5. After each complete governance task is completed, the logging module collects the actual performance data of each expert agent during the task execution process. The feedback learning module then processes this data and updates the dynamic attributes of the corresponding agents and capability nodes in the capability graph.

[0079] During the selection and allocation of expert agents (S2), the agent selection module queries the capability graph. The input to the query is the capability requirement label defined by a subtask node in the task graph. After receiving the query request, the capability graph first retrieves all expert agent nodes that possess that capability label, forming an initial candidate set.

[0080] Subsequently, for each agent in the candidate set, the query process further extracts its associated dynamic attributes. Ultimately, the query operation returns not a simple list of agents, but a rich set of information containing each candidate agent and its multi-dimensional dynamic performance metrics. This set provides the basis for subsequent agent selection strategies.

[0081] Through this dynamic capability graph construction and query mechanism, this method enables task allocation decisions to no longer be based solely on static capability matching, but to comprehensively consider the historical performance of each candidate agent, thus laying a data foundation for achieving more efficient and higher-quality agent selection.

[0082] After querying the expert agent capability graph and obtaining candidate agents and their dynamic attributes, the selection and allocation of expert agents S2 is further carried out by the agent selection module to execute a selection strategy to determine one or more final execution units from the candidate set.

[0083] In one embodiment, the selection strategy is implemented as a multi-objective optimization process that aims to achieve a balance among multiple conflicting optimization objectives based on preset preferences.

[0084] This multi-objective optimization process may specifically include the following steps:

[0085] First, the dynamic attributes of each candidate agent obtained from the capability map are normalized. Since different dynamic attributes have different dimensions and numerical ranges, direct comparison is inappropriate. Therefore, the agent selection module needs to convert these raw index values ​​into uniform, dimensionless scores.

[0086] Next, a comprehensive score is calculated for each candidate agent. This comprehensive score is a weighted sum of its normalized scores. The weights are pre-configured at the system level to reflect the degree of preference of the current data governance task for different optimization objectives.

[0087] After calculating the overall score of all candidate agents, the agent selection module makes the final decision based on the score.

[0088] The selection mode and the weight of the optimization target can both be configured parameters and specified when initiating a macro-level data governance task, thus enabling this method to flexibly adapt to the specific needs of different types of data governance tasks.

[0089] S3 is performed by the assigned execution units, namely expert agents. To ensure that different types of expert agents within the system can work together and output standardized results, each expert agent follows a common internal architecture.

[0090] In one embodiment, the general internal architecture of an expert agent may include the following modules: a task receiving and parsing module, a decision core module, a structured result generation module, and a communication interface module.

[0091] The communication interface module is responsible for network communication between the expert agent and external systems, particularly the central coordinator. It receives task allocation instructions from the central coordinator and sends the final structured results back to the central coordinator. This module can be implemented based on standard network communication protocols such as HTTP or RPC.

[0092] The task receiving and parsing module is connected to the communication interface module and is responsible for processing the received raw task instructions and data. This module parses the task description and data payload sent by the central coordinator into an internal data format that the decision core module can understand and process.

[0093] The decision-making core module is the core computing unit for expert intelligent agents to execute their professional capabilities. Depending on its specific functional positioning, this module can be implemented in a variety of different technical ways.

[0094] In one embodiment, when the expert agent is an agent for entity recognition or text classification, its decision core module can be a pre-trained machine learning model.

[0095] In another embodiment, when the expert agent is used for data validation or specific pattern matching, its decision core module can be a rule-based inference engine. The structured result generation module receives the raw processing results from the decision core module. The raw processing results are unencapsulated direct conclusions. The core responsibility of this module is to encapsulate these raw results into standardized structured results containing three key parts for use by subsequent collaborative arbitration S4.

[0096] In the structured results generation module, a key step in encapsulating the core processing conclusions is calculating their confidence scores. These confidence scores are standardized values, typically within a closed interval of 0 to 1, used to quantify the degree of certainty the expert agent has regarding its output conclusions. The calculation principle of this score is directly related to the specific technical implementation of the agent's core decision-making module.

[0097] In one embodiment, when the core decision-making module is a machine learning model, the calculation of the confidence score is related to the design of its output layer. If the model is used to perform a classification task, its output layer is typically a softmax layer, which outputs a probability distribution for all candidate categories. In this case, the confidence score is set as the probability value corresponding to the category selected by the model. If the model is used for sequence labeling tasks such as named entity recognition, for a recognized entity composed of multiple tokens, its confidence score can be calculated by aggregating the predicted probabilities of all tokens within the entity.

[0098] In another embodiment, when the decision core module is a rule-based inference engine, the generation of confidence scores depends on the design of the rules themselves. One implementation is to pre-assign a static confidence value to each rule in the rule base. This value is set by domain experts based on the reliability and specificity of the rule.

[0099] By designing corresponding confidence calculation principles for expert agents with different technical cores, the method of this invention ensures that the conclusions output by all execution units have a unified and quantifiable reliability metric, which provides a key input basis for subsequent collaborative arbitration and decision fusion S4.

[0100] When encapsulating core processing conclusions, a key step in the structured results generation module is generating attribution paths. These attribution paths are structured data objects designed to record the key evidence and logic leading to the conclusions, providing transparent and auditable evidence for subsequent collaborative arbitration, decision fusion, and the traceability of the final governance process.

[0101] In this embodiment, the data structure of the attribution path includes the following information:

[0102] The unique identifier of the expert agent executing this subtask; the version number of the decision core module used by the agent during execution; a fragment of raw data that serves as the key basis for the decision; and a code or text describing the reasoning logic of the decision.

[0103] The generation mechanism of attribution paths is similar to the calculation principle of confidence scores, and both are closely related to the specific technical implementation of the decision-making core module of the expert agent.

[0104] By designing corresponding attribution path generation mechanisms for each type of expert agent, the method of this invention ensures that every processing conclusion not only has its result, but also its detailed "origin." This attribution path, which includes detailed decision-making basis, is the foundation for subsequent advanced functions, especially for in-depth analysis and intelligent arbitration when multi-agent conclusions conflict.

[0105] In one embodiment, the implementation principle of the collision detection module may include the following steps:

[0106] All collected structured results are grouped. This grouping operation uses the unique identifier of the original data item processed by these results as the key. The specific form of the unique identifier depends on the type of data governance task. Through this grouping operation, all processing conclusions for the same data point or data segment are grouped into the same group.

[0107] For groups with more than one member, an internal consistency check is performed. If a group contains only one structured result, it is assumed to be conflict-free. For groups containing multiple structured results, this module performs a comparison operation to determine if conflicts exist. This comparison operation can include the following two types:

[0108] The conclusion conflict detection module compares multiple conclusion values ​​within a group. If at least two different conclusion values ​​exist within a group, the group is determined to have a conclusion conflict.

[0109] Boundary conflict detection is mainly applied to entity recognition tasks. In such tasks, the conclusion includes not only the type of the entity but also its location range in the original data. When comparing, this module not only checks whether the entity types are consistent but also checks the location range of the identified entities in the original data. If the location ranges of two entities overlap but are not completely the same, they are also judged to be in conflict.

[0110] When the conflict detection module determines that a group has a conflict, it marks the group and all its structured results as a conflict group and submits it to the arbitration module for further adjudication. For groups that are not marked as conflicting, their conclusions are directly sent to the decision fusion module for aggregation.

[0111] After the conflict detection module marks and submits the conflict group, the conflict group will be processed by the arbitration module.

[0112] In one embodiment, the arbitration module employs a tiered intelligent arbitration mechanism to resolve conflicts between conclusions in a progressive manner, from low to high cost and from simple to complex. This mechanism may specifically include the following progressive arbitration levels:

[0113] The core basis of this level of arbitration is the confidence score of different conclusions. The arbitration module first compares the confidence scores of all structured results within the conflict group. If the confidence score of one conclusion is significantly higher than all other conclusions, this arbitration level directly rules that conclusion is in favor. A significantly higher confidence score can be determined by calculating the difference between the maximum and second-highest confidence scores and determining whether this difference exceeds a preset first-level arbitration threshold. If the conclusion with the highest confidence score is close to the scores of other conclusions, i.e., the difference does not exceed the threshold, a decision cannot be made solely based on confidence score, and the arbitration process proceeds to the next level.

[0114] When the first-level arbitration fails to resolve the conflict, the arbitration module will further analyze the attribution paths of each conflict conclusion, conducting in-depth analytical reasoning. This analysis process is based on a set of predefined heuristic rules used to assess the inherent reliability of different decision-making logics. When all the aforementioned internal arbitration methods fail to resolve the conflict, the arbitration module will initiate a secondary inquiry process. This process proactively obtains new information needed to resolve the conflict by dynamically generating and assigning a new, higher-level subtask, namely the secondary inquiry task.

[0115] The generation of this secondary challenge task is not a simple repetition, but rather takes existing conflict information as its input. Specifically, the input of this task will include the original data fragments, all conflicting conclusions, and their respective complete attribution paths. This secondary challenge task can be assigned to a specific, pre-defined arbitral agent.

[0116] Through the aforementioned hierarchical and progressive intelligent arbitration mechanism, the method of this invention can achieve a balance between efficiency and effectiveness, resolve most conflicts at the lowest cost, and provide a reliable escalation solution path for difficult conflicts.

[0117] After the arbitration module completes its ruling on the conflict group, or for those result groups for which no conflict was initially detected, the process proceeds to the latter half of S4, namely the decision fusion and result construction process executed by the decision fusion module.

[0118] The decision fusion module receives a set of conflict-free results from the conflict detection module and a set of adjudicated results from the arbitration module. At this point, for each original data item or subtask node, a unique and definite processing conclusion exists in the system.

[0119] When the processing conclusion is numerical data or a probability distribution, the decision fusion module uses a weighted average algorithm to calculate the final fusion result.

[0120] In one embodiment, the final fusion result The calculation formula is as follows:

[0121] ;

[0122] in:

[0123] This represents the total number of execution units that provide valid conclusions for the current data item.

[0124] Indicates the first The numerical result or probability vector output by each execution unit.

[0125] Indicates the first The fusion weight of each execution unit.

[0126] Fusion weights The determination of is not a simple arithmetic average, but rather dynamically calculated based on the dynamic attributes stored in the expert agent's capability graph. Specifically, The calculation takes into account the agent's historical quality metrics. And the confidence score of the output of this execution Its calculation formula can be defined as:

[0127] ;

[0128] in, It is a preset balance coefficient (0≤ ≤1), used to adjust the relative importance of historical performance and current confidence in weight calculation. Through this algorithm, the system can automatically give greater weight to agents with more robust historical performance and higher current confidence, thereby improving the accuracy of the fusion results.

[0129] When the processing result is a non-numerical structured object, the decision fusion module performs a set union operation.

[0130] To ensure end users understand the reliability of the overall governance outcome, the decision fusion module needs to calculate a global confidence score. .

[0131] In one embodiment, if the final result is composed of multiple independent sub-parts... Defined as the harmonic mean of the confidence levels of all sub-conclusions, it reflects the weakest link effect, meaning that the overall reliability is limited by the least reliable component. Its calculation formula is as follows:

[0132] ;

[0133] in:

[0134] It is the number of independent conclusion fragments that make up the final result.

[0135] It is the first The final confidence score of each conclusion fragment.

[0136] Finally, the decision fusion module serializes the constructed internal object, which includes fused data content, global confidence, and aggregated attribution path information, into the format specified by the user in the macro-governance task, and returns it to the user through the system interface, thereby completing the entire closed-loop data governance process.

[0137] This field is used to uniquely identify and locate a specific instance of governance task execution. Specifically, it includes: a global tracking identifier, generated by the system upon receiving a macro-level task request, which runs through the execution process of all subtasks decomposed from the task and is used to associate log fragments scattered across different execution units; a task node identifier, corresponding to a specific subtask node in the task graph; and a pair of timestamps, recording the precise start and finish times of the subtask, with a time accuracy of at least milliseconds.

[0138] The execution unit instance information field records in detail the identity and status of the expert agent that actually executes the subtask. Specifically, it includes: a unique agent identifier, corresponding to the ID in the expert agent capability graph; an agent version number, used to trace the specific iteration version of the model or rule base; and resource consumption records. The resource consumption records quantify the computational cost of this execution, including but not limited to CPU time, peak memory usage, and the number of API call billing units. This quantified data is the direct data source for subsequently updating the dynamic cost attributes in the capability graph.

[0139] This field is the persistent storage form of the attribution path generated by S3 mentioned above. It not only records the final output of the agent, but also fully preserves the logical basis for generating that result.

[0140] This field is specifically used to record processing details of subtasks involving multi-agent collaboration. This applies when the subtask involves multiple execution units.

[0141] The feedback learning module periodically or triggered by specific events reads governance process logs from the log store. For learning to occur, the system first needs to determine the correctness of the result of each subtask execution. In one embodiment of the invention, the system employs a weak supervision mechanism based on arbitration results to automatically generate labels without relying on large-scale manual annotation.

[0142] Based on the generated supervision signal, the feedback learning module iteratively updates the performance indicators of each agent node in the capability graph. In order to adapt to the dynamic changes in the system environment, this invention adopts an update strategy based on exponential weighted moving average, rather than simple arithmetic accumulation.

[0143] In this strategy, for any expert agent Its time step Quality rating The update logic is as follows: The system updates the quality score from the previous time step. Multiply by a decay factor Then add the reward value obtained at the current time step. Multiply by the learning rate This computational logic ensures that the system can both retain long-term historical reputation evaluations and quickly respond to recent performance fluctuations of agents. If an agent repeatedly produces erroneous results that are rejected by the arbitration module, its quality score will drop rapidly, leading to a decrease in its probability of being selected in subsequent multi-objective optimization selection strategies.

[0144] Similarly, the system also uses a similar smooth update logic to record cost-related indicators such as execution time and resource consumption. This allows the capability graph to accurately reflect the agent's true response capability under the current load and network environment, avoiding evaluation bias caused by a single network jitter.

[0145] In addition to updating the global scoring metrics, the feedback learning module of this invention performs context-based meta-learning by analyzing global context information in logs and feature fingerprints of input data to learn the context-dependent nature of the agent's capabilities.

[0146] The system maintains a feature vector on the edge attributes of the capability graph, which maps the correlation between specific task types or data features and agent performance. The module uses machine learning algorithms to update this correlation. Specifically, the system identifies key data features that lead to excellent or poor performance by a particular agent.

[0147] The feedback learning module is also responsible for evaluating and optimizing the heuristic rules of the arbitration module. The system statistically analyzes the success rate of different arbitration rules in actual operation. If log data shows that a ruling based on a specific heuristic rule is frequently corrected by human feedback in subsequent steps, the system will automatically lower the priority of that rule or mark it as awaiting human review, thereby achieving the self-evolution of the arbitration logic.

[0148] Through the aforementioned log-based meta-learning mechanism, the scheduling strategy for expert agents can be continuously refined as the number of governance tasks increases, thereby continuously improving the accuracy and efficiency of governance without frequent manual intervention in the code. The specific mathematical derivation and parameter settings of the exponentially weighted moving average calculation and contextual multi-armed slot machine algorithm mentioned above are conventional techniques in the fields of statistics and machine learning, and can be implemented by those skilled in the art based on the logic disclosed in this specification, and will not be elaborated here.

[0149] Based on the generated standardized governance process logs, an end-to-end traceability chain is constructed, and a query mechanism based on this chain is implemented. This mechanism aims to transform discrete log records into a data lineage and decision-making basis chain that users can intuitively understand.

[0150] The lineage construction module in the system reads all log entries containing the same global tracking identifier. Since tasks in S1 are decomposed into a task graph with a directed acyclic graph structure, the lineage construction module reconstructs the actual execution path of this macro-governance task based on the task node identifiers and input / output data characteristics in the logs.

[0151] During this process, the lineage construction module instantiates a lineage graph in memory or a graph database. In this graph, each node represents a specific execution unit instance, corresponding to the execution unit instance information field in the log. Directed edges in the graph represent data flow relationships, i.e., the output of the predecessor node serves as the input of the successor node. Unlike the static task graph, this lineage graph is instantiated; it only contains paths that have actually been executed. For conflict conclusions that have been adjudicated by the arbitration module but not adopted, the system treats them as ghost branches, attaching them as dashed lines next to the main path for audit reference only, and not as valid data flow paths.

[0152] The system incorporates decision attribution and arbitration logic. Based on the constructed lineage graph, the system mounts recorded decision attribution snapshots and collaborative arbitration metadata to the corresponding graph nodes. This means that each node in the graph not only records how data flows but also encapsulates how the data is processed at that node and why that result occurs.

[0153] Specifically, for each leaf node, the system uses the attribution path data generated in S3 as the node's detailed attributes. For the convergence node, the system uses the conflict detection results, the confidence comparison of each branch, and the final decision reason as the node's attributes. This design achieves full-granularity coverage from macroscopic processes to microscopic atomic operations.

[0154] To perform source tracing and root cause analysis, the system provides a query interface that allows users or upper-layer applications to perform source tracing operations based on the kinship map. This operation supports two main query modes:

[0155] The first approach is the reverse root cause tracing mode. When a user questions a particular item in the governance results, the user submits a unique identifier for that result data. The query engine first locates the output node that produced the result at the end of the lineage graph, and then recursively traverses along the reverse direction of the directed edges. During the traversal, the query engine collects the decision attribution attributes of all nodes along the path. Finally, the system returns a structured chain of evidence object. This object is arranged in reverse chronological order, showing the complete transformation process from the final result back to the original input data, and highlights the key decision points.

[0156] The second approach is the positive impact analysis mode. This mode can be used when a system administrator plans to modify the rule base of an expert agent or replace a model version. The query engine retrieves all nodes containing the identifier of that specific agent in the historical lineage graph and traverses all its successor nodes along the positive direction of the directed edges. The system then compiles and returns a list of all final output results affected by that agent. This allows operations personnel to assess the potential impact of rule modifications on historical data governance conclusions before actual deployment changes.

[0157] For the storage and retrieval of the aforementioned graph, this embodiment can employ a graph database system that supports attribute graph models, utilizing its native graph traversal algorithm to efficiently perform pathfinding operations. For embodiments lacking a graph database environment, equivalent logical functions can be achieved using recursive common table expressions from relational databases or by constructing an adjacency list structure using a hash table at the application layer.

Claims

1. A method for governing large model data based on expert intelligent agents, characterized in that, Includes the following steps: S1: The central coordinator queries the dynamic expert agent capability graph based on the characteristics of the received data governance sub-tasks to obtain candidate expert agents and their dynamic attributes. S2: Execute a multi-objective optimization-based agent selection strategy to evaluate the dynamic attributes of the candidate expert agents, thereby determining one or more execution units; S3: The execution unit uses its internal decision core module to process the data governance sub-task and generate structured results; The structured results include core processing conclusions, confidence scores, and attribution paths; S4: Perform conflict detection on multiple structured results for the same data governance subtask; If a conflict is detected, a tiered intelligent arbitration mechanism is triggered to determine a valid conclusion. If no conflict is detected or arbitration has been completed, the decision fusion algorithm is executed to generate the final governance outcome; S5: Based on the comparison between the final governance result and the structured results of each execution unit, generate a governance process log, and use the governance process log to update the dynamic attributes in the dynamic expert agent capability graph.

2. The method as described in claim 1, characterized in that, In S1, the dynamic attributes include at least performance indicators, cost indicators, and quality indicators; updating the dynamic attributes in the dynamic expert agent capability graph specifically includes: The dynamic attribute is updated based on the exponentially weighted moving average algorithm; The quality index update is calculated using the quality score from the previous time step, the reward value obtained in the current time step, and a preset decay factor. The reward value is determined based on the win / loss status of the structured results of the execution unit in the hierarchical intelligent arbitration mechanism or its consistency with the final governance result.

3. The method as described in claim 1, characterized in that, In S2, the agent selection strategy based on multi-objective optimization specifically includes: The dynamic attributes of the candidate expert agents are normalized; wherein, for benefit-type attributes, a maximum-minimum normalization mapping is used, and for cost-type attributes, inverse normalization or reciprocal transformation is used; the comprehensive score of each candidate expert agent is calculated according to the preset preference weights; based on the comprehensive score, a single optimal expert agent is selected as the sole execution unit, or multiple expert agents with comprehensive scores higher than a preset threshold are selected as a common execution unit to form a redundant execution environment.

4. The method as described in claim 1, characterized in that, In S3, the calculation logic for the confidence score is determined based on the technology type of the decision core module: If the decision core module is a probability-based machine learning model, the confidence score is taken from the category probability value of the model output layer or the statistical average of the probabilities of each word in the sequence label; If the decision core module is a rule-based inference engine, the confidence score is a static weight preset when the rule is defined; If the decision core module is a script program that executes specific logic, the confidence score is dynamically calculated based on the number of verification checkpoints passed during script execution.

5. The method as described in claim 1, characterized in that, In S3, the attribution path is a structured data object used to record the decision basis for the core processing conclusion; The attribution path includes: a unique identifier of the expert agent performing the task, the version number of the decision core module, the original data fragment used as the basis for decision-making, and the decision logic identifier. The decision logic identifier corresponds to the feature dimension that contributes the most in the machine learning model, the specific rule ID that is triggered in the rule inference engine, or the logical branch identifier that is executed in the script program.

6. The method as described in claim 1, characterized in that, In S4, the collision detection specifically includes: The structured results are grouped according to the unique identifier of the processed data item; Perform a value consistency comparison on the results within the group to check whether the values ​​or labels of the core processing conclusions are equal; Perform boundary consistency comparison on the results within the group to check whether there are overlapping but not completely coincident positions of the core processing conclusions in the original data. If any of the above inconsistencies are detected, a conflict is determined to exist.

7. The method as described in claim 6, characterized in that, In S4, the hierarchical intelligent arbitration mechanism includes the following levels in sequence: Level 1 arbitration: Calculate the difference in confidence scores between the conflicting parties. If the difference between the highest confidence score and the second highest confidence score exceeds a preset significance threshold, the conclusion of the highest confidence score is deemed valid. Second-level arbitration: If the first-level arbitration is unresolved, the attribution paths stated by the conflicting parties are analyzed, and predefined heuristic rules are applied to make a ruling; The heuristic rules include prioritizing conclusions generated by the deterministic rule engine over those generated by the probabilistic model; Third-level arbitration: If the second-level arbitration is unresolved, a second-level inquiry task is constructed, which combines the original data, the conclusions of the conflicting parties and their attribution paths into a prompt message and sends it to the pre-set advanced arbitration agent to obtain the final ruling.

8. The method as described in claim 1, characterized in that, In S4, the decision fusion algorithm specifically includes: When the core processing conclusion is a numerical or probability vector, the weighted model averaging algorithm is used to calculate the final governance result. The fusion weight of each execution unit is determined by the weighted sum of the historical quality index of the execution unit in the dynamic expert agent capability graph and the confidence score output in the current task. When the final governance result is composed of multiple sub-parts, a global confidence index is calculated, which is the harmonic mean of the confidence scores of all sub-part conclusions.

9. The method as described in claim 1, characterized in that, In S5, updating the dynamic expert agent capability graph using the governance process log further includes performing context-based contextualized meta-learning: A context-based multi-armed slot machine algorithm is used to establish a mapping relationship between data features and the performance of expert agents; In this context, the input data feature fingerprint of the data governance subtask is used as the context vector, the candidate expert agent is used as an optional arm, and the structured result is used as the reward value. The bias weights in the dynamic expert agent capability graph for specific scenarios are updated according to the mapping relationship.

10. The method as described in claim 1, characterized in that, The method also includes constructing a data lineage topology network based on the governance process logs: Based on the task decomposition structure and the tracking identifiers in the governance process log, reconstruct the directed acyclic graph of task execution; The attribution path and the generated arbitration metadata are attached to the corresponding nodes in the directed acyclic graph; In response to the query request, the directed acyclic graph is traversed in reverse from the node corresponding to the final governance result to generate an evidence object containing a complete processing logic chain; The directed acyclic graph is traversed in a forward direction starting from a specific expert agent node to identify downstream results influenced by that expert agent.

Images