A method, system, and electronic device for local playback of a computing task

Abstract

The application relates to the field of computer data processing and task scheduling, and provides a local playback method and system of a computing task and electronic equipment, which comprises the following steps: obtaining a multi-modal environment dependence of a computing task and generating a verification digest, constructing a multi-dimensional execution graph snapshot containing multi-dimensional topological dependence; detecting environment differences between a target playback environment and the multi-dimensional execution graph snapshot; mapping the environment differences to the multi-dimensional execution graph snapshot, determining an affected node and a successor subgraph thereof based on the multi-dimensional topological dependence; performing local playback based on the affected node and the successor subgraph thereof, and generating an output drift report; and the application realizes accurate cutting and local execution of an affected subgraph in a complex computing graph, optimizes the utilization of computing power, and automatically generates an output drift report.

Description

Technical Field

[0001] This application relates to the field of computer data processing and task scheduling, specifically to a method, system, and electronic device for partial playback of a computing task. Background Technology

[0002] In the execution of complex computational tasks, task nodes often depend on various types of runtime environments and input data. When there are partial changes in underlying environment parameters, external tool versions, or input objects, the task usually needs to be re-executed to ensure the correctness and consistency of the computation results. However, most existing task scheduling and replay mechanisms are based on simple file hash comparisons or scalar parameter matching, which are difficult to effectively handle heterogeneous dependencies, including unstructured configurations, black-box toolchains, and multimodal objects. This leads to the system's inability to accurately identify the affected computational subgraph when there are minor changes in the environment, often forcing a full recalculation and resulting in a significant waste of computing resources. At the same time, due to the lack of a unified abstraction and tracing mechanism for multidimensional dependencies, existing solutions also struggle to quantify the specific drift of environmental changes on the final output results, failing to meet the requirements for result reproducibility efficiency and interpretability of differences in complex computational scenarios. Summary of the Invention

[0003] To address the problems of wasted computing resources and difficulty in quantifying result differences under heterogeneous dependency changes in existing technologies, this application achieves precise pruning and local execution of affected subgraphs in complex computation graphs through a method, system, and electronic equipment for local replay of computing tasks, thereby optimizing computing power utilization and automatically generating output drift reports.

[0004] To achieve the above objectives, this application adopts the following technical solution: Obtaining the multimodal environment dependencies of the computational task and generating a verification digest; constructing a multidimensional execution graph snapshot containing multidimensional topological dependencies; the multidimensional topological dependencies include data flow dependencies, execution control dependencies, and logical tracing dependencies. Detecting environmental differences between the target replay environment and the multidimensional execution graph snapshot. Mapping the environmental differences to the multidimensional execution graph snapshot, and determining the affected nodes and their successor subgraphs based on the multidimensional topological dependencies. Performing local replay based on the affected nodes and their successor subgraphs, and generating an output drift report.

[0005] The above scheme unifies the heterogeneous multimodal environment dependencies into a state snapshot with a verification digest, and constructs an execution graph containing a three-dimensional topology of data, control, and logical traceability. This enables the system to go beyond simple file-level comparisons when the environment changes, accurately locating the affected scope from the semantic and constraint levels. By performing local replay only on the pruned successor subgraph, it avoids full recalculation of irrelevant nodes, significantly reducing computational resource consumption. At the same time, the output drift report generated based on the replay results enables automated quantitative assessment of the impact of environmental changes.

[0006] As one implementation, the multimodal environment dependency includes a generative model configuration, an external computing toolchain environment, and multimodal input objects. Constructing a multidimensional execution graph snapshot containing multidimensional topological dependencies includes: performing digest-based encapsulation on the generative model configuration, the external computing toolchain environment, and the multimodal input objects respectively, generating a state snapshot with a verification digest. The data flow dependency is constructed based on the data transfer relationships between nodes in the computing task; the execution control dependency is constructed based on the execution timing and conditional branches between nodes; and the logical sourcing dependency is constructed based on the data reference and constraint transfer relationships formed by using the output objects of upstream nodes as verification benchmarks or boundary conditions for downstream nodes.

[0007] This implementation solves the problem of unified version management of heterogeneous dependencies by classifying and summarizing generative models, external tools, and multimodal objects; in particular, by explicitly constructing logical source dependencies, it transforms the originally implicit business verification rules into topological edges that can be processed by computers, providing a data foundation for subsequent cascading effect analysis based on constraint propagation.

[0008] As one implementation, mapping the environmental differences to the multidimensional execution graph snapshot and determining the affected nodes and their successor subgraphs based on the multidimensional topological dependencies includes: identifying the difference nodes in the multidimensional execution graph snapshot corresponding to the environmental differences; propagating the influence domain from the difference nodes to their successor nodes based on the data flow dependencies and the execution control dependencies; when the difference node or its successor node has the logical tracing dependency, triggering cascading failure propagation based on changes in the verification benchmark or boundary conditions, and adding the nodes affected by the cascading failure to the influence domain; and pruning the nodes within the influence domain and their associated topological edges to form the affected nodes and their successor subgraphs.

[0009] This implementation introduces a cascading failure propagation mechanism based on logical tracing dependencies, on the basis of conventional data flow and control flow propagation. It can capture the implicit effects caused by changes in verification benchmarks or boundary conditions, ensuring the integrity and accuracy of the pruning of affected subgraphs and preventing unreliable replay results due to the omission of implicit dependency nodes.

[0010] As one implementation, the step of encapsulating the generative model configuration, the external computing toolchain environment, and the multimodal input object into a digest to generate a state snapshot with a verification digest includes: performing parametric hash calculation on unstructured prompt text and model parameters to generate a first verification digest of the generative model configuration; extracting container image identifiers and dependency library version identifiers to generate a second verification digest of the external computing toolchain environment; performing multimodal feature extraction and hash operation on the multimodal input object to generate a third verification digest; and jointly verifying the first, second, and third verification digests to generate a global verification digest of the state snapshot with the verification digest.

[0011] This implementation employs differentiated summary generation strategies for different types of dependencies, particularly parameterized hashing of unstructured prompts and mirror-level identification extraction of black-box toolchains, enabling fine-grained control over heterogeneous elements that traditional version control systems cannot cover; and further ensuring the atomicity and integrity of snapshot states by generating global summaries through joint verification.

[0012] As one implementation method, the construction of the logical tracing dependency based on the data reference and constraint propagation relationship formed by using the output object of the upstream node as the verification benchmark or boundary condition of the downstream node includes: monitoring the calling behavior of the downstream node on the output object of the upstream node during the execution of the computation task. When it is identified that the downstream node uses the output object of the upstream node as a verification benchmark for error calculation or as a boundary condition for constraint pruning, a logical tracing edge is automatically generated. The logical tracing edge, triggering condition, and constraint parameters are recorded in the topology of the multidimensional execution graph snapshot.

