Aigc closed-loop management method based on unified parameter model and data source audit

Abstract

The application discloses an AIGC closed-loop management method based on a unified parameter model and a data source audit, and belongs to the technical field of computers. The method comprises the following steps: firstly, AI constructs a multi-modal parameter set according to a preset scene and forms a unified parameter model; the unified parameter model is subjected to consistency verification; if the verification is passed, the content generation stage is entered; otherwise, the parameter set is regenerated; in the content generation stage, the AI gradually obtains generated content according to the parameter set and a preset data source, and synchronously records each audit item to form a complete audit tracking chain. Then, the generated content is subjected to multi-modal consistency verification, audit chain consistency verification and data source consistency verification in sequence; if all the verifications are passed, the generated content is output; if not, a management control instruction is generated, the AI regenerates the content and performs verification, until compliant content is output or the maximum number of cycles is reached. The scheme can improve the consistency, traceability and verifiability of generated AI content.

Description

Technical Field

[0001] This invention belongs to the field of computer technology, specifically relating to an AIGC closed-loop governance method based on a unified parameter model and data source auditing. Background Technology

[0002] With the rapid development of generative artificial intelligence technology, Artificial Intelligence Generated Content (AIGC) has been widely used in various fields. However, the authenticity verification of generated content, the consistency maintenance of parameter configurations, and the closed-loop governance of the generation process have become urgent technical problems to be solved.

[0003] Among them, parameter configuration management systems, such as parameter verification methods based on rule bases, rely on predefined rules to conduct compliance checks on basic attributes such as parameter value range and data type to determine the accuracy of configuration. However, such solutions have certain defects: (1) They can only perform single parameter verification and cannot handle the dependency relationship between parameters; (2) They do not build a parameter dependency graph and cannot detect complex problems such as circular dependency and missing dependency; (3) The rule coverage is limited, and adding new parameters or dependency relationships requires updating a large number of rules; (4) They lack intelligent correction suggestions and require manual intervention to solve problems.

[0004] Content auditing systems, such as log-based content tracking solutions, generate process information including operation time, operator, and operation behavior by recording content in logs. The main drawbacks are: (1) the log information is incomplete, only recording the operation time and type, and cannot establish a strong correlation between the content and the original data source; (2) the logs are easily tampered with, lacking digital signatures and anti-tampering mechanisms; (3) it cannot automatically verify the authenticity of the content, requiring manual review; and (4) it lacks a standardized audit format, making it difficult to achieve verifiable traceability.

[0005] Content quality control systems include manual review or keyword-based automatic review methods. By reviewing the content after it is generated, the system determines whether the content meets quality standards. This type of post-control mode has obvious drawbacks: (1) The review is carried out after the content is generated, which is a post-event remedy and cannot prevent problems during the generation process; (2) The review standards are not uniform, are highly subjective, and rely on the reviewer's experience; (3) There is a lack of automatic correction mechanism, and manual regeneration is required after problems are found; (4) It is impossible to form a feedback loop and continuously optimize the generation strategy.

[0006] In summary, the existing technology has the following main problems:

[0007] (1) Lack of automated management of parameter dependencies Existing technologies only perform single-parameter verification or verification based on simple rules, without constructing a parameter dependency graph, and cannot automatically detect complex dependencies between parameters, especially circular dependencies, missing dependencies, etc.

[0008] (2) Lack of verifiable content and data source links: Existing log or auditing mechanisms cannot establish verifiable links between content and original data sources, lack anti-tampering mechanisms, and cannot effectively verify the authenticity of content.

[0009] (3) Lack of a complete closed-loop governance mechanism Existing technologies separate parameter verification, content generation, auditing and other links, and have not formed a unified closed-loop governance system, making it impossible to realize the complete process from parameter verification, content generation, auditing to correction and optimization.

[0010] (4) The existing technology does not address the special characteristics of AI-generated content, particularly: cross-modal parameter consistency (such as numerical consistency between question text, calculation process and answer), traceability of generation process, and automatic correction of generation errors.

[0011] Therefore, there is an urgent need to propose a new closed-loop governance method for AIGC. Summary of the Invention

[0012] To address existing technical problems, this invention provides an AIGC closed-loop governance method based on a unified parameter model and data source auditing. Its core technical architecture includes unified parameter model establishment, parameter dependency graph, cross-modal parameter mapping, executable data source auditing, and closed-loop control. The specific technical solution is as follows:

[0013] S1, Generative AI constructs a parameter set containing parameters of different modalities based on a preset content generation scenario, and further obtains a unified parameter model; at the same time, it registers preset data sources to generate data source identifiers and stores them in the data source registration library;

[0014] S2, construct a parameter dependency graph based on the unified parameter model, and perform consistency verification on the parameter dependency graph, including cyclic dependency detection, dependency integrity detection, parameter type verification and value range verification. If the consistency verification passes, proceed to S3.

[0015] S3, generative AI, outputs generated content based on a parameter set and a registered data source, while recording audit entries during the generation process; all audit entries form an audit trail chain;

[0016] S4, after mapping the generated content across modal parameters, combines the audit trail chain to perform multimodal consistency verification, audit chain consistency verification and data source consistency verification sequentially or in parallel;

