Method, device and equipment for generating authentication file in AIGC creation process
By constructing a DAG graph and using hash value authentication, the problems of continuity and storage resource consumption in the AIGC creation process are solved, providing an efficient and reliable evidence preservation solution to ensure the integrity and authenticity of the AIGC creation process.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2025-12-08
- Publication Date
- 2026-04-14
AI Technical Summary
In existing technologies, the methods for preserving evidence during the AIGC creation process cannot guarantee continuity and consume a lot of storage resources, which affects users' enthusiasm for creation and the effectiveness of evidence preservation.
By capturing user interaction data with AI tools, a DAG graph is constructed and hash values and timestamp certificates are generated to form an AIGC creation flow graph, avoiding manual screen recording, ensuring the continuity of evidence preservation, and reducing storage resource consumption.
It enables complete evidence preservation of the AIGC creation process, preventing content loss, reducing storage requirements, and improving the authenticity and probative value of the preserved documents.
Smart Images
Figure CN121859289A_ABST
Abstract
Description
Technical Field
[0001] This application relates to the field of Internet technology, as well as data security and data authentication technology, and in particular to a method, apparatus and device for generating AIGC creation process authentication files. Background Technology
[0002] In the field of AI-generated content (AIGC), the need to prove that the generation process was user-driven is increasingly prominent, such as for copyright confirmation, judicial evidence collection, and platform review. Currently, common methods of evidence preservation are still relatively rudimentary, mostly relying on the screen recording function of devices. That is, when users create content using AI tools on their devices, they can record a video stream of the user interface, capturing all the commands and prompts entered during creation, serving as evidence of the authenticity of the AIGC creation process. However, in practice, this method of full screen recording has been found to be only a temporary form of evidence preservation and has many problems.
[0003] On the one hand, simple screen recording cannot guarantee the continuity required for evidence preservation of the AIGC (AIGC) creation process. Starting and stopping screen recording relies entirely on user control. In typical long-duration AIGC operations, users may pause recording during breaks, repeatedly starting and stopping it. They may then forget to restart the recording device in subsequent sessions, resulting in a screen recording file that is actually a series of disjointed segments, failing to fully cover the entire process from initial parameter settings to final content output. In legal settings, this could lead to the authenticity of the screen recording file being questioned due to evidentiary flaws or missing information, rendering it ineffective as proof.
[0004] On the other hand, screen recording requires a large amount of storage resources. For example, if the screen recording standard is 1080P resolution and 60 frames per second, if the screen is recorded continuously for 1 hour, the resulting video file will occupy 3-5GB of storage space. For users who create frequently, the monthly storage demand will exceed TB. Users have to balance between cost and storage needs, which affects their enthusiasm for creation. Summary of the Invention
[0005] In view of this, embodiments of this application provide a method, electronic device, computer-readable storage medium, and computer program product for generating AIGC authoring process authentication files, thereby solving at least one technical problem.
[0006] This application provides a method for generating an AIGC (AI Generated Content) creation process authentication file. The AIGC creation process authentication file includes an AIGC creation flow graph. The method is based on a system for generating AIGC creation process authentication files. The system includes a terminal device, a server, and a timestamp authentication platform. The terminal device is equipped with an AI tool. The method is applied to the terminal device and includes: capturing user interaction data and content creation results during content creation using the AI tool on the terminal device; wherein the interaction data includes user operation data, AI tool response data, and / or question-and-answer data between the user and the AI tool; translating the interaction data into an executable script file and running the script file; and analyzing multiple node data and the relationships between node data obtained during script execution. The system constructs at least one Directed Acyclic Graph (DAG) based on relational information. Each node and edge in the DAG corresponds to multiple node data obtained from running the script file and the relational relationships between these node data. Node data represents a single operation step during script file execution, and the relational relationships between node data represent dependencies between these operation steps. The DAG and the content creation results are then sent to a server as an AIGC creation flow graph. The server generates corresponding hash values for the content creation results and multiple nodes in the AIGC creation flow graph and sends the AIGC creation flow graph and the generated hash values to a timestamp authentication platform. The timestamp authentication platform executes a verification procedure and generates a timestamp certificate. The AIGC creation flow graph and the timestamp certificate constitute the authentication file for the AIGC creation process.
[0007] Optionally, according to the method of the embodiments of this application, the interaction process data involves one or more of the following: the user selects a model in the visual interface of the AI tool and the AI tool responds and switches to the selected model; the user drags a component in the visual interface of the AI tool and the component responds and appears at the drag endpoint; the user inputs a prompt in the visual interface of the AI tool and the AI tool responds and provides feedback; the user sets parameters in the visual interface of the AI tool and the AI tool responds and executes the parameters; the user modifies the configuration in the visual interface of the AI tool and the AI tool responds and executes the configuration.
[0008] Optionally, the method according to the embodiments of this application further includes: after the timestamp authentication platform executes the verification procedure, it performs timestamp authentication on one or more predetermined nodes in the AIGC creation flow graph and the content creation results to generate the timestamp certificate.
[0009] Optionally, according to the method of the embodiments of this application, the single or multiple predetermined nodes include one or more of the following: creative intent node, process arrangement node, model call node, parameter setting node, configuration modification node, and manual intervention node.
[0010] Optionally, according to the method of this application embodiment, the AIGC creation process authentication file stores hash values corresponding to some or all nodes of the AIGC creation flow graph generated by the server.
[0011] Optionally, according to the method of this application embodiment, the hash value of the parent node is stored in the child node of the DAG graph; wherein, if the recalculated hash value of the parent node is consistent with the hash value of the parent node stored in the corresponding child node, it is confirmed that the child node, the parent node, and the edge between them in the DAG graph have not been tampered with.
[0012] This application also proposes an apparatus for generating AIGC creation process authentication files, characterized in that the AIGC creation process authentication file includes an AIGC creation flow graph. The apparatus is mounted in a terminal device of a system for generating AIGC creation process authentication files. The system also involves a server and a timestamp authentication platform. The terminal device is equipped with an AI tool. The apparatus includes: a capture module, used to capture user interaction process data and content creation results during content creation using the AI tool on the terminal device, wherein the interaction process data includes user operation data of the AI tool, AI tool response data, and / or question-and-answer data between the user and the AI tool; and a DAG graph construction module, used to translate the interaction process data into an executable script file and run the script file, based on multiple node data and nodes obtained during script execution. The system constructs at least one Directed Acyclic Graph (DAG) based on the relationships between data. Each node and edge in the DAG corresponds to multiple node data and their relationships obtained by running the script file. Node data represents a single operation step during script file execution, and the relationships between node data represent dependencies between these operation steps. A sending module sends the DAG and the content creation results as an AIGC creation flow graph to a server. The server generates corresponding hash values for the creation results and multiple nodes in the AIGC creation flow graph and sends the AIGC creation flow graph and the generated hash values to a timestamp authentication platform. The timestamp authentication platform executes a verification procedure and generates a timestamp certificate. The AIGC creation flow graph and the timestamp certificate constitute the authentication file for the AIGC creation process.
[0013] This application provides an electronic device, which includes a processor and a memory storing computer program instructions; the electronic device executes the computer program instructions to implement the method described above.
[0014] This application provides a computer program product, which includes computer program instructions that, when executed, implement the method described above.
[0015] This application provides a computer-readable storage medium storing computer program instructions that, when executed, implement the method described above.
[0016] The embodiments of this application provide a novel evidence preservation solution for the evidence preservation needs of the AIGC creation process. By constructing a DAG graph from the user's interaction data with AI tools during the AIGC creation process, the user's creation process is collected. The creation process is then solidified using hash values and timestamps to obtain an AIGC creation process authentication file containing the AIGC creation flow graph and timestamp certificate. The entire collection process does not require manual screen recording. This not only prevents content loss and high storage resource consumption caused by prolonged manual operation, but also improves the evidentiary value of the authentication file through hash value and timestamp information. Attached Figure Description
[0017] To more clearly illustrate the technical solutions of the embodiments of this application, the accompanying drawings of the embodiments of this application will be briefly described below.
[0018] Figure 1 This is a schematic diagram of the system architecture of an embodiment of this application.
[0019] Figure 2 This is a flowchart of a method for generating AIGC authoring process authentication files according to an embodiment of this application.
[0020] Figure 3 This is a schematic structural block diagram of an apparatus for generating AIGC authoring process authentication files according to an embodiment of this application.
[0021] Figure 4 This is a schematic diagram of an electronic device used to implement the method for generating AIGC authoring process authentication files according to embodiments of this application. Detailed Implementation
[0022] The principles and spirit of this application will be described below with reference to several exemplary embodiments. It should be understood that these embodiments are provided to make the principles and spirit of this application clearer and more thorough. The exemplary embodiments provided herein are only a part of the embodiments of this application, and not all of them. All other embodiments obtained by those skilled in the art without inventive effort are within the scope of protection of this application.
[0023] Embodiments of this application relate to terminal devices and / or servers. Implementations of this application can be a system, terminal, device, method, computer-readable storage medium, or computer program product, and can be specifically implemented as entirely hardware, entirely software, or a combination of hardware and software. Figure 1 This diagram illustrates a system architecture according to an embodiment of the present application, including a terminal device 102 and a server 104. The terminal device 102 may include at least one of the following: a smartphone, tablet computer, laptop computer, desktop computer, smart TV, various wearable devices, augmented reality (AR) devices, virtual reality (VR) devices, etc. A client application, such as an app, mini-program, or browser-based client, can be installed on the terminal device 102. Users can input commands through the client, and the terminal device 102 can send request information containing the commands to the server 104. Upon receiving the request information, the server 104 performs corresponding processing and returns the processing result information to the terminal device 102. The server 104 may be a local server or a cloud server, and may be a single server or a server cluster, etc.
[0024] In this document, the terms "first," "second," "third," etc., are used only to distinguish one entity (or operation) from another in textual description, and do not require or imply any sequential order between these entities (or operations).
[0025] Figure 2 This illustration shows a flowchart of a method for generating AIGC creation process authentication files according to an embodiment of this application. The authentication file for the AIGC creation process proposed in this embodiment includes an AIGC creation flow graph. The method is based on a system implementation for generating AIGC creation process authentication files. The system includes a terminal device, a server, and a timestamp authentication platform. The terminal device is equipped with AI tools, and the method is applied to the terminal device. The method includes the following steps: S101: During the content creation process of a user using an AI tool on a terminal device, capture the interaction process data between the user and the AI tool and the content creation results, wherein the interaction process data includes the user's operation data on the AI tool, the response data of the AI tool and / or the question and answer data between the user and the AI tool; S102: Translate the interaction process data into an executable script file and run the script file. Based on the multiple node data and the relationship information between the node data obtained during the script execution, construct at least one directed acyclic graph (DAG). Each node and edge in the DAG corresponds to the multiple node data and the relationship between the node data obtained during the execution of the script file. The node data is a single operation step in the execution process of the script file, and the relationship between the node data is the dependency relationship between the operation steps in the execution process of the script file. S103: The DAG graph and content creation results are sent to the server as an AIGC creation flow graph, so that the server generates corresponding hash values for the content creation results and multiple nodes in the AIGC creation flow graph, and sends the AIGC creation flow graph and the generated hash values to the timestamp authentication platform, so that the timestamp authentication platform generates a timestamp certificate after executing the verification procedure. The AIGC creation flow graph and the timestamp certificate constitute the authentication file of the AIGC creation process.
[0026] According to the processing method of this application embodiment, in order to obtain the AIGC creation process certification file, it is necessary to capture the user's interaction process data with the AI tool during content creation, as well as the content creation results. The interaction process data can include prompts entered by the user when interacting with the AI tool, selected models, uploaded files, clicked buttons, etc. In this application embodiment, after acquiring the interaction data, the terminal device's compiler can be used to translate the interaction process data into an executable script. After translating this data into an executable script, the entire creation process can be reproduced by running the executable script.
[0027] For a Directed Acyclic Graph (DAG), its construction process can include: during the execution of the executable script, after each step is completed, a node is created with the output result as its content, and an edge is created from the upstream node to this new node based on the input parameters of that step. The upstream node contains the input parameters and operation type, while the new node contains the output result and operation type. This process is repeated until the script is completed, and the entire DAG is then constructed. Thus, in the DAG, the execution data (node data) of each script step is saved and directly becomes an entity node in the DAG. The input-output dependencies between steps—that is, which result is derived from which previous result—are automatically captured and transformed into directed edges between nodes. Through the process of "executing the script," the dependencies between nodes and edges are naturally and objectively revealed during the computation process. This preserves the original intent, avoids potential ambiguities and errors from directly parsing the original logs, and ensures the authenticity of the DAG.
[0028] Furthermore, the DAG graph and the creation results are sent to the server as a whole (AIGC creation flow graph). The server generates a unique hash value for each node and result. In some embodiments of this application, optionally, the node data includes: Node_ID (unique identifier), Node_Type, Timestamp(s), Input_Data (or a reference to it), Output_Data (or a reference to it), and Parent_Node_IDs (predecessor nodes), wherein the inclusion of Parent_Node_IDs establishes dependencies between nodes. Optionally, when calculating the hash value, a strong cryptographic hash function (such as SHA-256) is applied to the core immutable data of each node (Node_Type, Timestamp(s), normalized representation of Input_Data, normalized representation of Output_Data, Parent_Node_IDs) to calculate the hash value. The calculation formula is as follows: Node_Hash=SHA256(Node_Type||Timestamp_Str||Canonical(Input_Data) ||Canonical(Output_Data)||Parent_Node_IDs_Concatenated) The use of hash values ensures the authenticity of node data, acting like a "digital fingerprint" to lock the integrity of the content and prevent tampering. After these "fingerprints" are sent to an authoritative timestamp verification platform, the platform performs verification (such as checking credentials), and then digitally signs the received hash value set, the current authoritative time, and other information using its private key to generate a standard-format timestamp certificate (usually a .tsr file), proving that this series of "fingerprints" existed at a specific point in time. The original creation flow graph and the timestamp certificate together constitute a legally and technically credible authentication document, used to prove "who, when, through what steps, and what content was generated." The server ultimately binds and stores the received timestamp certificate with the initially received AIGC creation flow graph, forming a complete authentication document. This document can be used for future judicial evidence, copyright registration, or transaction auditing.
[0029] In this embodiment, the timestamp authentication platform refers to a legally valid and authoritative third-party trusted service institution that has the ability to prove that electronic data existed at a specific point in time and has not been tampered with. The timestamp certificate is an electronic credential issued by the timestamp authentication platform. It contains the hash value of the data to be authenticated, an authoritative timestamp, and a digital signature generated by the timestamp authentication platform's private key, and possesses legal evidentiary value.
[0030] This application embodiment collects the user's creation process by constructing a DAG graph from the user's interaction data with AI tools during the AIGC creation process. The creation process is then solidified and authenticated using hash values and timestamps, resulting in an AIGC creation process authentication file composed of the AIGC creation flow graph and timestamp certificate. The entire process does not require manual screen recording, which not only prevents content loss and high storage resource consumption caused by prolonged manual operation, but also improves the authenticity of the authentication file through hash values and timestamps.
[0031] In some embodiments of this application, optionally, the interaction process data involves one or more of the following: Users select a model and the AI tool's response in the visual interface of the AI tool and switch to the selected model; Users drag and drop components in the visual interface of the AI tool, and the components respond and appear at the end of the drag; Users input "Prompt" in the visual interface of the AI tool, and the AI tool responds, executes, and provides feedback. Users set parameters and the AI tool responds and executes the parameters in the visual interface of the AI tool; Users can modify configurations and the AI tool can respond and execute configurations within the AI tool's visual interface.
[0032] For example, selecting and switching models could be done by the user clicking on "GPT-4" from a dropdown menu on the interface, choosing options like "GPT-3.5," "GPT-4," or "Claude." The AI tool's response would be a notification that "Model has been switched to GPT-4," and all subsequent generation tasks would use the GPT-4 model. Setting parameters and execution could be done by the user dragging the "Creativity" parameter slider, changing it from the standard "0.7" to a higher "0.9." Correspondingly, the AI tool's response would be to this parameter change. When the user clicks "Generate" again, the AI's output text would be more imaginative and unexpected, rather than conventional. Modifying configurations and execution could be done by the user finding the "Output Language" configuration item in the "Settings" panel and changing it from "Chinese" to "English." Correspondingly, the AI tool's response would be to immediately apply this configuration. The next time the user requests content generation, the AI will respond in English, not Chinese.
[0033] Optionally, the method according to the embodiments of this application further includes: after the timestamp authentication platform executes the verification procedure, it performs timestamp authentication on one or more predetermined nodes in the AIGC creation flow graph and the content creation results to generate a timestamp certificate.
[0034] In this embodiment, the nodes for timestamp authentication can be a single node in the AIGC creation flow graph or multiple pre-selected nodes, including not only nodes but also content creation outcomes. Pre-selected nodes refer to nodes that require priority authentication (such as final outcome nodes or key modification nodes) pre-selected by the user or system policy before applying for timestamps. This design allows users to selectively authenticate specific milestones in the creation process based on importance, cost, or compliance requirements, rather than requiring authentication of the entire process.
[0035] Optionally, according to the method of the embodiments of this application, the single or multiple predetermined nodes include one or more of the following: creative intent node, process arrangement node, model call node, parameter setting node, configuration modification node, and manual intervention node.
[0036] Taking the creative intent node as an example, it refers to the node created by the terminal device after the user enters the initial instruction in the input box: "Generate a cyberpunk-style cityscape at night." It represents the starting point and core goal of the entire creative task. In summary, these "pre-defined nodes" are key links in the creative process. They are chosen for separate authentication because they either define the goal (intent), determine the method (model, parameters, process), or embody human creative contribution (human intervention). Applying for timestamps for these nodes is equivalent to providing strong ownership proof for the most core and original link in the entire creative process.
[0037] Optionally, according to the method of this application embodiment, the AIGC creation process authentication file stores hash values corresponding to some or all nodes of the AIGC creation flow graph generated by the server. In some embodiments of this application, optionally, the server can generate hash values based on the data of each node in the AIGC creation flow graph, or select only child nodes as target nodes for generating hash values, or select some child nodes and the remaining pairs of child nodes and parent nodes as target nodes to generate hash values. The child nodes of the target nodes store the data of their corresponding parent nodes. If, according to calculation, it is confirmed that the data of the target node has not changed, then the parent node data in the confirmed target node is compared with the corresponding parent node data in the DAG graph. If the two are consistent, then the parent node data has not been tampered with. Therefore, it can be determined that the authentication file is authentic and trustworthy.
[0038] Optionally, according to the method of the embodiments of this application, the hash value of the parent node is stored in the child nodes of the DAG graph; If the recalculated hash value of the parent node is consistent with the hash value of the parent node stored in the corresponding child node, then it is confirmed that the child node, the parent node, and the edge between them in the DAG graph have not been tampered with.
[0039] In a Directed Acyclic Graph (DAG), the integrity of a parent node is anchored to its child nodes. When the system constructs the DAG sequentially and generates a child node (e.g., generating a "refined draft" node based on a "draft" node), it immediately performs an operation: calculating the hash value of its parent node's ("draft" node's) data. This calculated parent node hash value is then stored directly into the child node's data structure as metadata. When integrity verification is required, the verification system locates the child node and extracts the previously stored parent node hash value from its data body. Next, the system accesses the parent node's current data and recalculates its hash value (i.e., the "actual value"). Finally, the "claimed value" is compared with the "actual value." If they match perfectly, it constitutes strong evidence that "the parent node data and the parent-child relationship have not been tampered with."
[0040] In this way, any modification to the parent node's data will cause its hash value to change, resulting in a mismatch with the original hash value of the parent node pre-stored in the child node. This allows verifiers to efficiently and accurately determine whether the data chain from the parent node to the child node is complete and has not been tampered with by checking whether the hash value stored in the child node matches the recalculated actual hash value.
[0041] Optionally, in some embodiments of this application, the method further includes: generating a root hash based on the AICG generation process credential after removing the node timestamp, applying for a final timestamp based on the root hash, and packaging the final timestamp, DAG lineage, multiple hash values and node timestamps to obtain the AICG generation process credential after overall authentication.
[0042] The system first extracts the individual timestamps of all nodes from the generated AIGC creation process certificate, retaining only core information such as the DAG graph structure data and the hash values of each node's content. Then, the system calculates a total hash value (i.e., the root hash) for the entire extracted dataset. This root hash represents the complete state of the entire creation process after removing the node timestamps. The system submits the root hash calculated in the previous step as the authentication object to the Timestamp Authentication Platform (TSA) to request a final overall timestamp. This timestamp proves that the entire creation process (the version without node timestamps) was finalized at a certain point in time. After receiving and verifying the final timestamp returned by the TSA, the system performs a packaging operation. It integrates all the following elements: the final overall timestamp, the original DAG graph, the hash values of all nodes, and the individual timestamp certificates of each node. These components are then encapsulated to generate a final, fully authenticated AIGC creation process certificate.
[0043] This implementation method greatly enhances the integrity and legal evidentiary value of the entire certification document by applying for a final timestamp for the entire process and cross-validating it with the timestamps at all node levels.
[0044] The implementation methods and advantages of the embodiments of this application have been described above through multiple examples. The specific processing procedures of the embodiments of this application are described in detail below with reference to specific examples.
[0045] Taking the generation of text using a large model A as an example, the method of this application for generating AIGC authoring process authentication documents includes the following steps: Step 1: Acquire Interaction Data. Specifically, in the visualization interface of the large model A, deploy event listeners for each listed user action (such as the model selection dropdown, draggable components, Prompt input box, parameter slider, and configuration switch). Data Capture: When a listener captures a user action, it immediately generates a structured log entry. This log entry includes: action type (e.g., drag_and_drop), action target (e.g., component_A), action content (e.g., prompt_text or parameter_value), timestamp, and other information. Simultaneously, the system records the response from the AI backend service to this action (e.g., successful model switching, generation of new content, parameter activation), and associates this response with the previous user action log. Finally, these captured, one-to-one action-response data pairs are packaged together into interaction process data for subsequent steps such as script translation.
[0046] For example, backend operation data is recorded in JSON format, including timestamps, operation types, and detailed information. Example data is as follows: json [ { "timestamp": "2023-10-05T10:00:00Z", "operation": "set_prompt", "details": { "prompt": "Generate a poem about spring" } }, { "timestamp": "2023-10-05T10:00:05Z", "operation": "set_model_parameters", "details": { "model": "gpt-3.5-turbo", "temperature": 0.7, "max_tokens": 100 } }, { "timestamp": "2023-10-05T10:00:10Z", "operation": "generate_text", "details": {} }, { "timestamp": "2023-10-05T10:00:15Z", "operation": "save_output", "details": { "filename": "poem.txt" } } ] ``` The second step involves translating the interaction data into an executable script and running the script file. Specifically, the system first parses and cleans the captured raw interaction data (such as clicks, inputs, drags, etc.). Then, using a predefined rule engine or mapping table, it maps discrete user actions and responses from a large model A into standardized, sequential high-level instructions. For example, entering "sun" in the Prompt input box and clicking the "Generate Image" button are aggregated into an atomic operation `generate(prompt="Generate a poem about spring")`. Next, this standardized instruction sequence is translated into an executable script file in a specific format, based on the chronological order of events or logical dependencies. This script is typically written in a lightweight structured data format (such as JSON or YAML) or a domain-specific language (DSL), explicitly containing each operation instruction, input parameters, and implicit contextual dependencies. The generated script file is then submitted to a controlled execution environment (such as a sandbox or container) for execution. This environment is equipped with a runtime environment where the interpreter can execute each instruction in the script sequentially, call the corresponding AI services or tool interfaces, and dynamically monitor and record the execution results (output content), execution status, and data flow relationships between each step. During script execution, the execution engine automatically generates and saves the output results of each step as node data based on the execution order of instructions and the input / output dependencies of data. At the same time, it constructs directed edges between nodes in real time based on the derivation relationships between call parameters and results, thus providing a structured and practically validated data foundation for the subsequent construction of the DAG graph.
[0047] For example, the above operations can be automated using a Python script. The script uses the API of Model A. The generated script example (script.py) is as follows: Python import openai # Set API key (you need to set environment variables in advance or enter it directly) openai.api_key = 'your-api-key-here' # Replace with the actual API key # Extracting parameters from operational data prompt = "Generate a poem about spring" model = "gpt-3.5-turbo" temperature = 0.7 max_tokens = 100 filename = "poem.txt" # Generate text response = openai.ChatCompletion.create( model=model, messages=[ {"role": "user", "content": prompt} ], temperature = temperature, max_tokens=max_tokens ) generated_text = response.choices[0].message.content.strip() # Save output with open(filename, 'w', encoding='utf-8') as f: f.write(generated_text) print(f"Text generation complete, saved to {filename}") ``` Execute script Run the script: bash python script.py ``` After execution, a text file is generated and saved to the poem.txt file. Assume the output content is: ``` Spring has arrived, the flowers are smiling. Birds sing, sunshine shines.
[0048] A gentle breeze rustled the green willow branches. The world is full of new hope.
[0049] ``` Step 3: Based on the multiple node data and the relationships between them obtained during script execution, at least one Directed Acyclic Graph (DAG) is constructed. Specifically, during script execution, the terminal device's execution engine captures the output of each instruction step in real time as node data. Simultaneously, it automatically parses the input-output dependencies between steps (e.g., the input of step C depends on the output of step B), using this as node relationship information to provide raw material for graph construction. The system automatically creates directed edges from parent nodes to child nodes based on subsequent steps referencing previous data (e.g., an operation instruction explicitly calls the output ID of a previous node). It dynamically constructs the DAG structure according to the execution order and dependencies, ensuring the graph strictly corresponds to the actual execution flow. The completed DAG graph (containing node sets, edge sets, and corresponding node data) is persistently stored in a standard graph structure data format (e.g., JSON, GraphML) or database format, forming a traceable, queryable, and verifiable creation process graph instance.
[0050] Task dependencies are extracted during script execution to generate a Directed Acyclic Graph (DAG). Nodes represent operation steps, and edges represent dependencies (such as data flows). The DAG is represented in JSON format. json { "nodes": [ { "id": 1, "type": "set_prompt", "data": { "prompt": "Generate a poem about spring" } }, { "id": 2, "type": "set_model_parameters", "data": { "model": "gpt-3.5-turbo", "temperature": 0.7, "max_tokens": 100 } }, { "id": 3, "type": "generate_text", "data": { Output: "Spring has arrived, flowers are blooming, birds are singing, and the sun is shining. A gentle breeze caresses the green willow branches, and the world is filled with new hope." } }, { "id": 4, "type": "save_output", "data": { "filename": "poem.txt" } } ], "edges": [ { "from": 1, "to": 3, "description": "The prompt text is used for generation" }, { "from": 2, "to": 3, "description": "Model parameters are used for generation" }, { "from": 3, "to": 4, "description": "Generated text is used for saving" } ] } ``` Step 4: The DAG graph and content creation results are sent to the server as an AIGC creation flow graph. The server generates corresponding hash values for each node and content creation result in the AIGC creation flow graph. Specifically, the client serializes the DAG graph representing the creation process (including the node relationship structure) and the specific content creation results of each node (such as text and image data) into a standard data format (such as JSON), packages them together into an AIGC creation flow graph data packet, and sends it to the server through a secure channel. After receiving the graph data packet, the server parses and traverses each node, independently calculating the cryptographic hash value of the content creation results contained in each node (such as using the SHA-256 algorithm). This process ensures that each node obtains a unique and verifiable digital fingerprint. To enhance overall integrity, the server can also calculate hash values separately for the topological structure information of the DAG graph (such as the relationships between nodes and metadata), which, together with the node content hash values, constitute a complete verification set. The server binds all generated hash values with the corresponding node ID, graph version, and other information for persistent storage, providing a data foundation for subsequent timestamp authentication and integrity verification applications.
[0051] Step 5: Send the AIGC creation flow graph and the generated hash values to the timestamp authentication platform. The timestamp authentication platform will then execute a verification process and generate a timestamp certificate. Specifically, before sending a request to the timestamp authentication platform, the user or system will select one or more key nodes (such as "final draft nodes") from the complete AIGC creation flow graph that need authentication. This process is completed automatically via checkboxes on the interface or based on rules. The system does not send out the hash values of the entire graph; instead, it only calculates the hash values of the content of these "pre-selected" nodes and their relationships, forming a list of hash values that need authentication. This customized list of hash values is then submitted to the timestamp authentication platform. After completing the verification process, the timestamp authentication platform will sign and authenticate this specific list of hash values, ultimately generating a timestamp certificate.
[0052] Step 6: Use the AIGC creation flow graph and the timestamp certificate obtained in the previous step as authentication documents for the user's AIGC creation process of generating poems using the large model A.
[0053] Correspondingly, this application also provides an apparatus for generating AIGC creation process authentication documents. The AIGC creation process authentication documents include an AIGC creation flow graph. The apparatus is mounted in a terminal device within a system for generating AIGC creation process authentication documents. The system also includes a server and a timestamp authentication platform. The terminal device is equipped with AI tools. Figure 3 The device 100 includes: The capture module 110 is used to capture the interaction process data between the user and the AI tool and the content creation results during the content creation process of the user through the AI tool in the terminal device. The interaction process data includes the user's operation data on the AI tool, the response data of the AI tool and / or the question and answer data between the user and the AI tool. DAG graph construction module 120 is used to translate interaction process data into an executable script file and run the script file. Based on multiple node data and the relationship information between node data obtained during script execution, at least one directed acyclic graph (DAG) is constructed. Each node and edge in the DAG graph corresponds to multiple node data and the relationship between node data obtained by running the script file. Node data is a single operation step in the script file execution process, and the relationship between node data is the dependency relationship between operation steps in the script file execution process. The sending module 130 is used to send the DAG graph and content creation results as an AIGC creation flow graph to the server, so that the server generates corresponding hash values for the creation results and multiple nodes in the AIGC creation flow graph, and sends the AIGC creation flow graph and the generated hash values to the timestamp authentication platform, so that the timestamp authentication platform generates a timestamp certificate after executing the verification procedure. The AIGC creation flow graph and the timestamp certificate constitute the authentication file of the AIGC creation process.
[0054] Based on at least one of the above embodiments, the electronic device in the embodiments of this application may be a user terminal device, a server, other computing devices, or a cloud server. Figure 4 The diagram illustrates the hardware structure of an electronic device according to an embodiment of this application. The electronic device may include a processor 601 and a memory 602 storing computer program instructions. The processor 601 reads and executes the computer program instructions stored in the memory 602 to implement the process or function of any of the methods described above.
[0055] Specifically, processor 601 may include a central processing unit (CPU), or an application-specific integrated circuit (ASIC), or one or more integrated circuits configured to implement the embodiments of this application. Memory 602 may include a mass storage device for data or instructions. For example, memory 602 may be at least one of the following: a hard disk drive (HDD), read-only memory (ROM), random access memory (RAM), floppy disk drive, flash memory, optical disk, magneto-optical disk, magnetic tape, universal serial bus (USB) drive, or other physical / tangible memory storage device. Alternatively, memory 602 may include removable or non-removable (or fixed) media. Furthermore, memory 602 may be internal or external to the integrated gateway disaster recovery device. Memory 602 may be non-volatile solid-state memory. In other words, typically memory 602 includes a tangible (non-transitory) computer-readable storage medium (such as a memory device) encoded with computer-executable instructions, and when the software is executed (e.g., by one or more processors), it can perform the operations described in the methods of the embodiments of this application.
[0056] As an example, Figure 4 The illustrated electronic device may also include a communication interface 603 and a bus 610. The processor 601, memory 602, and communication interface 603 are connected via bus 610 and communicate with each other. Bus 610 may include hardware, software, or both, and may couple components of an online data traffic metering device together. The bus may include at least one of the following: Accelerated Graphics Port (AGP) or other graphics bus, Enhanced Industry Standard Architecture (EISA) bus, Front Side Bus (FSB), HyperTransport (HT) Interconnect, Industry Standard Architecture (ISA) bus, Infinite Bandwidth Interconnect, Low Pin Count (LPC) bus, memory bus, Microchannel Architecture (MCA) bus, Peripheral Component Interconnect (PCI) bus, PCI-Express (PCI-X) bus, Serial Advanced Technology Attachment (SATA) bus, Video Electronics Standards Association Local (VLB) bus, or other suitable bus. Bus 610 may include one or more buses. Although specific buses are described or shown in the embodiments of this application, any suitable bus or interconnection method is contemplated in the embodiments of this application.
[0057] In conjunction with the methods in the above embodiments, this application also provides a computer-readable storage medium storing computer program instructions, which, when executed by a processor, implement the process or function of any of the methods in the above embodiments.
[0058] This application also provides a computer program product that stores computer program instructions, which, when executed by a processor, implement the process or function of any of the methods described above.
[0059] The flowcharts and / or block diagrams of methods, terminals, systems, and computer program products according to embodiments of this application have been exemplarily described above, and related aspects have been described. It should be understood that each block or combination thereof in the flowcharts and / or block diagrams may be implemented by computer program instructions, by dedicated hardware performing a specified function or action, or by a combination of dedicated hardware and computer instructions. For example, these computer program instructions may be provided to a processor of a general-purpose computer, a special-purpose computer, or other programmable data processing apparatus to form a machine such that these instructions, executed via such processor, enable the implementation of the function / action specified in each block or combination thereof in the flowcharts and / or block diagrams. Such a processor may be a general-purpose processor, a dedicated processor, a special-purpose application processor, or a field-programmable logic circuit.
[0060] The functional blocks shown in the structural block diagrams of this application can be implemented as hardware, software, firmware, or a combination thereof. When implemented in hardware, they can be, for example, electronic circuits, application-specific integrated circuits (ASICs), appropriate firmware, plug-ins, function cards, etc.; when implemented in software, they are programs or code segments used to perform the required tasks. Programs or code segments can be stored in memory or transmitted over a transmission medium or communication link via data signals carried on a carrier wave. Code segments can be downloaded via computer networks such as the Internet or intranets.
[0061] It should be noted that this application is not limited to the specific configurations and processes described above or shown in the figures. The above descriptions are merely specific embodiments of this application. Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working processes of the described systems, devices, terminals, modules, or units can be referred to the corresponding processes in the method embodiments, and need not be repeated here. It should be understood that the scope of protection of this application is not limited thereto. Any equivalent modifications or substitutions that can be conceived by those skilled in the art within the scope of the technology disclosed in this application should be covered within the scope of protection of this patent application.
Claims
1. A method for generating AIGC authoring process authentication documents, characterized in that, The AIGC creation process authentication document includes an AIGC creation flow graph. The method is based on a system implementation for generating AIGC creation process authentication documents. The system includes a terminal device, a server, and a timestamp authentication platform. The terminal device is equipped with AI tools. The method is applied to the terminal device and includes: During the content creation process of users using AI tools on terminal devices, capture the interaction process data between users and AI tools and the content creation results. The interaction process data includes the user's operation data on AI tools, the response data of AI tools, and / or the question and answer data between users and AI tools. The interaction process data is translated into an executable script file and the script file is run. Based on the multiple node data and the relationship information between the node data obtained during the script execution, at least one directed acyclic graph (DAG) is constructed. Each node and edge in the DAG corresponds to the multiple node data and the relationship between the node data obtained by running the script file. The node data is a single operation step in the script file execution process, and the relationship between the node data is the dependency relationship between the operation steps in the script file execution process. The DAG graph and the content creation results are sent to the server as an AIGC creation flow graph. The server generates corresponding hash values for the content creation results and multiple nodes in the AIGC creation flow graph. The AIGC creation flow graph and the generated hash values are then sent to the timestamp authentication platform. The timestamp authentication platform executes a verification procedure and generates a timestamp certificate. The AIGC creation flow graph and the timestamp certificate constitute the authentication file for the AIGC creation process.
2. The method according to claim 1, characterized in that, The interaction process data involves one or more of the following: Users select a model and the AI tool's response in the visual interface of the AI tool and switch to the selected model; Users drag and drop components in the visual interface of the AI tool, and the components respond and appear at the end of the drag; Users input "Prompt" in the visual interface of the AI tool, and the AI tool responds, executes, and provides feedback. Users set parameters and the AI tool responds and executes the parameters in the visual interface of the AI tool; Users can modify configurations and the AI tool can respond and execute configurations within the AI tool's visual interface.
3. The method according to claim 1, characterized in that, Also includes: After executing the verification procedure, the timestamp authentication platform performs timestamp authentication on one or more predetermined nodes in the AIGC creation flow graph and the content creation results to generate the timestamp certificate.
4. The method according to claim 3, characterized in that, The single or multiple predetermined nodes include one or more of the following: creative intent node, workflow arrangement node, model call node, parameter setting node, configuration modification node, and manual intervention node.
5. The method according to claim 1, characterized in that, The AIGC creation process authentication file stores hash values corresponding to some or all nodes of the AIGC creation flow graph generated by the server.
6. The method according to claim 1, characterized in that, The child nodes in the DAG graph store the hash value of the parent node; If the recalculated hash value of the parent node is consistent with the hash value of the parent node stored in the corresponding child node, then it is confirmed that the child node, the parent node, and the edge between them in the DAG graph have not been tampered with.
7. An apparatus for generating AIGC authoring process authentication documents, characterized in that, The AIGC creation process authentication document includes an AIGC creation flow graph. The device is mounted on a terminal device in a system for generating AIGC creation process authentication documents. The system also includes a server and a timestamp authentication platform. The terminal device is equipped with AI tools. The device includes: The capture module is used to capture the interaction process data between the user and the AI tool and the content creation results during the content creation process of the user through the AI tool in the terminal device. The interaction process data includes the user's operation data of the AI tool, the response data of the AI tool and / or the question and answer data between the user and the AI tool. The DAG graph construction module is used to translate the interaction process data into an executable script file and run the script file. Based on the multiple node data and the relationship information between the node data obtained during the script execution, at least one directed acyclic graph (DAG) is constructed. Each node and edge in the DAG graph corresponds to the multiple node data and the relationship between the node data obtained by running the script file. The node data is a single operation step in the script file execution process, and the relationship between the node data is the dependency relationship between the operation steps in the script file execution process. The sending module is used to send the DAG graph and the content creation results as an AIGC creation flow graph to the server, so that the server generates corresponding hash values for the creation results and multiple nodes in the AIGC creation flow graph, and sends the AIGC creation flow graph and the generated hash values to the timestamp authentication platform, so that the timestamp authentication platform generates a timestamp certificate after executing the verification procedure. The AIGC creation flow graph and the timestamp certificate constitute the authentication file of the AIGC creation process.
8. An electronic device, characterized in that, The electronic device is a terminal device or a server. The electronic device includes a processor and a memory storing computer program instructions. When the electronic device executes the computer program instructions, it implements the method as described in any one of claims 1-6.
9. A computer program product, characterized in that, It includes computer program instructions that, when executed, implement the method as described in any one of claims 1-6.
10. A computer-readable storage medium, characterized in that, It stores computer program instructions that, when executed, implement the method as described in any one of claims 1-6.