[0013] This implementation method uses runtime dynamic monitoring and automatic recording to solidify logical constraints into edge information in the topology, eliminating the need for manually pre-defining complex dependency rules and improving the system's ability to adaptively model complex computational logic.

[0014] As one implementation, the partial replay based on the affected node and its successor subgraph includes: traversing each node in the affected node and its successor subgraph. If the verification digest of all input dependencies and environment dependencies of the current node is consistent with the original verification digest in the multidimensional execution graph snapshot, then the original output object cached in the multidimensional execution graph snapshot is reused. If the verification digest of the input dependencies or environment dependencies of the current node changes, then the corresponding resource in the target replay environment is invoked to re-execute the current node, and a state rollback and isolation mechanism is triggered in the event of an execution exception.

[0015] This implementation combines a refined cache reuse strategy with an exception isolation mechanism, which minimizes redundant calculations while ensuring the robustness of the local replay process and preventing the overall snapshot state from being polluted by a single point of failure.

[0016] As one implementation, generating the output drift report includes: comparing the newly generated output object after partial playback with the original output object in the multidimensional execution graph snapshot in multiple dimensions to generate an output drift matrix that includes numerical drift, structural differences, and textual differences. When the state of the computation task meets preset freezing conditions, a state freezing mechanism is triggered, setting the multidimensional execution graph snapshot and the output drift report to an immutable state and storing them in a tamper-proof storage medium.

[0017] This implementation not only provides a multi-dimensional quantitative view of result differences, but also ensures the traceability and legal validity of key calculation processes through a state freeze mechanism, meeting the audit requirements in high compliance scenarios.

[0018] Furthermore, this application also provides a partial replay system for a computational task, comprising: a snapshot construction module, used to acquire the multimodal environment dependencies of the computational task and generate a verification digest, and construct a multidimensional execution graph snapshot containing multidimensional topological dependencies; the multidimensional topological dependencies include data flow dependencies, execution control dependencies, and logical tracing dependencies. A difference detection and pruning module, used to detect environmental differences between the target replay environment and the multidimensional execution graph snapshot, map the environmental differences to the multidimensional execution graph snapshot, and determine the affected nodes and their successor subgraphs based on the multidimensional topological dependencies. A partial replay module, used to perform partial replay based on the affected nodes and their successor subgraphs, and generate an output drift report. The above-described partial replay system for a computational task is used to execute the above-described partial replay method for a computational task.

[0019] The aforementioned device implements the technical functions corresponding to the method through a modular architecture, ensuring the decoupling and scalability of the system during engineering implementation.

[0020] In one implementation, the snapshot construction module, the difference detection and pruning module, and the local playback module interact with each other via a snapshot package object. The snapshot package object includes: an identifier field, used to uniquely identify the snapshot package object and its associated project; an inventory field, including an object list, a prompt word list, and an environment list, recording the verification summaries of the multimodal input objects, generative model configurations, and external computing toolchain environments, respectively; a topology field, recording the node information of the multidimensional execution graph snapshot and the edge information of the data flow dependencies, execution control dependencies, and logical tracing dependencies; and a strategy field, recording the playback mode, caching strategy, and difference comparison range.

[0021] This implementation defines a standardized data interaction carrier. Through structured field design, it enables modules to efficiently and accurately transmit complex dependency states and topology information, supporting the collaborative operation of the device.

[0022] In addition, this application also provides an electronic device, including a processor and a memory, wherein a computer program is stored in the memory, and the processor executes the computer program to implement the partial playback method of the computing task as described above.

[0023] Beneficial effects:

[0024] 1. This application overcomes the limitations of traditional techniques that can only perform dependency analysis based on files or scalar parameters by constructing a multi-dimensional execution graph snapshot that includes data flow, execution control, and logical tracing, and by uniformly encapsulating heterogeneous multimodal dependencies into a verification digest. Its principle lies in transforming unstructured configurations, black-box tool environments, and logical constraints into standardized topological elements that can be processed by computers. This achieves a complete digital representation of the state of complex computational tasks, ensuring the accuracy and reliability of computational result reproduction under heterogeneous environment changes.

[0025] 2. This application solves the problem of wasted computing power caused by full recalculation by mapping environmental differences to multidimensional execution graph snapshots and pruning affected subgraphs based on logical tracing of dependencies to trigger cascading failure propagation. Its principle lies in accurately propagating the influence domain using multidimensional topological relationships, particularly capturing implicit dependency failures caused by changes in verification benchmarks or boundary conditions. This allows the system to re-execute only the truly affected nodes and their subsequent paths, significantly improving the utilization efficiency of computing resources while ensuring result consistency.

[0026] 3. This application solves the problem of difficulty in quantifying and tracing result differences after environmental changes by generating an output drift matrix containing numerical, structural, and textual differences, combined with a state freeze mechanism. Its principle lies in automatically aligning and comparing multimodal outputs before and after playback, and placing key snapshots in a tamper-proof state, thereby providing objective and quantifiable technical evidence for result verification, compliance auditing, and version evolution of complex computing tasks. Attached Figure Description

[0027] Figure 1 This is a schematic flowchart of the computational task partial replay method according to an embodiment of this application;

[0028] Figure 2 This is a schematic diagram of the multidimensional execution graph snapshot and dependency mapping relationship in an embodiment of this application;

[0029] Figure 3 This is a schematic diagram of the affected node subgraph trimming process in an embodiment of this application;

[0030] Figure 4 This is a schematic diagram of the output drift report generation process according to an embodiment of this application;

[0031] Figure 5 This is a schematic diagram of the structure of a partial playback system for computing tasks according to an embodiment of this application. Detailed Implementation

[0032] To make the objectives, technical solutions, and advantages of this application clearer, the technical solutions in the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of this application.

[0033] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this application pertains.

[0034] Example 1

[0035] like Figure 1 As shown, this embodiment provides a method for partial replay of computing tasks. This method is applied to electronic devices or distributed computing clusters containing processors and memory, and is used to achieve efficient result reproduction and difference assessment when complex computing environments change. The method for partial replay of computing tasks includes the following steps.