[0017] S5: If the generated content passes all the checks in S4, the generated content that has passed the checks is output. Otherwise, the corresponding governance control instructions are generated according to the check results. The generative AI recycles S3-S5 according to the governance control instructions until the generated content passes the checks or the preset number of cycles is reached. At this time, the loop stops and the generated content is output.

[0018] Furthermore, in S1, the generative AI is a large language model; the content generation scenario includes test question generation and code generation; the modality includes text modality, code modality and formula modality; the parameter set includes parameters and each parameter's parameter identifier, parameter name, parameter type, value range and dependent parameter list;

[0019] Furthermore, in S1, the unified parameter model includes a parameter master table and a parameter mapping index table; the parameter master table is composed of a parameter set, and the parameter mapping index table is used to store the mapping relationship between parameters.

[0020] Furthermore, S2 specifically refers to:

[0021] S201, Based on the parameters and the dependencies between parameters in the unified parameter model, a parameter dependency graph is constructed;

[0022] S202: Based on the parameter dependency graph, use topological sorting to sort all parameters in the parameter dependency graph. Simultaneously, perform dependency integrity checks, parameter type verification, and value range verification on each node in the parameter dependency graph. If a sorted result containing all parameters is obtained and each node passes the dependency integrity check, parameter type verification, and value range verification, then proceed to the content generation stage. If a complete sorted result containing all parameters cannot be obtained, proceed to S203. If a sorted result containing all parameters is obtained but at least one node fails the dependency integrity check, parameter type verification, or value range verification, then output a consistency verification failure result and corresponding correction suggestions, and terminate the current consistency verification process.

[0023] S203 performs a circular dependency check on the parameter dependency graph. If the check passes, proceed to the content generation stage; otherwise, output the circular dependency check failure result and return to S1 to regenerate the parameter set.

[0024] Furthermore, the circular dependency check specifically includes:

[0025] S2031, initialize the state of each node in the parameter dependency graph to an unvisited state, and initialize the recursion stack;

[0026] S2032, For each node in the parameter dependency graph, determine whether the current node is in an unvisited state. If the current node has been visited, skip the node. If the current node has not been visited, mark the current node as being visited and put the node into the recursion stack.

[0027] S2033, determine whether the current node has an adjacent node. If it does, proceed to S2034. If it does not, remove the current node from the recursion stack and update the status to visit complete.

[0028] In S2034, check each adjacent node in the recursive stack. If it is, the circular dependency check is considered to be failed. If it is not, check if the adjacent node is in an unvisited state. If the adjacent node is in an unvisited state, mark the adjacent node as being visited and put it on the recursive stack. Then, use the adjacent node as the current node and loop through S2033-S2034. If the adjacent node is in a visited state, skip the adjacent node. When all adjacent nodes have been traversed, remove the current node from the recursive stack and update its state to visited.

[0029] S2035, loop through S2032-S2034 until all nodes in the parameter dependency graph have been traversed.

[0030] Furthermore, the dependency integrity detection involves checking whether the dependency relationship of each parameter in the parameter dependency graph can be found in the parameter dependency graph, and whether the dependency relationship forms a complete dependency relationship chain.

[0031] The parameter type validation checks whether the data type of the parameter matches the parameters it depends on.

[0032] The value range verification checks whether the parameter value is within a predefined valid range.

[0033] Furthermore, in S3, the audit entry includes a step identifier, the value of the parameter in the step, the data source identifier, the step timestamp, the hash value of the currently generated content, the hash value of the previous audit entry, and the corresponding digital signature.

[0034] Furthermore, S4 specifically includes:

[0035] S401, based on the preset unit conversion table and the parameter mapping index table in the unified parameter model, maps all parameters appearing in the generated content to the corresponding parameter identifiers to obtain a unified parameter set;

[0036] S402, based on the audit trail chain, performs multimodal consistency verification, audit chain consistency verification and data source consistency verification on the unified parameter set sequentially or in parallel. If all verifications pass, proceed directly to S5. If any verification fails, output the corresponding verification result and proceed to S5.

[0037] Furthermore, in S402, the multimodal consistency verification specifically involves comparing and verifying the performance of the same parameter identifier in different modalities within the unified parameter set, including checking whether the parameter name, type, unit, and value are consistent.

[0038] Furthermore, the audit chain consistency verification and data source consistency verification include audit entry integrity verification, audit entry signature validity verification, data source registration status verification, and data source hash consistency verification.

[0039] The audit entry integrity verification involves sequentially calculating the hash value of each audit entry in the audit trail chain and comparing the calculated hash value with the hash value of the previous audit entry stored in the next audit entry.

[0040] The audit entry signature validity check verifies whether the digital signature on each audit entry is valid.

[0041] The data source registration status verification is performed by querying the data source registration database based on the data source identifier of each audit entry in the audit trail chain to confirm that the corresponding data source has completed registration and the registration status is valid.

[0042] The data source hash consistency verification is as follows: First, based on the data source identifier of each audit entry in the audit trail chain, the unique hash identifier of the corresponding data source in the data source registry is obtained; second, based on the actual content stored in the corresponding data source in the data source registry, the hash value is calculated, and the unique hash identifier and the calculated hash value are compared to see if they are consistent.

[0043] The beneficial effects of this invention are:

[0044] (1) Cross-modal semantic alignment is achieved by using the parameter mapping index table and standard unit identifier in the unified parameter model, so that the references to the same parameter by different modalities can maintain a unified identifier before and after generation, and consistency judgment is performed after unit conversion, thereby reducing parameter semantic drift.

[0045] (2) The parameter relationship is structured by using the parameter dependency graph, and the circular dependency, missing dependency, and type and value range conflict are detected by combining topological sorting and depth-first search.

[0046] (3) Through data source registration and audit trail chain, the data usage path in the generation process can be recorded and verified, enhancing the verifiable association between content and data source;

[0047] (4) By extracting parameters from the generated content through regular expression matching, structured tag parsing, or named entity recognition, the coverage of parameter extraction for different modalities can be improved;

[0048] (5) When the verification fails, the parameters are corrected or the data source is retrieved again according to the deviation threshold to form an automatic governance process of "verification, correction and regeneration".

[0049] In summary, compared to the existing technologies where parameter verification, log auditing, and content review are handled in a fragmented manner, this invention establishes a cross-modal semantic alignment foundation through a unified parameter model, identifies parameter conflicts in advance through a parameter dependency graph, establishes data source associations through data source registration and audit trail chains, and achieves automatic correction after verification through closed-loop control. This enables the consistency, traceability, and automatic governance capabilities of generated content to be achieved collaboratively within the same processing framework. Attached Figure Description

[0050] Figure 1 This is a schematic diagram of the parameter dependency graph construction and consistency verification process of the present invention.

[0051] Figure 2 This is a schematic diagram of the circular dependency detection process of the present invention.

[0052] Figure 3 This is a schematic diagram of the data source auditing process of this invention.

[0053] Figure 4 This is a schematic diagram of the closed-loop governance and control process of the present invention. Detailed Implementation

[0054] To make the above-mentioned objects, features, and advantages of the present invention more apparent and understandable, the specific embodiments of the present invention will be described in detail below with reference to the accompanying drawings. Many specific details are set forth in the following description to provide a thorough understanding of the present invention. However, the present invention can be practiced in many other ways different from those described herein, and those skilled in the art can make similar modifications without departing from the spirit of the present invention. Therefore, the present invention is not limited to the specific embodiments disclosed below. Technical features in the various embodiments of the present invention can be combined accordingly without mutual conflict.

[0055] First, to facilitate understanding of the technical solution of this invention, the relevant terms appearing in this invention are defined as follows:

[0056] (1) Parameter dependency graph: a directed graph consisting of parameters as nodes and dependencies as directed edges;

[0057] (2) Data source: The data source object that is referenced during the generation process and has been registered. The registration information includes at least the data source identifier, hash value and metadata;

[0058] (3) Audit trail chain: a sequence of audit entries connected in chronological order. Each entry includes at least a step identifier, an input parameter snapshot, a data source identifier, an output hash, a timestamp, and the signature hash value of the previous audit entry. The audit trail chain can be stored in a trusted storage medium, such as a trusted execution environment, a trusted log storage system, or an immutable storage device, or enhanced by combining a trusted timestamp service.

[0059] (4) Unified parameter model: A model used to map parameters in different modalities to the same parameter identifier, including at least a parameter master table and a parameter mapping index table. The parameter mapping index table is used to map text modalities (such as "quality"), code modalities (such as "mass") and formula modalities (such as "m") to a unified parameter identifier (such as ID_001). The parameter master table also records the parameter values ​​and units and converts them to a unified standard unit identifier. For example, "10kg" and "10000g" in the text are considered to be consistent after conversion to a unified standard unit identifier.

[0060] (5) Closed-loop governance: a cyclical control process of “parameter verification, content generation, audit verification, failure correction, and regeneration”.

[0061] Based on the above background, this invention proposes an AIGC closed-loop governance method based on a unified parameter model and data source auditing. Through the establishment of a unified parameter model, the construction of a parameter dependency graph, data source auditing, and a closed-loop control mechanism, a closed-loop governance process is realized to verify the consistency of generated content, audit its authenticity, and automatically correct it.

[0062] The overall framework of the closed-loop governance process of this invention is as follows: Figure 4 As shown, it includes three stages: the pre-generation control stage, the generation process audit stage, and the post-generation verification stage. Among them, Figure 4 The process node number is used to represent each processing step in the closed-loop governance process, which corresponds to different processing stages and sub-processes in the specific embodiments of the present invention.

[0063] I. Pre-generation control stage

[0064] In the pre-generation control phase, the system verifies the standardization of parameter definitions and the structuring of logical relationships between parameters by constructing a unified parameter model and parameter dependency graph. The parameter verification results output by this step are an important basis for the system to determine whether to start content generation. If the pre-generation verification fails, the system directly outputs the pre-generation verification failure result and corresponding correction suggestions and terminates the process. If the pre-generation verification passes, the generative AI content generation is started and the generation process audit phase begins.

[0065] The specific steps are as follows:

[0066] Step 1: Establishing a unified parameter model

[0067] Based on the user's preset application scenarios, the system generates the required parameters and definitions for all modalities (including text modality, code modality, formula modality, and other modalities), forms a parameter definition set, maps the parameters in different modalities to a unified parameter identifier, and constructs a unified parameter model including a parameter master table and a parameter mapping index table.

[0068] Step 2: Constructing the parameter dependency graph