[0036] Step S100: Obtain the multimodal environment dependencies of the computation task and generate a verification digest, constructing a multidimensional execution graph snapshot containing multidimensional topological dependencies. These multidimensional topological dependencies include data flow dependencies, execution control dependencies, and logical tracing dependencies. Specifically, a computation task typically consists of multiple interconnected computation nodes. The execution of each node depends not only on the output data of the upstream node but also deeply on the heterogeneous environment elements at runtime. Multimodal environment dependencies encompass structured data (such as input files and database records), unstructured configurations (such as prompt text for generative models and hyperparameter sets), and the runtime environment of external black-box toolchains (such as container image identifiers, dependency library versions, and driver fingerprints). The system standardizes and encapsulates these heterogeneous elements using a pre-defined digest algorithm, generating a unique verification digest, thereby solidifying the dispersed environment state into a verifiable digital representation. The multidimensional execution graph snapshot constructed on this basis is not merely a static log record of the task execution history but an executable model containing complete dynamic constraint relationships, recording the full context state of the task at a specific moment. Among these, data flow dependencies describe explicit data transfer paths between nodes, such as intermediate result files generated by an upstream node being read by a downstream node; execution control dependencies describe the temporal logic and conditional branches of task scheduling, such as determining subsequent execution paths based on the return values ​​of preceding nodes; and logical sourcing dependencies specifically refer to data references and constraint propagation relationships in a computer system, i.e., implicit coupling formed when the output object of an upstream node is used by a downstream node as a verification benchmark, boundary condition, or filtering threshold. For example, when the confidence threshold T output by node A is used by node B to filter candidate datasets, even if node B does not directly read node A's output file as input data, the system will still establish a logical sourcing dependency edge from A to B to represent this constraint propagation relationship. By constructing a multidimensional execution graph snapshot containing the above three-dimensional topology, the system can transform the originally discrete and implicit dependencies into a standardized graph structure that can be processed by a computer, laying a data foundation for subsequent precise influence domain analysis.

[0037] Step S200 involves detecting environmental differences between the target replay environment and the multidimensional execution graph snapshot. Specifically, when a historical computation task needs to be reproduced at a new time point or on a new computing cluster, the system automatically loads a pre-stored multidimensional execution graph snapshot and compares its recorded environmental state with the actual state of the current target replay environment item by item. This comparison is not limited to hash verification of file content, but also includes semantic-level comparison of unstructured configurations and mirror-level identification comparison of the toolchain environment. For example, the system can detect that the prompt word template of the generative model has undergone parameter adjustments, the container image version of the external simulation tool has been updated, or the feature vector of the input multimodal object has changed. By transforming abstract environmental changes into a specific list of differences, the system can accurately identify which environmental elements have changed relative to the original snapshot, thereby avoiding blind full recalculation caused by environmental inconsistencies.

[0038] Step S300 maps environmental differences to a multidimensional execution graph snapshot, determining affected nodes and their successor subgraphs based on multidimensional topological dependencies. Specifically, this step achieves automated correlation analysis from the "environment layer" to the "task graph." The system first locates directly related difference nodes in the multidimensional execution graph snapshot based on the type and content of the difference items. Then, the system traverses backwards based on multidimensional topological dependencies to identify all potentially affected successor nodes. In this process, logical sourcing dependencies play a crucial role, in addition to the regular propagation of data flow dependencies and execution control dependencies. When the verification baseline or boundary condition of a node fails due to changes in the upstream environment, even if the node's direct data input remains unchanged, the system will determine that the node is in a potentially risky state and include it in the affected scope. This cascading failure propagation mechanism based on multidimensional topology ensures the completeness of the impact domain pruning and prevents unreliable replay results due to the omission of implicit dependency nodes. Finally, the system prunes all identified affected nodes and their associated topological edges from the original graph, forming a simplified subgraph to be replayed. It should be understood that this pruning process is entirely based on the automated execution of graph algorithms, without the need for human intervention or manual selection, thus ensuring the objectivity and consistency of the replay strategy.

[0039] Step S400 involves performing a partial replay based on the affected nodes and their successor subgraphs, and generating an output drift report. Specifically, the system only re-executes the computational resources scheduled for the pruned successor subgraphs. For unaffected nodes outside the subgraphs, the original output objects cached in the multi-dimensional execution graph snapshot are directly reused. This partial replay strategy significantly reduces unnecessary redundant computations and greatly improves the utilization efficiency of computing resources. After replay, the system compares the newly generated output objects with the corresponding objects in the original snapshot in multiple dimensions and automatically generates an output drift report. This report quantifies the specific impact of environmental changes on the computation results, including but not limited to deviations in numerical precision, changes in data structures, or differences in text content. In this way, users can not only quickly obtain the latest computation results consistent with the current environment, but also clearly understand the specific degree of disturbance that environmental changes cause to the reliability of the results, thus providing an objective basis for subsequent decision-making or debugging.

[0040] Through steps S100 to S400, this embodiment abstracts heterogeneous multimodal dependencies into a unified state snapshot with a verification digest, and constructs an execution graph containing a three-dimensional topology of data, control, and logical traceability. This enables the system to go beyond simple file-level comparisons when the environment changes, accurately locating the affected scope from a semantic and constraint perspective. Simultaneously, by performing local replay only on the pruned successor subgraph, full recalculation of irrelevant nodes is avoided. Combined with the output drift report, automated quantitative assessment of the impact of environmental changes is achieved, effectively solving the technical problems of low result reproducibility and poor interpretability of differences in complex computational tasks.

[0041] Example 2

[0042] like Figure 2 As shown, this embodiment, based on Embodiment 1, further details the unified summary encapsulation and multi-dimensional topology construction mechanism for multimodal environment dependencies. As one implementation method, multimodal environment dependencies include generative model configurations, external computing toolchain environments, and multimodal input objects. This classification is not an arbitrary division based on business attributes, but rather an engineering decoupling based on the frequency of changes and impact mechanisms of dependent elements in the computing system. Specifically, generative model configurations represent semantic-level soft dependencies, where minor changes can lead to significant shifts in output results; external computing toolchain environments represent runtime hard dependencies, determining the basis for the reproducibility of the computing process; and multimodal input objects represent data-level entity dependencies, serving as the direct processing objects of the computing tasks. By explicitly classifying heterogeneous dependencies into these three categories, the system can adopt differentiated version management strategies for different categories, thereby solving the problem of coarse version tracking granularity caused by mixed dependency types in traditional technologies.

[0043] Building upon this foundation, the process of constructing a multidimensional execution graph snapshot containing multidimensional topological dependencies involves summarizing and encapsulating generative model configurations, external computing toolchain environments, and multimodal input objects to generate state snapshots with verification summaries. Simultaneously, data flow dependencies are constructed based on data transfer relationships between nodes in the computation task; execution control dependencies are constructed based on execution timing and conditional branches between nodes; and logical sourcing dependencies are constructed based on data references and constraint transfer relationships formed by upstream node output objects serving as verification benchmarks or boundary conditions for downstream nodes. This construction process unifies implicit relationships originally scattered across configuration files, container environments, and code logic into explicit topological edges in the graph structure, enabling the multidimensional execution graph snapshot to record not only "who generated what data" but also "who constrained whose execution logic."