[0069] The system creates corresponding nodes and directed edges based on the dependencies between parameters in the parameter definition set, thus constructing a parameter dependency graph. Consistency verification is then performed, synchronously checking for cyclic dependencies, dependency integrity, and parameter type and value range. After consistency verification is complete, the system determines whether the verification passed. If successful, the verification result is output; otherwise, the verification result and corresponding correction suggestions are output.

[0070] like Figure 1 As shown, the specific steps are as follows:

[0071] 1.2.1: Receiving a set of parameter definitions. The system receives parameter definitions, each of which includes attributes such as parameter name, parameter value, dependency list, value range, and type.

[0072] 1.2.2: Create a parameter node for each parameter. The system creates a node object for each parameter, forming a set of parameter nodes.

[0073] 1.2.3: Create directed edges based on the dependencies between parameters. The system creates directed edges between parameter nodes based on the dependencies, forming a parameter dependency graph structure.

[0074] 1.2.4: Consistency verification of the parameter dependency graph. The system first determines whether there is an acyclic sorting result in the parameter dependency graph based on topological sorting, and verifies the dependency integrity, parameter type, and value range. When a complete sorting result containing all parameters cannot be obtained, a circular dependency detection is performed based on a depth-first search algorithm.

[0075] The detailed process of circular dependency detection is as follows: Figure 2 As shown. First, the access state of each parameter node is initialized to unvisited, and the recursion stack information is initialized. Then, each node in the parameter dependency graph is traversed. During the traversal, the system first determines whether the current node is in an unvisited state. If the node has been visited, it is skipped directly. If it has not been visited, a circular dependency check is performed on the unvisited node.

[0076] During the detection process, the current node is marked as being visited and placed on the recursive stack. First, it is checked whether the current node has any adjacent nodes. If not, the current node is removed from the recursive stack, and its status is updated to "visited." If adjacent nodes exist, all adjacent nodes are traversed, and each adjacent node is checked against the recursive stack. If an adjacent node exists, it means the node has been encountered again on the current search path, indicating a circular dependency. The circular path is recorded, a consistency verification failure result is output, and the system returns to the parameter generation stage to regenerate the parameter set. If adjacent nodes do not exist, the system further checks whether they are unvisited. If unvisited, the system recursively performs circular dependency detection on that adjacent node, repeating the marking and traversal process. Otherwise, the adjacent node has been fully explored and passes the circular dependency detection, and the system continues to check the next adjacent node. When an adjacent node has been visited, the system continues to check the next adjacent node.

[0077] After all adjacent nodes of a given node have been traversed, the system removes the current node from the recursion stack and updates its status to "travel complete," indicating that all paths originating from this node have been safely explored and no loops have been found. This process is repeated until no untraversed nodes remain, at which point the cycle dependency detection of the current parameter dependency graph ends, and the detection result is output.

[0078] Dependency integrity checks verify consistency by ensuring that every dependency declared by a parameter in the dependency graph can be traced back to a corresponding node in the graph. Specifically, if parameter A declares its dependency on parameter B, the system must be able to find parameter B in the dependency graph, and parameter B must exist and be reachable. This verification effectively prevents a parameter from referencing a non-existent parameter, which could lead to unresolved missing parameters during subsequent generation. Simultaneously, path integrity checks check if dependencies form a complete chain, ensuring that tracing the dependency chain from any parameter ultimately leads to a root parameter with no dependencies, thus guaranteeing that the entire dependency graph structure is closed and complete.

[0079] Parameter type and value range validation checks the properties of each parameter itself and ensures that dependencies between parameters are type-compatible. Parameter type validation focuses on whether the data types of the parameters match. For example, if a parameter is defined as a floating-point number, then the parameters it depends on should also be able to provide floating-point values, or the type conversion should be feasible, avoiding type errors such as using a string as a number. Value range validation checks whether the value of a parameter is within a predefined valid range. For example, if a parameter representing "difficulty" has a value range limited to 1 to 5, then its actual assigned value cannot exceed this range. At the same time, if the value of a parameter depends on other parameters, the system will also verify whether the final result obtained after this dependency propagation still meets the value range constraints of each parameter itself.

[0080] II. Auditing Phase of the Generation Process

[0081] The generation process audit phase involves recording audit entries to audit the generation process. Once the system passes the pre-generation verification, it enters the generation process audit phase. During this phase, the system registers data sources and records generation steps to form an audit trail chain, providing traceable evidence for subsequent verification. The data source audit process of this invention is as follows: Figure 3 As shown. The specific steps are as follows:

[0082] Step 1: Register the data source and generate a hash identifier.

[0083] The user-preset data source is used as the data source to be registered, and the hash value of the data source content is calculated to obtain a unique hash identifier for the data source content, thereby generating a data source identifier. The data source information is then written into the data source registry in the data source registry library to complete the data source registration. The data source registry library can be a database system, a distributed storage system, or a key-value storage system.

[0084] Step 2: Record the generation steps during content generation and create an audit trail.

[0085] During the content generation process, generative AI generates corresponding content step by step based on the parameter definition set and the registered data source. The generated content includes at least two modalities from text, graphics, code, and formula. For example, in the application example of test question generation, the generated content may include the question text and answer in the text modality, and the formula and calculation process in the formula modality.