[0044] Regarding the specific implementation of the above-mentioned summary encapsulation, as one approach, parametric hashing is performed on the unstructured prompt text and model parameters to generate a first verification summary of the generative model configuration. Specifically, since the prompts in generative models are typically unstructured natural language text, directly hashing the original text is highly susceptible to formatting noise (such as extra spaces, line breaks, and Unicode encoding differences), leading to situations where the semantics remain unchanged but the verification summary alters. Therefore, this embodiment employs a parametric hashing strategy. First, the prompt template is parsed, key parameter key-value pairs are extracted, sorted according to a preset lexicographical order, and serialized into a standard format (such as Canonical JSON). Then, the hash value is calculated in conjunction with model hyperparameters (such as temperature coefficient and Top-P value). This method ensures that the first verification summary only changes when the substantive semantic content of the prompt or the model inference parameters undergo a real change, thus achieving accurate capture of semantic-level changes. For external computing toolchain environments, container image identifiers and dependency library version identifiers are extracted to generate a second verification summary. The container image identifiers mentioned here preferably use digest values ​​generated by content-addressable storage mechanisms (such as Docker Digest SHA256) rather than volatile tag names to prevent environmental inconsistencies caused by tampering with the tags in the image repository. For multimodal input objects, multimodal feature extraction and hashing are performed to generate a third verification digest. For example, for image or spectral inputs, perceptual hashing algorithms or deep learning feature vectors can be used as the digest basis, giving it a certain degree of noise resistance and similarity measurement capability. Finally, the first, second, and third verification digests are jointly verified to generate a global verification digest of the state snapshot with verification digests. This joint verification mechanism ensures the atomicity of the snapshot state, that is, any change in dependency in any dimension will be reflected in the global digest, providing a reliable anchor point for subsequent integrity verification.

[0045] In constructing multidimensional topological dependencies, the generation of logical sourcing dependencies is a key feature that distinguishes this embodiment from conventional workflow engines. As one implementation method, logical sourcing dependencies are constructed based on the data references and constraint propagation relationships formed by using the output objects of upstream nodes as verification benchmarks or boundary conditions for downstream nodes. Specifically, this process does not rely on static code analysis or manual predefinition, but rather monitors the calling behavior of downstream nodes on the output objects of upstream nodes in real time during the execution of computation tasks. The system captures data access events between nodes by embedding monitoring probes or interceptors in the runtime environment. When it is detected that a downstream node uses the output object of an upstream node as a verification benchmark for error calculation or as a boundary condition for constraint pruning, a logical sourcing edge is automatically generated. For example, in an abstract computation scenario, node A is responsible for calculating and outputting a dynamic threshold T. Node B reads this threshold T as the upper limit of the filtering condition when performing data filtering. Although node B may not load node A's output file as a standard input port, the system automatically determines the existence of logical coupling when it detects that node B reads variable T for constraint judgment, and then generates a logical sourcing edge from node A to node B. Subsequently, the system records the logical sourcing edges, triggering conditions, and constraint parameters into the topology of the multidimensional execution graph snapshot. The triggering conditions describe the context in which the dependency takes effect (e.g., "only effective in filtering mode"), while the constraint parameters quantify the specific content of the dependency (e.g., "threshold T=0.85"). Through this runtime dynamic solidification mechanism, the system can explicitly transform the logical constraints hidden in the program execution flow into a traceable topology, effectively avoiding biases in impact domain assessment caused by missing dynamic dependencies in static analysis. This provides a precise data foundation for subsequent cascading failure propagation based on logical sourcing.

[0046] Example 3

[0047] like Figure 3 and Figure 4As shown, this embodiment, based on Embodiments 1 and 2, further details the difference mapping, subgraph pruning, and local replay execution strategy based on multidimensional topology. As one implementation method, environmental differences are mapped to a multidimensional execution graph snapshot, and affected nodes and their successor subgraphs are determined based on multidimensional topology dependencies. Specifically, this process is not a simple node labeling, but a dynamic influence domain calculation process. The system first identifies the difference nodes in the multidimensional execution graph snapshot that correspond to the environmental differences. For example, when a change in the container image identifier of an external computing toolchain environment is detected, the system locates all execution nodes that depend on that container image as difference nodes in the graph. Subsequently, the system propagates the influence domain from the difference nodes to their successor nodes based on data flow dependencies and execution control dependencies. This step covers conventional downstream data propagation and control flow reachability analysis. However, relying solely on these two dependencies often cannot cover all risks in complex computing scenarios. Therefore, the key to this embodiment is that when a difference node or its successor node has a logical tracing dependency, cascading failure propagation is triggered based on changes in verification benchmarks or boundary conditions, and nodes affected by cascading failures are added to the influence domain. Specifically, cascading failure propagation refers to a mechanism where, even if the direct input data file of a successor node remains unchanged at the bit level, if the parameters output by its upstream node—used by the successor node as a validation benchmark or filtering threshold—change, the execution logic of that successor node is effectively in a "constraint failure" state. For example, in a data processing task, node A is responsible for calculating a dynamic confidence threshold T, and node B uses this threshold T to filter candidate datasets. If node A's output threshold T changes from 0.8 to 0.9 due to a model configuration change, although the hash value of the original candidate dataset file read by node B remains unchanged, node B's filtering result will inevitably change. In this case, the system will capture this implicit change through logical sourcing dependency edges, forcibly including node B in the affected scope. In contrast, traditional scheduling engines based solely on data stream hash comparisons might mistakenly classify node B as "unaffected" and directly reuse the old result, leading to incorrect final output. By pruning the nodes within the influence domain and their associated topological edges into the affected nodes and their successor subgraphs, the system can construct a complete set to be replayed, which includes both explicit downstream data and implicit downstream constraints, ensuring the correctness and credibility of the local replay results.