[0086] Simultaneously, the system records the input data, output data, and data source identifier used for each generation step in the content generation process, performs digital signatures, and generates audit entries. Each audit entry includes at least the generation step identifier, the current value of the parameters that the generation step depends on, the data source identifier used, the hash value of the content generated by the generation step, the timestamp, and the hash value of the previous audit entry. Furthermore, all audit entries are linked into an audit trail chain in chronological order.

[0087] The audit entries are organized using a hash chain structure and stored in a trusted storage medium, such as a trusted log storage system, an immutable storage device, or a trusted execution environment, or the audit generation time is fixed using a trusted timestamp service. In a preferred embodiment, the audit entries can be organized using a Merkle tree structure to improve the efficiency of tamper-proof verification.

[0088] III. Post-Generation Verification Phase

[0089] In this stage, the system first performs parameter parsing on the multimodal content generated by generative AI (such as regular expression pattern matching, structured parsing based on preset XML or JSON tags, and parameter extraction based on named entity recognition). The parsed parameter expressions under various modalities are uniformly mapped to the corresponding parameter identifiers according to the parameter mapping index table pre-established in the unified parameter model. At the same time, according to the preset unit conversion table, the parameter values ​​of different unit systems are uniformly converted to the values ​​corresponding to the standard unit identifiers. On this basis, multimodal consistency verification and audit chain and data source consistency verification are performed sequentially or in parallel.

[0090] In the multimodal consistency verification, the system compares and verifies the performance of the same mapped parameter identifier in different modalities, checking whether the parameter name, type, unit, and value are consistent. For example, it verifies whether the mass of 2.5 kg in the text modality and the m in the formula modality are equal to their original values ​​after conversion to standard units. If inconsistencies are found for the same parameter, the system calculates the difference between the two as the consistency deviation.

[0091] In the consistency verification between the audit chain and the data source, the system first verifies the integrity and signature validity of the audit entries based on the audit trace chain. If the verification passes, the data source registration status is verified. If the verification also passes, the data source hash consistency is verified. When any verification fails, the audit failure result is output and the verification process is stopped. When all verifications pass, the audit pass result is output.

[0092] In terms of the integrity and signature validity of audit entries, the system starts from the first audit entry in the audit trail chain, recalculates the hash value of each audit entry in turn, and compares the calculation result with the previous hash value stored in the next audit entry. The system also verifies whether the digital signature on each audit entry is valid.

[0093] During the data source registration status verification, the system queries the data source registration database one by one based on the data source identifier recorded in each audit entry in the audit trail chain to confirm that the corresponding data source has completed registration and that the registration status is valid.

[0094] In the data source hash consistency verification, the system retrieves the unique hash identifier corresponding to the data source from the data source registry based on the data source identifier recorded in the audit entry. At the same time, it rereads the actual data source content stored in the current data source registry and calculates the hash value, and compares the two hash values.

[0095] If the multimodal consistency check and the audit chain and data source consistency check both pass, the output content passes the instruction. If one of the checks fails, the system generates governance control instructions based on the check results. For example, if the consistency deviation does not exceed a preset threshold, automatic parameter regression correction is triggered; if the consistency deviation exceeds the preset threshold, the corresponding data source is marked as invalid, and the data source is re-retrieved or re-registered before content generation is triggered. Then, the governance control instructions are fed back to the generative AI engine via API, driving it to perform corrections and re-enter Phase Two.

[0096] In this embodiment, the preferred value of the preset threshold is 5% of the preset target parameter value. Those skilled in the art can dynamically adjust the preset threshold according to specific business scenarios, for example, setting it to 0.1% in high-precision physical calculation scenarios and 20% in conventional text generation scenarios.

[0097] Furthermore, the present invention provides a detailed description of the complete application process of the present invention, including parameter dependency graph construction, executable data source auditing, and closed-loop governance control, through two specific embodiments.

[0098] Example 1: AI Question Generation System

[0099] The system needs to generate physics test questions, and the test question examples generated by the specified generative AI must include modalities such as text, formulas, and code. Since different modalities involve common physical parameters, such as object mass and acceleration, cross-modal parameter consistency verification is required. The quality requirements of this embodiment include: (1) Numerical parameters should be consistent across modalities, and verification is performed using the question text, calculation process, answer, and analysis as examples; (2) Parameter configurations should not have circular dependencies or conflicts; and (3) The generated content should be authentic and reliable, and traceable to the data source used.

[0100] Step 1: Construct the parameter dependency graph for the test questions

[0101] In the test question generation system, the first step is to construct a test question parameter dependency graph. The system defines attributes such as name, parameter value, parameter unit, dependency list, value range, parameter type and description for each parameter, and generates the parameter master table in the unified parameter model based on this.

[0102] This embodiment defines eight core parameters, including three basic question parameters, two generation model parameters, and three numerical parameters.

[0103] The basic parameters of the question include the knowledge point depth parameter, the question type complexity parameter, and the question difficulty parameter. Among them, the question difficulty value depends on the knowledge point depth and the question type complexity, and in this specific embodiment, the value is medium; the knowledge point depth has no dependency and its value range is integers from 1 to 5, and in this specific embodiment, the value is 3; the question type complexity has no dependency and in this specific embodiment, the value is calculation.