[0048] After accurately identifying the subgraph to be replayed, the system performs a partial replay operation. As one implementation, partial replay is performed based on the affected nodes and their successor subgraphs. Specifically, the system traverses each node in the affected nodes and their successor subgraphs according to topological sorting. For each current node, the system calculates a checksum of all its input dependencies and environment dependencies in real time and compares it with the original checksum recorded in the multidimensional execution graph snapshot. Here, input dependencies refer to the data flow dependencies formed by the node receiving data input from upstream nodes, and the original checksum refers to the checksum generated and recorded in the multidimensional execution graph snapshot during the snapshot construction phase. If the checksums of all the current node's input dependencies and environment dependencies match the original checksum in the multidimensional execution graph snapshot, the original output object cached in the multidimensional execution graph snapshot is reused. This fine-grained cache reuse strategy allows "pseudo-affected nodes" that are on the topological path but whose actual inputs have not changed, even in larger affected subgraphs, to skip computation, further saving computing resources. Conversely, if the verification digest of the input dependencies or environment dependencies of the current node changes, the corresponding resources in the target replay environment are invoked to re-execute the current node. During execution, to ensure system robustness, a state rollback and isolation mechanism is triggered when an execution exception occurs. Specifically, the isolation mechanism can be implemented by creating an independent temporary workspace or sandbox container for each node to be replayed, ensuring that a single execution failure does not pollute the global environment or corrupt existing cached data. The rollback mechanism employs a transactional write strategy, atomically committing the new output object to the version store only after the node executes successfully and passes integrity verification. If execution fails, temporary artifacts are automatically discarded and the system is restored to the previous stable state. This design ensures the safety and controllability of the local replay process, avoiding the risk of the entire snapshot state being corrupted due to the failure of some nodes to retry.

[0049] After partial replay is completed, the system automatically generates quantitative evaluation results. As one implementation method, an output drift report is generated. Specifically, the system compares the new output object generated after partial replay with the original output object in the multidimensional execution graph snapshot from multiple dimensions, generating an output drift matrix that includes numerical drift, structural differences, and textual differences. Numerical drift is calculated for scalar or vector type outputs, determining absolute error, relative error, or distribution distance (such as KL divergence); structural differences are compared for graph, table, or tree objects, examining changes in the number of nodes, connection relationships, or field patterns; and textual differences are assessed for unstructured strings, using semantic similarity scoring or key entity extraction comparison to evaluate the degree of content change. This multidimensional drift matrix provides users with deeper insights beyond simple "success / failure" binary judgments, enabling them to quickly pinpoint the specific perturbation patterns of computational results caused by environmental changes. Furthermore, to meet the traceability requirements in high-compliance scenarios, when the state of the computation task meets preset freezing conditions, a state freezing mechanism is triggered, setting the multidimensional execution graph snapshot and output drift report to an immutable state and storing them in tamper-proof storage media. It is important to note that the freezing conditions here refer to internal status indicators of the computer system, such as "task completion," "full verification passed," or "version release confirmed," which are technical events automatically detected by the system or triggered by the user through standard interfaces, rather than relying on external business processes or unstructured administrative instructions. Tamper-proof storage media can be implemented using write-once-read-many (WORM) storage devices, blockchain evidence services, or cloud storage services with object locking capabilities. In this way, the system can technically guarantee the legal validity and audit traceability of critical computing processes and results, providing an objective and irrefutable data foundation for subsequent version evolution or compliance reviews.

[0050] Example 4

[0051] like Figure 5 As shown, this embodiment provides a partial replay system for computing tasks. This device is a physical architecture of the aforementioned method embodiments at the computer system level, aiming to achieve efficient management and accurate replay of complex computing tasks through modular functional decoupling and standardized data collaboration. The partial replay system for computing tasks includes a snapshot construction module, a difference detection and pruning module, and a partial replay module.

[0052] The snapshot building module is used to acquire the multimodal environment dependencies of computing tasks and generate verification summaries, constructing a multidimensional execution graph snapshot containing multidimensional topological dependencies. These multidimensional topological dependencies include data flow dependencies, execution control dependencies, and logical tracing dependencies. Specifically, the snapshot building module is not a simple logger, but a digital twin building unit for the runtime state of computing tasks. Internally, this module can be further subdivided into a dependency acquisition unit, a summary calculation unit, and a topology resolution unit. The dependency acquisition unit captures heterogeneous elements such as generative model configurations, external computing toolchain environments, and multimodal input objects in real time by embedding runtime probes or interceptors. The summary calculation unit performs parameterized hashing or feature extraction on the acquired elements to generate stable verification summaries. The topology resolution unit is responsible for analyzing explicit data flows, control flows, and implicit logical tracing relationships between nodes, solidifying them into a graph structure. It should be understood that although the diagram shows each unit integrated within the same module, in other embodiments, these units can also be deployed as independent microservices or plugins, as long as they can collaboratively complete the snapshot building function. Through this structured design, the snapshot building module can encapsulate the scattered and dynamic runtime states into standardized multidimensional execution graph snapshots, providing a complete and reliable data foundation for subsequent differential analysis and playback.

[0053] The difference detection and pruning module detects environmental differences between the target playback environment and the multidimensional execution graph snapshot, maps these differences to the multidimensional execution graph snapshot, and determines the affected nodes and their successor subgraphs based on multidimensional topological dependencies. Specifically, this module acts as the system's intelligent analysis engine, its core capability being the transformation of abstract environmental changes into precise graph operations. Internally, the module typically includes an environment comparison unit, an influence domain propagation unit, and a subgraph pruning unit. The environment comparison unit compares the current environment with the verification summary recorded in the snapshot, identifying differences. The influence domain propagation unit loads the topology from the snapshot, starting from the differing nodes and traversing bidirectionally or unidirectionally along data flow dependencies, execution control dependencies, and key logical tracing dependencies to calculate the complete set of affected nodes. The subgraph pruning unit then extracts a simplified subgraph containing all affected nodes and their associated edges from the original graph based on the calculation results. This dynamic pruning mechanism based on graph algorithms allows the device to adapt to arbitrarily complex task topologies, avoiding maintenance difficulties and omission risks caused by hard-coded dependency rules, and ensuring the completeness and accuracy of influence domain assessment.

[0054] The local replay module performs local replay based on affected nodes and their successor subgraphs, generating an output drift report. Specifically, this module acts as the system's execution controller and result evaluator. It receives the pruned subgraph as input, combines it with cached historical output objects from snapshots, and intelligently schedules computing resources. For nodes whose input and environment dependencies remain unchanged, the module directly reuses cached results; for nodes that have changed, it calls the corresponding resources in the target environment to re-execute, implementing state isolation and anomaly rollback protection during execution. After replay, the module automatically compares the old and new output objects, generating an output drift report that includes differences in numerical values, structure, and text. In this way, the local replay module not only optimizes the use of computing resources but also provides users with a quantified view of result changes, supporting a deep understanding of the evolution of computing tasks.

[0055] In this embodiment, the collaborative work between the modules is not achieved through tight coupling methods such as direct function calls or shared memory, but rather through standardized data interaction via snapshot package objects. Specifically, the snapshot package object, as a self-contained data contract, carries all the context information required for inter-module communication. After completing the construction, the snapshot building module persistently stores the generated snapshot package object or passes it downstream; the difference detection and pruning module reads the list field and topology field in the object for analysis, and updates the object with the pruning results or generates a new playback plan object; the partial playback module then performs specific scheduling and comparison operations based on the strategy field and topology field in the object. This interaction mode based on standardized objects brings significant technical benefits: On the one hand, it achieves complete decoupling of the modules in engineering implementation, allowing different modules to use different programming languages, frameworks, or even be deployed on different physical nodes, greatly improving the scalability and maintainability of the system; on the other hand, the snapshot package object itself has self-descriptiveness and integrity, making the entire device's processing process naturally traceable and auditable. Even in offline environments or cross-system migration scenarios, the execution context and playback logic of the computing task can be completely restored based solely on this object, thereby effectively ensuring the robustness and flexibility of complex computing task management.

[0056] Example 5

[0057] This embodiment further details the specific data structure of the snapshot package object used for data interaction between the snapshot construction module, the difference detection and pruning module, and the partial playback module. This snapshot package object is the core carrier of the technical solution at the engineering implementation level. Its design follows the principles of self-containment and self-description, aiming to solidify the abstract computational task execution context into a standardized data entity that can be independently stored, transmitted, and parsed. Specifically, the snapshot package object includes an identifier field, a manifest field, a topology field, and a policy field. This structured data organization method allows each functional module to obtain complete task information without relying on external databases or global states, thereby achieving complete decoupling of the system architecture. Simultaneously, since this object completely records the environmental fingerprint and dependency topology during task execution, it is also the most direct and reliable data source for subsequent difference analysis, partial playback, and even compliance auditing.

[0058] The identifier field is used to uniquely identify snapshot package objects and their respective projects. In practice, the identifier field typically uses a globally unique identifier (UUID) or a hash value generated based on content addressing to ensure that snapshot package objects generated on different computing clusters or at different points in time do not conflict. Furthermore, the identifier field can also contain metadata such as project namespace, branch identifier, or version number to facilitate rapid retrieval and association within a multi-level project management system. For example, in a development project with multiple iterations, the system can automatically construct the evolutionary lineage of snapshot packages using the version sequence number in the identifier field, providing an index foundation for subsequent version comparisons and backtracking.

[0059] The manifest fields include an object manifest, a prompt word manifest, and an environment manifest, which record verification summaries of multimodal input objects, generative model configurations, and external computing toolchain environments, respectively. These three manifests constitute a digital fingerprint of the snapshot package object's environment state. Specifically, the object manifest records unique identifiers and integrity verification values ​​for all input files, intermediate products, and output results, ensuring the immutability of data entities; the prompt word manifest not only records the parameterized hash values ​​of the generative model's prompt word text but can also selectively retain key-value pair mappings or anonymized template structures of key parameters to help pinpoint whether playback failures are caused by semantic changes or format noise; the environment manifest records detailed content summaries of the container image, precise version numbers of dependent libraries, and fingerprint information of runtime drivers. It should be understood that the design of manifest fields is not limited to these three types. In practical applications, database connection manifests, external API service manifests, or hardware accelerator configuration manifests can be added, depending on the characteristics of the computing task, as long as they provide summary information for environment consistency verification.

[0060] The topology field records node information and edge information for data flow dependencies, execution control dependencies, and logical sourcing dependencies in the multidimensional execution graph snapshot. This is the most technically advanced part of the snapshot package object, statically transforming dynamic execution logic into a queryable graph structure. For node information, the topology field records the input / output port definitions, execution code references, and resource quota requirements for each compute node. For edge information, in addition to regular data flow edges and control flow edges, the topology field uses a structured approach to store logical sourcing dependencies. Specifically, each logical sourcing dependency edge is represented in the topology field as a composite record containing a source node identifier, a target node identifier, a constraint type, and a triggering condition expression. For example, when the confidence threshold output by an upstream node is used as a filtering condition by a downstream node, a record is generated in the topology field, explicitly indicating that the source node is a "threshold calculation node," the target node is a "data filtering node," the constraint type is "boundary condition pruning," and the triggering condition expression is "input.confidence >= upstream.threshold." This explicit structured storage allows the system to directly reconstruct the implicit logical coupling relationships between nodes by simply reading the constraint records in the topology field, without needing to re-parse the code or run the probe during the playback phase. This greatly improves the accuracy and efficiency of influence domain analysis.

[0061] The strategy field records the replay mode, caching strategy, and difference comparison range. This field endows the snapshot package object with behavioral semantics, making it not just a static historical archive, but also an executable set of instructions. The replay mode can be specified as full replay, partial replay, or comparative replay to adapt to different verification needs; the caching strategy defines which intermediate results are allowed to be reused and which must be forcibly recalculated, thereby achieving a balance between computational consumption and result timeliness; the difference comparison range limits the dimensions of the output drift report generation, such as focusing only on changes in numerical precision or focusing on semantic deviations in textual conclusions. By encapsulating these control parameters within the snapshot package object, the system can ensure consistent replay behavior of the same snapshot package in different execution environments, avoiding uncertainty in reproduction results caused by external configuration drift.

[0062] In summary, the snapshot package object defined in this embodiment achieves complete encapsulation of the execution context of complex computing tasks through the organic combination of four types of fields: identifier, list, topology, and strategy. This self-contained data structure not only supports efficient collaboration and decoupling design between various modules of the device, but more importantly, it concretizes abstract technical features such as "logical source dependence" into computer-readable, storable, and comparable entity data, providing a solid material foundation for infringement determination and compliance auditing of the technical solution of this application. It should be understood that the specific naming, data types, and nesting levels of the above fields are merely illustrative examples. Without departing from the core concept of this application, those skilled in the art can adaptively adjust the above structure according to actual storage formats (such as JSON, Protocol Buffers, XML, etc.) or business needs, and these variations should all be covered within the protection scope of this application.

[0063] Example 6

[0064] This embodiment provides an electronic device, including a processor and a memory. The memory stores a computer program, and when the processor executes the computer program, it implements a partial playback method for the computational task as described in any one of embodiments 1 to 3. Specifically, the electronic device can be any hardware entity with data processing capabilities, such as a server, workstation, personal computer, mobile terminal, or embedded computing device. The processor can include one or more combinations of a central processing unit, graphics processing unit, network processor, or application-specific integrated circuit (ASIC), used to provide the computing power support required to execute the above method. The memory can include high-speed random access memory, and can also include non-volatile memory, such as at least one disk storage device, flash memory device, or other solid-state storage device, used to persistently store the computer program instructions implementing the above method, as well as data objects such as multidimensional execution graph snapshots, verification summaries, and output drift reports generated during operation. When the computer program is loaded and run by the processor, the electronic device is configured as a dedicated computing device to perform a series of specific technical actions, such as acquiring multimodal environment dependencies, constructing multidimensional topology, detecting environmental differences, pruning affected subgraphs, and generating output drift reports, thereby implementing the technical solution of this application at the physical level.