[0104] The generation model parameters, serving as auxiliary parameters to control the generation behavior, are used to adjust the randomness of the generated content and the output length. They are also incorporated into a unified parameter model for unified management and participate in the construction and consistency verification of parameter dependencies. In this specific embodiment, the generation model parameters include a model temperature parameter and a maximum token parameter.

[0105] The model temperature parameter depends on the difficulty of the question, and in this specific embodiment, it is set to 0.7. The maximum number of tokens depends on the complexity of the question type, and in this specific embodiment, it is set to 500. The rationale is as follows: The model temperature parameter controls the randomness of the generated content, with a feasible range of 0.5 to 0.9. When the temperature is below 0.5, the generated results tend to be conservative and lack diversity; when the temperature is above 0.9, the generation stability decreases and inconsistent content is easily generated. Experimental tests show that a balance between generation stability and diversity is achieved within the range of 0.6 to 0.8, therefore, the preferred value is set to 0.7. The above selection is also constrained by the cross-modal consistency threshold and the upper limit of generation latency. The maximum number of tokens parameter limits the length of the generated content, with a feasible range of 200 to 3000, and a preferred range of 400 to 2000. When the number of tokens is too small, the generated content is incomplete; when the number of tokens is too large, the generation time increases and redundant content is easily generated. Question generation experiments show that 500 tokens can meet the generation requirements of common questions and achieve a balance between generation latency and output completeness.

[0106] The numerical parameters include the object's mass, acceleration, and force. The object's mass is independent and is 2.5 kg in this specific embodiment; the acceleration is independent and is 9.8 m / s² in this specific embodiment; the force depends on both the object's mass and acceleration, and the calculated result in this specific embodiment is 24.5 N.

[0107] To achieve cross-modal semantic alignment, the system further constructs a parameter mapping index table, uniformly mapping "mass" in the text modality, "m" in the code modality, and "m" in the formula modality to parameter identifier ID_001; uniformly mapping "acceleration" in the text modality, "acceleration" in the code modality, and "a" in the formula modality to parameter identifier ID_002; and uniformly mapping "force" in the text modality, "force" in the code modality, and "F" in the formula modality to parameter identifier ID_003.

[0108] The unified parameter model also records a standard unit identifier for each parameter. In one implementation, the International System of Units (SI) is used as the standard unit system, and "2.5kg" and "2500g" are converted to the same standard unit value according to a preset conversion table before a consistency check is performed.

[0109] Based on the parameter mapping index table, the system automatically analyzes the dependencies between parameters and constructs a parameter dependency graph. In one implementation, a unified parameter model is stored in a parameter model memory and accessed through a parameter identifier index to support fast mapping and consistency verification of cross-modal parameters.

[0110] Step 2: Register the test question data source

[0111] After the parameter definitions are completed, the system enters the data source registration phase, registering the three data sources in sequence: the question template library, the knowledge point library, and the physical constant library. After each data source is registered, the system calculates its hash value, generates a unique data source identifier, and stores this information in the data source registry.

[0112] Step 3: Execute closed-loop governance to generate test questions

[0113] The system creates a closed-loop governance controller and executes a test question generation process with governance features. In the complete execution process, the parameter consistency verification in Phase 1 fails in the first round due to missing dependency parameters, and the system generates correction suggestions. In the second round, the audit in Phase 2 fails because the data source does not exist, and the system generates correction suggestions again. In the third round, the test questions are successfully generated.

[0114] Step 4: Verification of Test Item Quality

[0115] In the test question quality verification stage, the system uses a parsing module to perform parameter parsing on the generated content to extract parameter identifiers and values. Parameter extraction methods include using regular expression matching and named entity recognition to extract numerical entities such as "2.5kg" and "9.8m / s²" from the question text, using formula tag parsing to extract parameter symbols such as "m", "a", and "F" from the formula content, and using preset JSON tags to parse the structured question bank output to extract parameter names, units, and parameter values.

[0116] When the overall confidence level of the above automatic extraction method is lower than the preset threshold, the system triggers an explicit reconstruction instruction, sends reconstruction control information to the generative AI engine, and requests the generative AI to perform structured reconstruction of the test content according to the preset JSON Schema, so as to improve the parsability of parameters and avoid the stagnation of the closed-loop process.

[0117] Ultimately, the test questions generated in this embodiment include the question text "A 2.5kg object moves with an acceleration of 9.8m / s²", the calculation process "F = 2.5 × 9.8 = 24.5N", and the answer "24.5N". After mapping the extracted results to unified parameter identifiers ID_001, ID_002, and ID_003, the system verifies the consistency of parameter names, units, and values. The verification result indicates that the parameter extraction was successful and the consistency check passed.

[0118] Example 2: AI Code Generation System

[0119] This embodiment applies the method of the present invention to an AI code generation scenario to verify the parameter consistency among code, interface documentation, and test scripts. In this scenario, the system automatically generates program code based on the requirements description, and simultaneously generates interface documentation and unit test scripts. The generated content includes at least three modalities: program code, interface documentation, and test scripts. Since the different modal contents contain common parameters, such as interface names, parameter names, parameter types, and default values, cross-modal parameter consistency verification is required.