[0065] This embodiment also provides a computer-readable storage medium storing a computer program thereon. When executed by a processor, the program implements the partial playback method of the computational task as described in any one of embodiments 1 to 3. Specifically, the computer-readable storage medium can be any tangible medium containing or storing a program, including but not limited to electrical, magnetic, optical, electromagnetic, infrared, or semiconductor systems, devices, or apparatuses. For example, the storage medium can be a read-only memory, random access memory, optical disc, magnetic disk, USB flash drive, portable hard drive, or virtual storage volume in a cloud storage service. By embedding the computer program implementing the above method in the storage medium, the technical solution of this application can be distributed, sold, or deployed as an independent software product. When a user installs or loads the program in the storage medium onto any compatible electronic device, the device can then perform accurate partial playback and result drift evaluation of complex computational tasks. This hardware-software separation protection method not only ensures the portability and consistency of the technical solution across different hardware platforms but also provides a standardized delivery carrier for subsequent software licensing, version updates, and compliance audits, further expanding the commercial application boundaries of the technical solution of this application.

[0066] Example 7

[0067] This embodiment provides a partial replay application scenario for materials research and development tasks on the AI4S platform. This scenario is a specific implementation of the partial replay method for computational tasks described in Embodiments 1 to 6 above in the fields of scientific computing and materials discovery. It should be understood that although this embodiment uses materials research and development as an example, this is only to more clearly illustrate the application mechanism of the technical solution in a complex heterogeneous computing environment and does not constitute a limitation on the scope of protection of this application. In other embodiments, this technical solution is also applicable to complex computational task scenarios involving multimodal dependencies and black-box toolchains, such as drug molecule screening, weather simulation and prediction, and financial risk control modeling.

[0068] In this application scenario, the computational task typically manifests as a long-chain workflow encompassing literature analysis, structure generation, property prediction, simulation optimization, and result analysis. Unlike general data processing tasks, such tasks involve not only explicit data file transfers between nodes but also extensive implicit constraints based on scientific principles. For example, the physical model parameters output by upstream nodes often serve as boundary conditions or convergence criteria for downstream node simulation calculations; this relationship corresponds to the logical source dependency in the aforementioned embodiment. Simultaneously, the task is highly dependent on external scientific computing toolchains (such as quantum chemistry software and molecular dynamics engines) and generative model configurations; even minor changes to these elements can lead to significant drift in the final research conclusions. This embodiment effectively solves the problem of full recalculation or unreliable results caused by the inability of traditional workflow engines to identify implicit dependencies when processing such scientific computing tasks by applying the aforementioned multidimensional execution graph snapshot and local replay mechanism.

[0069] Specifically, taking a typical transitional state search task as an example, this task includes multiple computational nodes such as literature data mining, initial structure generation, potential energy surface scanning, transitional state optimization, and reaction barrier analysis. When the version of the potential energy surface model in the system is updated, this is a change in the external computational toolchain environment. The system will generate a new second verification summary and detect the environmental difference. According to the difference mapping and subgraph pruning mechanism described in Example 3 above, the system first locates the environmental difference to the "transitional state optimization node" that directly calls the potential energy surface model. Subsequently, the system backpropagates the influence domain based on multidimensional topological dependencies. In this process, logical tracing dependencies play a key role: although the "reaction barrier analysis node" does not directly read the configuration file of the potential energy surface model, its computational logic relies on the energy extremum point coordinates output by the "transitional state optimization node" as a verification benchmark. When the change of the potential energy surface model causes a change in the accuracy or numerical range of the energy extremum point coordinates, the system determines that the verification benchmark of the "reaction barrier analysis node" has become invalid through the detected logical tracing dependency edges, thereby automatically including it in the affected subgraph. Meanwhile, for the "literature data mining node" and "initial structure generation node" located upstream in this path, since their output objects neither depend on the potential energy surface model nor are referenced as dynamic constraints by downstream affected nodes, the system determines that they are outside the influence domain and directly reuses the original output objects cached in the multidimensional execution graph snapshot. In this way, the system accurately skips the time-consuming literature parsing and structure generation process, performing only partial replay on the optimization and analysis stages that are truly affected by the model version, significantly shortening the R&D iteration cycle while ensuring the scientific rigor of the results.

[0070] As another alternative implementation, in the design scenario of metal-organic frameworks (MOF) materials, the technical solution of this application also demonstrates a refined control over heterogeneous dependencies. In this scenario, the computational task involves generating candidate structures based on the topology network, evaluating porosity using an aperture calculator, and ranking candidates based on performance indicators. When the container image identifier of the external black-box tool, the aperture calculator, changes, the system can identify that only the "aperture evaluation node" and its subsequent "candidate ranking node" and "report generation node" need to be re-executed. It is worth noting that since upgrades to the aperture calculator may change the porosity calculation algorithm or unit conversion logic, even if the hash value of the input MOF structure file remains unchanged, the system will trigger cascading failure propagation due to the "computation tool version constraint" recorded in the logical tracing dependency, forcing a recalculation of the evaluation node. This avoids the risk of algorithm-level changes that may be missed by traditional file-level comparison mechanisms. Furthermore, for structure generation nodes assisted by generative models, if only the synthesis feasibility constraint parameters in the prompt words are adjusted, the system will capture the change in the first verification digest through the parameterized hashing mechanism, and accurately locate the structure generation node and all downstream evaluation nodes that depend on the structure for replay, while the pure theoretical calculation branch unaffected by the prompt words remains unchanged.

[0071] After partial replay is completed, the system-generated output drift report provides researchers with quantitative decision support. In the aforementioned transitional search or MOF design cases, the output drift matrix not only demonstrates the absolute error of the old and new versions of the tool on a single numerical indicator, but also includes a comparison of structural differences in the candidate material ranking list. For example, the report can clearly indicate that the upgrade of the potential energy surface model caused a candidate material that was originally ranked 3rd to drop to 8th, or that the aperture calculator algorithm adjustment caused the screening pass rate of a certain type of material to decrease by 15%. This multi-dimensional drift analysis directly maps the underlying environmental changes into an impact assessment on the credibility of research conclusions, helping researchers quickly determine whether to adopt the calculation results of the new version or revert to the old version to maintain the consistency of historical data. At the same time, when the task status meets the preset freezing conditions (such as passing the stage verification), the system locks the current snapshot package object and the output drift report into an immutable state, providing a complete and traceable chain of technical evidence for subsequent compliance audits or intellectual property rights confirmation.

[0072] In summary, this embodiment applies the abstract method of partial replay of computational tasks to a specific materials research and development scenario, verifying the unique advantages of the technical solution in handling the black-box toolchains, unstructured prompts, and complex verification logic unique to scientific computing. Compared to general CI / CD pipelines or simple file version management systems, this application, by constructing a multi-dimensional execution graph snapshot containing logical source dependencies, achieves digital representation and precise control of implicit knowledge flow in scientific computing tasks. This maximizes the utilization efficiency of computing resources and the agility of research and development iterations while ensuring the reproducibility of research results.

[0073] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any person skilled in the art can easily conceive of variations or substitutions within the technical scope disclosed in this application, such as extending the topological dependency types in the multidimensional execution graph snapshot, adjusting the verification digest generation algorithm, redefining the logical sourcing dependency triggering conditions, or adaptively modifying the field structure of the snapshot package object, etc., as long as they do not depart from the core technical concept of this application regarding the unified abstraction of heterogeneous dependencies, the propagation of multidimensional topological influence domains, and local replay, they should all be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

Claims

1. A method for local replay of a computational task, characterized in that, include: Obtain the multimodal environment dependencies of the computation task and generate a verification summary, and construct a multidimensional execution graph snapshot containing multidimensional topological dependencies; The multimodal environment dependencies include generative model configuration, external computation toolchain environment, and multimodal input objects; The multidimensional topological dependencies include data flow dependencies, execution control dependencies, and logical tracing dependencies; Detect the environmental differences between the target playback environment and the multidimensional execution graph snapshot; The environmental differences are mapped to the multidimensional execution graph snapshot, and the affected nodes and their successor subgraphs are determined based on the multidimensional topological dependencies. Perform local playback based on the affected nodes and their successor subgraphs, and generate an output drift report; The construction of a multidimensional execution graph snapshot containing multidimensional topological dependencies includes: The generative model configuration, the external computing toolchain environment, and the multimodal input object are respectively digested and encapsulated to generate a state snapshot with a verification digest; The data flow dependency is constructed based on the data transfer relationship between nodes in the computing task; the execution control dependency is constructed based on the execution timing and conditional branches between nodes; and the logical tracing dependency is constructed based on the data reference and constraint transfer relationship formed by the output object of the upstream node as the verification benchmark or boundary condition of the downstream node. The step of mapping the environmental differences to the multidimensional execution graph snapshot and determining the affected nodes and their successor subgraphs based on the multidimensional topological dependencies includes: Identify the difference nodes in the multidimensional execution graph snapshot that correspond to the environmental differences; Based on the data flow dependency and the execution control dependency, the influence domain is propagated from the difference node to the successor node; When the differential node or its successor node has the logical tracing dependency, the cascading failure propagation is triggered based on the change of the verification benchmark or boundary conditions, and the node affected by the cascading failure is added to the influence domain. The nodes within the influence domain and their associated topological edges are clipped into the affected nodes and their successor subgraphs.

2. The method for local replay of a computational task according to claim 1, characterized in that, The process of digesting and encapsulating the generative model configuration, the external computing toolchain environment, and the multimodal input object to generate a state snapshot with a verification digest includes: Perform parameterized hash calculation on the unstructured prompt text and model parameters to generate the first verification digest of the generative model configuration; Extract the container image identifier and the dependency library version identifier to generate a second verification digest of the external computing toolchain environment; Multimodal feature extraction and hashing are performed on the multimodal input object to generate a third verification digest; The first verification digest, the second verification digest, and the third verification digest are jointly verified to generate a global verification digest of the state snapshot with the verification digest.

3. The method for local replay of a computational task according to claim 1, characterized in that, The logical tracing dependency is constructed by establishing data references and constraint propagation relationships based on the output objects of upstream nodes as verification benchmarks or boundary conditions for downstream nodes, including: During the execution of the computation task, the behavior of downstream nodes calling the output objects of upstream nodes is monitored; When it is identified that the downstream node uses the output object of the upstream node as a verification benchmark for error calculation or as a boundary condition for constraint pruning, a logical tracing edge is automatically generated. The logical tracing edges, triggering conditions, and constraint parameters are recorded in the topology of the multidimensional execution graph snapshot.

4. The method for partial replay of a computational task according to claim 1, characterized in that, The process of performing local replay based on the affected nodes and their successor subgraphs includes: Traverse the affected nodes and each node in the successor subgraph; If the verification digest of all input dependencies and environment dependencies of the current node is consistent with the original verification digest in the multidimensional execution graph snapshot, then the original output object cached in the multidimensional execution graph snapshot is reused. If the verification digest of the input dependency or environment dependency of the current node changes, the corresponding resource in the target replay environment is invoked to re-execute the current node, and a state rollback and isolation mechanism is triggered when an execution exception occurs.

5. The method for local replay of a computational task according to claim 1, characterized in that, The generated output drift report includes: The new output object generated after partial replay is compared with the original output object in the multidimensional execution graph snapshot in multiple dimensions to generate an output drift matrix that includes numerical drift, structural differences and textual differences. When the state of the computation task meets the preset freezing conditions, the state freezing mechanism is triggered, and the multidimensional execution graph snapshot and the output drift report are set to an immutable state and stored in an anti-tampering storage medium.

6. A partial playback system for a computational task, characterized in that, include: The snapshot building module is used to obtain the multimodal environment dependencies of computing tasks and generate a verification summary, and build a multidimensional execution graph snapshot containing multidimensional topological dependencies; The multidimensional topological dependencies include data flow dependencies, execution control dependencies, and logical tracing dependencies; The difference detection and pruning module is used to detect the environmental differences between the target playback environment and the multidimensional execution graph snapshot, map the environmental differences to the multidimensional execution graph snapshot, and determine the affected nodes and their successor subgraphs based on the multidimensional topological dependencies. A local replay module is used to perform local replay based on the affected node and its successor subgraph, and generate an output drift report. The local replay system of the computing task is used to execute the local replay method of the computing task as described in any one of claims 1 to 5.

7. The partial playback system for computational tasks according to claim 6, characterized in that, The snapshot construction module, the difference detection and cropping module, and the local playback module interact with each other through a snapshot package object. The snapshot package object includes: An identifier field is used to uniquely identify the snapshot package object and its associated project; The list fields include an object list, a prompt word list, and an environment list, which respectively record the verification summaries of multimodal input objects, generative model configurations, and external computing toolchain environments; The topology field records the node information of the multidimensional execution graph snapshot and the edge information of the data flow dependency, execution control dependency and logical tracing dependency; The strategy field records the playback mode, caching strategy, and the range of differences for comparison.

8. An electronic device comprising a processor and a memory, wherein the memory stores a computer program, characterized in that, When the processor executes the computer program, it implements the partial playback method of the computational task as described in any one of claims 1 to 5.

Images