[0120] The system first constructs a unified parameter model, mapping code parameters, documentation parameters, and test script parameters to the same parameter identifier, thus establishing the foundation for semantic alignment between different modalities. Subsequently, the system constructs a parameter dependency graph, extracting dependencies between parameters based on function definitions and call relationships. These dependencies include those between function input parameters and output results; for example, in the `calculateForce` function, the output parameter `force` depends on the input parameters `mass` and `acceleration`. Based on these dependencies, the system constructs a directed graph structure, where nodes represent parameters or calculation results, and edges represent dependencies between parameters. It also checks the completeness and type matching of parameter dependencies in function call relationships to ensure that parameters do not conflict or lack logically. During the generation process, the system sequentially records audit entries for code generation, documentation generation, and test script generation steps, forming a complete audit trail chain and providing traceable evidence for subsequent verification stages.

[0121] Finally, the system performs cross-modal parameter consistency verification. Taking the specific code definition, interface documentation, and test script as examples, the code is defined as function calculateForce(mass: float, acceleration: float), the interface documentation records it as mass: float, acceleration: float, and the test script writes it as assertcalculateForce(2.5, 9.8)==24.5.

[0122] The system extracts the above parameters through the parsing module and performs consistency checks on the parameter names, types, quantities, order, and values ​​in each modality to confirm whether they match. When parameter inconsistencies are detected, a correction process is automatically triggered to regenerate the relevant code or documentation, thus forming a complete closed-loop governance from generation and verification to correction.

[0123] To illustrate the feasibility and technical effectiveness of this invention, the following verification is conducted using simulated business samples. The verification objects include four core processing stages: parameter dependency graph construction, data source auditing, cross-modal parameter extraction, and closed-loop control. The verification samples include multimodal test questions, code generation samples, and data source anomaly samples. Evaluation metrics include circular dependency identification rate, parameter false negative rate, traceable path integrity, and closed-loop correction time.

[0124] In the validation of parametric dependency graph construction and cyclic dependency detection, for samples without cyclic dependencies, the system successfully constructed a parametric dependency graph. The example graph has 6 nodes, 7 edges, and a maximum depth of 3, and no cyclic dependencies were detected. In samples with cyclic dependencies, when three parameters are input to form a closed loop A→B→C→A, the system can output the corresponding loop path.

[0125] In the verification of executable data source audit, after registering three data sources and generating content, the system completes the verification of audit entry link integrity, data source registration status, and data source hash consistency. In the data source tampering sample, the system can identify hash inconsistencies and output data source correction instructions.

[0126] In the verification of closed-loop governance control, under the combined scenario of parameter verification failure and data source anomaly, the first round of generation identified dependency missing, the second round identified data source mismatch, and the third round passed the consistency verification after correction, indicating that the closed-loop control process can be stably executed in the order of "verification failure, correction, regeneration".

[0127] The present invention further verified the technical effect of the proposed method through comparative experiments.

[0128] On 1000 simulated multimodal samples, compared with the processing method using only log auditing, the traceability path integrity of the present invention was improved from 82.4% to 97.1%. On the same set of samples, compared with the consistency detection method using only simple field comparison, the parameter false negative rate of the present invention was reduced from 11.8% to 2.9%.

[0129] On 200 simulated samples with parameter deviations, when the deviation does not exceed 5% of the target parameter value, the average closed-loop time for the system to perform automatic parameter regression correction is 1.6 seconds; under the same conditions, the average time for manual review and correction is 9.4 seconds. These results demonstrate that the proposed solution can improve cross-modal consistency governance efficiency while ensuring data source traceability.

[0130] In summary, compared to traditional methods that can only detect anomalies, this invention, by constructing a parameter dependency graph structure, can also locate the parameter source node and perform automatic regression correction, thereby forming a closed-loop mechanism for parameter consistency governance.

[0131] The embodiments described above are merely preferred embodiments of the present invention and are not intended to limit the invention. Those skilled in the art can make various changes and modifications without departing from the spirit and scope of the invention. Therefore, all technical solutions obtained through equivalent substitution or transformation fall within the protection scope of the present invention.

Claims

1. An AIGC closed-loop governance method based on a unified parameter model and data source auditing, characterized in that: include: S1, Generative AI constructs a parameter set containing parameters of different modalities based on a preset content generation scenario, and further obtains a unified parameter model; at the same time, it registers preset data sources to generate data source identifiers and stores them in the data source registration library; S2, construct a parameter dependency graph based on the unified parameter model, and perform consistency verification on the parameter dependency graph, including cyclic dependency detection, dependency integrity detection, parameter type verification and value range verification. If the consistency verification passes, proceed to S3. S3, generative AI, outputs generated content based on parameter set and registered data source, while recording audit entries during the generation process; all audit entries form an audit trail chain; S4, after mapping the generated content across modal parameters, combines the audit trail chain to perform multimodal consistency verification, audit chain consistency verification and data source consistency verification sequentially or in parallel; S5: If the generated content passes all the checks in S4, the generated content that has passed the checks is output. Otherwise, the corresponding governance control instructions are generated according to the check results. The generative AI recycles S3-S5 according to the governance control instructions until the generated content passes the checks or the preset number of cycles is reached. At this time, the loop stops and the generated content is output.

2. The AIGC closed-loop governance method based on a unified parameter model and data source auditing as described in claim 1, characterized in that, In S1, the generative AI is a large language model; the content generation scenarios include test question generation and code generation; the modalities include text modalities, code modalities, and formula modalities; the parameter set includes parameters and each parameter's parameter identifier, parameter name, parameter type, value range, and dependent parameter list.

3. The AIGC closed-loop governance method based on a unified parameter model and data source auditing as described in claim 1, characterized in that, In S1, the unified parameter model includes a parameter master table and a parameter mapping index table; the parameter master table is composed of a parameter set, and the parameter mapping index table is used to store the mapping relationship between parameters.

4. The AIGC closed-loop governance method based on a unified parameter model and data source auditing as described in claim 1, characterized in that, Specifically, S2 is: S201, Based on the parameters and the dependencies between parameters in the unified parameter model, a parameter dependency graph is constructed; S202, based on the parameter dependency graph, use topological sorting to sort all parameters in the parameter dependency graph, and simultaneously perform dependency integrity detection, parameter type verification and value range verification on each node in the parameter dependency graph. If a sorting result containing all parameters is obtained and each node passes the dependency integrity detection, parameter type verification and value range verification, then proceed to the content generation stage. If a complete sorting result containing all parameters cannot be obtained, proceed to S203; if a sorting result containing all parameters is obtained but at least one node fails dependency integrity check, parameter type check, or value range check, output the consistency verification failure result and corresponding correction suggestions, and terminate the current consistency verification process. S203 performs a circular dependency check on the parameter dependency graph. If the check passes, proceed to the content generation stage; otherwise, output the circular dependency check failure result and return to S1 to regenerate the parameter set.

5. The AIGC closed-loop governance method based on a unified parameter model and data source auditing as described in claim 4, characterized in that, The circular dependency check is specifically as follows: S2031, initialize the state of each node in the parameter dependency graph to an unvisited state, and initialize the recursion stack; S2032, For each node in the parameter dependency graph, determine whether the current node is in an unvisited state. If the current node has been visited, skip the node. If the current node has not been visited, mark the current node as being visited and put the node into the recursion stack. S2033, determine whether the current node has an adjacent node. If it does, proceed to S2034. If it does not, remove the current node from the recursion stack and update the status to visit complete. In S2034, check each adjacent node in the recursive stack. If it is, the circular dependency check is considered to be failed. If it is not, check if the adjacent node is in an unvisited state. If the adjacent node is in an unvisited state, mark the adjacent node as being visited and put it on the recursive stack. Then, use the adjacent node as the current node and loop through S2033-S2034. If the adjacent node is in a visited state, skip the adjacent node. When all adjacent nodes have been traversed, remove the current node from the recursive stack and update its state to visited. S2035, loop through S2032-S2034 until all nodes in the parameter dependency graph have been traversed.

6. The AIGC closed-loop governance method based on a unified parameter model and data source auditing as described in claim 4, characterized in that, The dependency integrity check is to check whether the dependency relationship of each parameter in the parameter dependency graph can be found in the parameter dependency graph, and whether the dependency relationship forms a complete dependency relationship chain. The parameter type validation checks whether the data type of the parameter matches the parameters it depends on. The value range verification checks whether the parameter value is within a predefined valid range.

7. The AIGC closed-loop governance method based on a unified parameter model and data source auditing as described in claim 1, characterized in that, In S3, the audit entry includes a step identifier, the value of the parameter in the step, the data source identifier, the step timestamp, the hash value of the currently generated content, the hash value of the previous audit entry, and the corresponding digital signature.

8. The AIGC closed-loop governance method based on a unified parameter model and data source auditing as described in claim 1, characterized in that, Specifically, S4 is: S401, based on the preset unit conversion table and the parameter mapping index table in the unified parameter model, maps all parameters appearing in the generated content to the corresponding parameter identifiers to obtain a unified parameter set; S402, based on the audit trail chain, performs multimodal consistency verification, audit chain consistency verification and data source consistency verification on the unified parameter set sequentially or in parallel. If all verifications pass, proceed directly to S5. If any verification fails, output the corresponding verification result and proceed to S5.

9. The AIGC closed-loop governance method based on a unified parameter model and data source auditing as described in claim 8, characterized in that, In S402, the multimodal consistency verification specifically involves comparing and verifying the performance of the same parameter identifier in different modalities within the unified parameter set, including checking whether the parameter name, type, unit, and value are consistent.

10. The AIGC closed-loop governance method based on a unified parameter model and data source auditing as described in claim 8, characterized in that, In S402, the audit chain consistency verification and data source consistency verification include audit entry integrity verification, audit entry signature validity verification, data source registration status verification, and data source hash consistency verification. The audit entry integrity verification involves sequentially calculating the hash value of each audit entry in the audit trail chain and comparing the calculated hash value with the hash value of the previous audit entry stored in the next audit entry. The audit entry signature validity check verifies whether the digital signature on each audit entry is valid. The data source registration status verification is performed by querying the data source registration database based on the data source identifier of each audit entry in the audit trail chain to confirm that the corresponding data source has completed registration and the registration status is valid. The data source hash consistency verification is as follows: First, based on the data source identifier of each audit entry in the audit trail chain, the unique hash identifier of the corresponding data source in the data source registry is obtained; Secondly, based on the actual content stored in the corresponding data source in the data source registration database, the hash value is calculated, and the unique hash identifier is compared with the calculated hash value to see if they are consistent.

Images