Artificial intelligence task execution method, system and device based on three-graph decoupling and profile binding

Abstract

The application discloses a kind of based on three graph decoupling and Profile binding artificial intelligence task execution method, system and equipment.The method obtains self-contained execution data packet, which includes the business logic graph defining calculation node and to be assigned variable, the running control graph defining candidate executor and scheduling constraint, and the binding relationship graph including multiple configuration profiles.System selects target configuration profile according to current operating environment, and in the compilation phase, the binding relationship graph is executed target selector unfolding and conflict resolution, and candidate control node is compiled into node-level runtime execution contract.Subsequently, according to the contract, ready nodes are dynamically scheduled, triggering target executor to perform tensor calculation and variable assignment and update memory state.The application realizes three-layer decoupling of business logic, control capability and scenario-based binding strategy, supports the same business graph to quickly adapt to different computing power environment by switching profile, completely eliminates hard coding, and greatly improves model asset reuse rate.

Description

Technical Field

[0001] This invention belongs to the fields of artificial intelligence, graph computing and heterogeneous computing resource scheduling technology, and in particular relates to an artificial intelligence task execution method, system and device based on three-graph decoupling and profile binding. Background Technology

[0002] Existing systems based on Large Language Models (LLM) typically employ graph computing frameworks as their underlying support architecture when constructing complex computational workflows. By defining the dependencies between graph nodes and integrating relevant parameters such as system prompts, computing power configurations, and execution rules, they can decompose and advance complex computational tasks and complete various solution tasks by relying on the inference capabilities of the large language model.

[0003] However, during the process of implementing the technology, the inventors discovered that the existing technology has at least the following computer technology problems that urgently need to be solved:

[0004] Technical Issue 1: Deep coupling between the computational logic ontology and the underlying computing power scheduling / hardware resource constraints. Existing graph computing frameworks typically hard-code configurations such as system prompts, computing power consumption limits (e.g., token or call count limits), execution order, verification rules, and stopping conditions directly into node attributes. This coupling makes it difficult for the computational logic model to remain stable, and the same computational logic cannot be reused under different hardware resource constraints (e.g., low-computing-power environments and high-computing-power environments).

[0005] Technical Issue 2: Lack of an independent scenario-based configuration routing mechanism. Even when some systems attempt to decouple configuration, they often simply use static mapping tables for hard-coded binding. When faced with different computing power environments or diverse business requirements such as low-end, medium-end, and high-end configurations, multiple complete sets of control logic still need to be rewritten or maintained. This makes it impossible to achieve flexible switching between "one business diagram + one candidate control diagram + multiple binding profiles," resulting in low model asset reuse rate.

[0006] Technical Issue 3: Graph computing structures lack self-contained cross-environment portability. Due to the mixing of configuration and problem definition, traditional graph models often only describe the structure and dependencies, heavily relying on the hard-coded logic of external host programs at runtime. The graph itself cannot be executed as an independent runtime package, resulting in a separation between the "problem definition" and the "solution path," and the system lacks the ability to be migrated across servers as a whole and delivered as a package.

[0007] Technical Issue 4: Lack of graph-level dynamic control and recovery mechanisms to address the nondeterministic computational power consumption of large models. The derivation of large models is highly nondeterministic, and the execution chain is often long. Existing systems struggle to dynamically support depth-first (DFS) / breadth-first (BFS) routing switching, global computational quota circuit breaking, checkpoint memory snapshot saving, breakpoint resumption, concurrent execution, and relay execution of multiple heterogeneous execution modules (such as multiple models with different parameter scales) during graph computation. Summary of the Invention

[0008] The purpose of this invention is to provide an artificial intelligence task execution method, system, and device based on three-graph decoupling and profile binding. By reconstructing the underlying data structure, it solves the technical problems in the prior art, such as coupling of computational logic and runtime configuration, lack of multi-scenario profile configuration switching capability, lack of compile-time static checking, and difficulty in achieving dynamic control of complex resources.

[0009] To achieve the above objectives, the technical solution of the present invention is summarized as follows:

[0010] On one hand, this invention provides an artificial intelligence task execution method based on three-graph decoupling and profile binding, executed by a computer device, specifically including:

[0011] Obtain a serialized self-contained execution data packet, the execution data packet including an independently encapsulated business logic diagram, a runtime control diagram, and a binding relationship diagram containing multiple configuration profiles; wherein, the business logic diagram includes computing nodes with defined unassigned variables, and the runtime control diagram includes multiple candidate control nodes for constraining computer hardware resources and execution strategies;

[0012] Based on the current operating environment, user commands, resource constraints, or service level parameters, determine the target configuration profile from the binding relationship diagram;

[0013] Based on the target configuration profile, target selector expansion and conflict resolution are performed on the binding relationship graph, and candidate control nodes in the runtime control graph are compiled and parsed into node-level runtime execution contracts corresponding to the target objects in the business logic graph.

[0014] Based on the topology of the business logic graph and the current variable assignment state, dynamically determine the executable computing nodes that currently meet the input dependency conditions;

[0015] According to the node-level runtime execution contract, the target executor is triggered to perform tensor calculations and variable assignments on the executable computing node, and update the memory state of the business logic graph until the preset calculation termination condition is met.

[0016] Each binding edge in the binding relationship graph includes at least one of the following: business logic graph target selector, runtime control graph node reference identifier, scope, configuration profile identifier, activation condition, priority, merging rule, or conflict resolution rule.

[0017] The business logic diagram target selector is used to select at least one of the following: the overall business logic diagram, a local subgraph, a layer level, a set of node types, a set of node labels, a specific business node, a specific data flow edge, a set of variables, or an execution stage.

[0018] The candidate control nodes in the operation control diagram include at least one of the following: concurrent and traversal routing nodes, computing power quota nodes, computing termination nodes, state snapshot nodes, executor allocation nodes, data pattern verification nodes, and global static parameter nodes.

[0019] Prior to performing target selector expansion and conflict resolution on the binding graph based on the target configuration profile, the method further includes:

[0020] A static graph compilation check is performed on the self-contained execution data package to verify the topological legality of the business logic graph, the version compatibility of the target configuration profile and the candidate control node, and the data source completeness of the unassigned variables, thereby intercepting illegal memory access and invalid binding.

[0021] The step of performing static graph compilation checks on the self-contained execution data package includes:

[0022] The business logic diagram is subjected to input source tracing checks, data type domain checks, and dead node checks.

[0023] When the business logic graph is a directed acyclic graph, a topology sorting check is performed;

[0024] When the business logic graph is a general directed graph, strong connectivity component analysis is performed to identify feedback loops.

[0025] The step of compiling and parsing the candidate control nodes in the runtime control graph into node-level runtime execution contracts corresponding to the target objects in the business logic graph based on the target configuration profile includes:

[0026] If the binding edge in the target configuration profile indicates that the control node acts on the global domain of the business logic graph, then the control node is resolved into a global runtime variable;

[0027] If the binding edge in the target configuration profile indicates that the control node acts on a local subgraph, then the control node is resolved as a local execution strategy;

[0028] If the binding edge in the target configuration profile indicates that the control node acts on a specific compute node, then the control node is resolved to the node-level runtime execution contract of the compute node.

[0029] The dynamic determination of the executable computing node that currently satisfies the input dependency conditions includes:

[0030] Traverse the topology of the business logic graph, extract the computing nodes where all current input data has resided in memory, and dynamically generate a set of ready nodes.

[0031] The triggering target executor performs tensor calculations and variable assignments on the executable computing node, including:

[0032] Read the concurrent and traversal routing nodes in the node-level runtime execution contract to determine the graph traversal algorithm and concurrency.

[0033] Based on the graph traversal algorithm and concurrency, one or more target nodes are extracted from the ready node set, and the target executor is concurrently invoked for computation. The runtime control graph contains multiple candidate executor allocation nodes; different configuration profiles bind target objects in the same business logic graph to different candidate executor allocation nodes in the runtime control graph by activating different binding edges.

[0034] The triggering target executor performs tensor calculations and variable assignments on the executable computing node, including:

[0035] Based on the node-level runtime execution contract, identify the target executor allocation node to which the currently executable computing node is bound;

[0036] Based on the target executor allocation node, the network routing interface or memory context is dynamically switched, and a specific parameter scale model or heterogeneous agent matching the executable computing node is invoked for relay computing. In this process, at least one configuration profile in the binding relationship graph inherits some binding edges from another configuration profile, and replaces executor allocation nodes, concurrent and traversal routing nodes, computing power quota nodes, or computing termination nodes bound to specific business nodes, node types, or local subgraphs by overriding these binding edges.

[0037] The step of updating the memory state of the business logic graph includes:

[0038] The pattern and type of the variable assignment result are validated using the validation rules derived from the data pattern validation node.

[0039] After the verification is passed, the output variables of the computing node are mapped and propagated to the input variable domain of the downstream nodes;

[0040] Based on the rules defined for the state snapshot nodes, the current variable assignment table, the current set of ready nodes, and the current computing power consumption statistics are serialized and saved to a non-volatile storage medium to generate a checkpoint snapshot that can be used for breakpoint recovery. The method also includes a breakpoint recovery mechanism, comprising:

[0041] When a computing power quota exhaustion exception or external interruption signal is detected, the current computing process is suspended.

[0042] In response to a recovery command, the most recently saved checkpoint snapshot is deserialized and loaded from the non-volatile storage medium;

[0043] The variable assignment table and ready node set in main memory are reconstructed using the checkpoint snapshot, and the calculation of subsequent nodes continues directly from the reconstructed ready node set. Specifically, when the business logic graph is a general directed graph containing feedback loops, and the static graph compilation check identifies strongly connected components, updating the memory state of the business logic graph includes:

[0044] A fixed-point iterative algorithm is used to repeatedly calculate within the strongly connected component, and the rate of change of the variable matrix within the strongly connected component is monitored in real time.

[0045] When the rate of change of the numerical value is lower than the preset convergence threshold, or when the number of iterations reaches the maximum number of iteration rounds defined in the node-level runtime execution contract, it is determined that the calculation of the strongly connected component is completed, and the memory state is propagated to the downstream nodes outside the strongly connected component.

[0046] On the other hand, the technical solution of the present invention also provides a method for generating a self-contained execution data package for artificial intelligence, executed by a computer device, specifically including:

[0047] In response to the first structure construction instruction, a business logic diagram is generated. The computing nodes of the business logic diagram only contain data input / output declarations and variable patterns, and do not contain resource call instructions.

[0048] In response to the second structure construction instruction, an operation control diagram independent of the business logic diagram is generated. The operation control diagram contains multiple candidate control nodes for constraining computing power quotas, state snapshots, and concurrency and traversal routing strategies.

[0049] In response to the mapping configuration command, a binding relationship graph containing multiple configuration profiles is generated. The binding edges in the binding relationship graph, under different configuration profiles, will directionally bind the candidate control nodes in the operation control graph to the specified objects in the business logic graph.

[0050] The business logic diagram, the operation control diagram, and the binding relationship diagram are serialized and encoded, and packaged to generate a self-contained execution data package. This enables heterogeneous computing engines to perform calculations based on the same business logic diagram and the same operation control diagram, simply by switching configuration profiles to load different computing power and state control strategies.

[0051] In another aspect, the present invention also provides a computer system, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the method steps described above.

[0052] In another aspect, the present invention also provides a computer-readable storage medium storing a computer program, which, when executed by a processor, implements the method steps described above.

[0053] To address the aforementioned technical problems one and two, one aspect of this invention provides an artificial intelligence task execution method based on three-graph decoupling and profile binding. This method reconstructs the system into a ternary decoupled structure of "business logic graph + operation control graph + binding relationship graph". The business logic graph defines only the pure task topology and variable dependencies; the operation control graph independently defines all candidate scheduling strategies, computing power quotas, and snapshot rules available to the system. Coupling is achieved through a binding relationship graph containing multiple profiles, and the three are serialized and packaged into a "self-contained execution data package". The beneficial effects of this technical solution are: it enables the computational logic ontology to be independent of specific operation strategies, allowing for long-term stable reuse; the same business logic graph and operation control graph can generate different node execution contracts simply by switching profiles (e.g., low / medium / high configuration) during the compilation phase, greatly reducing system deployment costs, avoiding hard-coded binding of control logic, and improving the reusability of model assets. Simultaneously, the problem definition and solution path are merged into a single file, allowing for overall transmission and delivery independent of the original development environment, significantly reducing system deployment costs and user understanding costs.

[0054] To address the third technical problem mentioned above, in one possible implementation, this invention parses the binding graph into a global or local execution context based on the target profile at runtime. The system dynamically maintains a set of ready frontier nodes based on the runtime context, and allocates nodes through the executor to support concurrent relay of multiple heterogeneous large models / agents; and serializes and saves variable assignment tables and computing power consumption statistics to disk based on state snapshot nodes. The beneficial effect of this auxiliary technical feature is that it endows the graph-native AI system with powerful system-level fault tolerance and recovery capabilities. When an anomaly of computing power quota exhaustion is detected, the system can instantly reconstruct the memory state by deserializing the disk snapshot, achieving precise breakpoint resumption. This completely avoids recalculation from scratch due to unexpected interruptions, greatly improving the execution efficiency of long-chain nondeterministic computation tasks.

[0055] To address the fourth technical problem mentioned above, in one possible implementation, this invention performs static graph compilation checks on the self-contained execution data package before invoking large models and consuming computational power. This includes tracing the input source, verifying the data type domain, DAG topological sorting, and performing strongly connected component (SCC) analysis on general directed graphs. The beneficial effect of this auxiliary technical feature is that it can intercept illegal memory access and system crashes caused by free variables before large language models generate high computational power consumption. Particularly for graph structures containing feedback loops, this invention effectively prevents large models from falling into an infinite loop of repeated generation through the SCC fixed-point iterative convergence mechanism, significantly reducing the waste of computational resources. Attached Figure Description

[0056] The accompanying drawings are provided for a better understanding of this solution and do not constitute a limitation of the invention. Wherein:

[0057] Figure 1 A schematic diagram of a ternary decoupling structure for a business logic diagram, a runtime control diagram, and a binding relationship diagram provided in an embodiment of the present invention;

[0058] Figure 2 This is a data flow processing flowchart for the compilation and execution of the executable package provided in an embodiment of the present invention;

[0059] Figure 3 This is a schematic diagram illustrating the memory mapping of resolving candidate control nodes into runtime execution contracts based on the target profile, as provided in an embodiment of the present invention.

[0060] Figure 4 This is a schematic diagram illustrating the parent node output constraint on the child node input domain in a tree structure provided in an embodiment of the present invention.

[0061] Figure 5 This is a schematic diagram of the data flow for concurrent advancement and checkpoint saving of a DAG structure provided in an embodiment of the present invention;

[0062] Figure 6 This is a schematic diagram of an algorithm for iterative convergence of a general directed graph at the SCC level, provided as an embodiment of the present invention. Detailed Implementation

[0063] Unless otherwise expressly stated, throughout the specification and claims, the term "comprising" or its variations such as "including" or "comprises" shall be understood to include the stated elements or components without excluding other elements or other components.

[0064] The technical solution of the present invention is illustrated below through specific embodiments. It should be understood that the one or more steps mentioned in the present invention do not preclude the existence of other methods and steps before or after the combined steps, or that other methods and steps may be inserted between these explicitly mentioned steps. It should also be understood that these examples are for illustrative purposes only and are not intended to limit the scope of the present invention. Unless otherwise stated, the numbering of each method step is only for the purpose of identifying each method step, and not for limiting the order of each method or limiting the scope of the present invention. Changes or adjustments to their relative relationships, without substantial changes to the technical content, can also be considered as within the scope of the present invention.

[0065] The raw materials and instruments used in the examples are not subject to any specific restrictions on their source; they can be purchased from the market or prepared according to conventional methods known to those skilled in the art.

[0066] To address the shortcomings of traditional technologies, this invention provides an artificial intelligence task execution method based on three-graph decoupling and profile binding, executed by a computer device, specifically including:

[0067] Obtain a serialized self-contained execution data packet, the execution data packet including an independently encapsulated business logic diagram, a runtime control diagram, and a binding relationship diagram containing multiple configuration profiles; wherein, the business logic diagram includes computing nodes with defined unassigned variables, and the runtime control diagram includes multiple candidate control nodes for constraining computer hardware resources and execution strategies;

[0068] Based on the current operating environment, user commands, resource constraints, or service level parameters, determine the target configuration profile from the binding relationship diagram;

[0069] Based on the target configuration profile, target selector expansion and conflict resolution are performed on the binding relationship graph, and candidate control nodes in the runtime control graph are compiled and parsed into node-level runtime execution contracts corresponding to the target objects in the business logic graph.

[0070] Based on the topology of the business logic graph and the current variable assignment state, dynamically determine the executable computing nodes that currently meet the input dependency conditions;

[0071] According to the node-level runtime execution contract, the target executor is triggered to perform tensor calculations and variable assignments on the executable computing node, and update the memory state of the business logic graph until a preset computation termination condition is met. It should be noted that the target executor includes at least one of a large language model, a multimodal model, a heterogeneous intelligent agent, a local tool module, or an external event interface; that is, the target executor can be an artificial intelligence large language model, a heterogeneous intelligent agent, a local tool, an external asynchronous confirmation input node, a network I / O listener, etc.

[0072] The control nodes in the operation control diagram include at least one of the following: concurrent and traversal routing nodes, computing power quota nodes, computing termination nodes, state snapshot nodes, executor allocation nodes, data pattern verification nodes, and global static parameter nodes.

[0073] Prior to performing target selector expansion and conflict resolution on the binding graph based on the target configuration profile, the method further includes:

[0074] A static graph compilation check is performed on the self-contained execution data package to verify the topological legality of the business logic graph, the version compatibility of the target configuration profile and the candidate control node, and the data source completeness of the unassigned variables, thereby intercepting illegal memory access.

[0075] The step of performing static graph compilation checks on the self-contained execution data package includes:

[0076] The business logic diagram is subjected to input source tracing checks, data type domain checks, and dead node checks.

[0077] When the business logic graph is a directed acyclic graph, a topology sorting check is performed;

[0078] When the business logic graph is a general directed graph, strong connectivity component analysis is performed to identify feedback loops.

[0079] The step of compiling and parsing the candidate control nodes in the runtime control graph into node-level runtime execution contracts corresponding to the target objects in the business logic graph based on the target configuration profile includes:

[0080] If the binding edge in the target configuration profile indicates that the control node acts on the global domain of the business logic graph, then the control node is resolved into a global runtime variable;

[0081] If the binding edge in the target configuration profile indicates that the control node acts on a local subgraph, then the control node is resolved as a local execution strategy;

[0082] If the binding edge in the target configuration profile indicates that the control node acts on a specific compute node, then the control node is resolved into a node-level runtime execution contract of the compute node. It should be noted that when two or more control nodes are bound to the same business logic graph target object through the target configuration profile, the graph compilation and parsing module classifies and merges the control nodes according to the control type, and performs conflict resolution according to preset priority, coverage rules or binding order to generate the runtime control contract corresponding to the target object. Different types of control constraints take effect together according to the combination rules, and control constraints of the same type take effect or generate alarms according to the priority rules.

[0083] Specifically, when multiple control nodes are mapped to the same target object, the graph compilation and parsing module parses them into a runtime control contract for that target object. The runtime control contract includes at least one or more of the following: executor selection, scheduling strategy, budget constraints, stopping conditions, verification rules, and snapshot strategy. For control nodes of different types, the system uses a combination approach to make them work together; for control nodes of the same type, the system performs conflict resolution based on explicit priority, default priority, inheritance relationship, or binding order; when a conflict cannot be resolved, a compilation warning is output, and a preset degradation strategy is executed or execution is terminated.

[0084] The dynamic determination of the executable computing node that currently satisfies the input dependency conditions includes:

[0085] Traverse the topology of the business logic graph, extract the computing nodes where all current input data has resided in memory, and dynamically generate a set of ready nodes.

[0086] The triggering target executor performs tensor calculations and variable assignments on the executable computing node, including:

[0087] Read the concurrent and traversal routing nodes in the node-level runtime execution contract to determine the graph traversal algorithm and concurrency.

[0088] Based on the graph traversal algorithm and concurrency, one or more target nodes are extracted from the ready node set, and the target executor is concurrently invoked for computation. Specifically, when the control node contains multiple executor-assigned nodes, triggering the target executor to perform tensor computation and variable assignment on the executable computation node includes:

[0089] Based on the node-level runtime execution contract, identify the target executor allocation node to which the currently executable computing node is bound;

[0090] Based on the target executor allocation node, the network routing interface or memory context is dynamically switched, and a specific parameter scale model or heterogeneous agent matching the executable computing node is invoked for relay computing. The updating of the memory state of the business logic graph includes:

[0091] The pattern and type of the variable assignment result are validated using the validation rules derived from the data pattern validation node.

[0092] After the verification is passed, the output variables of the computing node are mapped and propagated to the input variable domain of the downstream nodes;

[0093] Based on the rules defined for the state snapshot nodes, the current variable assignment table, the current set of ready nodes, and the current computing power consumption statistics are serialized and saved to a non-volatile storage medium to generate a checkpoint snapshot that can be used for breakpoint recovery. The method also includes a breakpoint recovery mechanism, comprising:

[0094] When a computing power quota exhaustion exception or external interruption signal is detected, the current computing process is suspended.

[0095] In response to a recovery command, the most recently saved checkpoint snapshot is deserialized and loaded from the non-volatile storage medium;

[0096] The variable assignment table and ready node set in main memory are reconstructed using the checkpoint snapshot, and the calculation of subsequent nodes continues directly from the reconstructed ready node set. Specifically, when the business logic graph is a general directed graph containing feedback loops, and the static graph compilation check identifies strongly connected components, updating the memory state of the business logic graph includes:

[0097] A fixed-point iterative algorithm is used to repeatedly calculate within the strongly connected component, and the rate of change of the variable matrix within the strongly connected component is monitored in real time.

[0098] When the rate of change of the numerical value is lower than the preset convergence threshold, or when the number of iterations reaches the maximum number of iteration rounds defined in the node-level runtime execution contract, it is determined that the calculation of the strongly connected component is completed, and the memory state is propagated to the downstream nodes outside the strongly connected component.

[0099] It should be noted that during the static compilation phase, a general directed graph is compressed into a condensed graph composed of strongly connected components, and topological scheduling is performed on the condensed graph; each strongly connected component is executed iteratively at fixed points. On the other hand, the technical solution of this invention also provides a method for generating a self-contained execution data package for artificial intelligence, executed by a computer device, specifically including:

[0100] In response to the first structure construction instruction, a business logic diagram is generated. The computing nodes of the business logic diagram only contain data input / output declarations and variable patterns, and do not contain resource call instructions.

[0101] In response to the second structure construction instruction, an operation control diagram independent of the business logic diagram is generated. The operation control diagram contains multiple candidate control nodes for constraining computing power quotas, state snapshots, and concurrency and traversal routing strategies.

[0102] In response to the mapping configuration command, a binding relationship graph containing multiple configuration profiles is generated. Under different configuration profiles, the binding edges in the binding relationship graph will directionally bind the candidate control nodes in the operation control graph to the specified objects in the business logic graph. The specified objects include at least one of the following: the entire business logic graph, local subgraphs, layer level, node type set, specific computing nodes, specific data flow edges, variable set, and execution stage.

[0103] The business logic diagram, the operation control diagram, and the binding relationship diagram are serialized and encoded, and packaged into a self-contained execution data package so that heterogeneous computing engines can load different configuration profiles for computation based on the same business logic diagram.

[0104] It should also be noted that the "ternary decoupling" and "ternary coupling" described in the embodiments of this invention are used to characterize different structural relationships of the same technical architecture at different processing stages, and are not contradictory. Specifically, in the modeling stage, the business logic diagram, the operation control diagram, and the binding relationship diagram exist as independent structures. The business logic diagram describes business nodes, variable dependencies, and data propagation relationships; the operation control diagram describes operation control information such as scheduling strategies, resource budgets, stopping conditions, executor selection, result verification, and snapshot strategies; and the binding relationship diagram describes the binding rules between control nodes in the operation control diagram and target objects in the business logic diagram. Therefore, in this stage, business logic and operation control information remain decoupled, and both can be modified, reused, or replaced separately.

[0105] During the compilation phase, the system expands the binding edges in the binding relationship graph based on the target configuration profile. Then, according to the target selector, scope, priority, inheritance relationship, overriding rule, or conflict resolution rule in the binding edges, it binds one or more control nodes in the runtime control graph to target objects in the business logic graph. The target objects include at least one of the following: the entire business logic graph, a local subgraph, a set of node types, a specific business node, a specific data flow edge, a set of variables, or an execution phase. For multiple control nodes bound to the same target object, the system categorizes and merges them according to control type. When conflicts exist, conflict resolution is performed based on preset priority, profile inheritance relationship, overriding rule, or binding order, thereby generating a global runtime context, a local execution strategy, or a node-level runtime execution contract.

[0106] During the runtime phase, the scheduler, target executor, verifier, and recovery module advance the task based on the compiled runtime context and execution contract. This includes generating a set of ready nodes, selecting nodes to be executed, allocating computing resources, invoking the target executor, verifying execution results, writing back variable states, saving checkpoint snapshots, and resuming execution after an interruption. Therefore, the "ternary decoupling" in this invention emphasizes the independence of the three types of structures during the modeling and maintenance phases, while "ternary coupling" emphasizes establishing on-demand associations during the compilation phase through binding relationship graphs and target configuration profiles, and taking effect in the runtime phase in the form of runtime contracts.

[0107] The technical solution of the present invention will be further described in detail below with reference to the accompanying drawings and specific embodiments. In the following description, to make the structure of the present invention clearer, consistent reference numerals are introduced. The core idea of ​​the technical solution of the present invention and the ternary decoupling diagram model structure are defined as follows:

[0108] like Figure 1 As shown, this invention abandons the traditional approach of mixing "logical problem definition" and "runtime solution configuration" in a single node attribute, and further eliminates the limitations of hard-coding binding using a single static mapping table. It adopts a strict ternary decoupling structure to describe the executable AI solution system. In computer memory, this system is abstracted into the following ternary data structure packaged in a self-contained execution data package:

[0109] (1) Business Logic Graph (100)

[0110] Allocated in the computer's memory heap, it is used to define purely computational logical dependencies, mathematically represented as BG = (V_task, E_data, S_schema).

[0111] Where: V_task is the set of computing nodes (e.g., ... Figure 1 The computation nodes are 111, 112, 113, and 114; E_data is the data flow edge set 120; and S_schema is the variable pattern set.

[0112] Each compute node 110 includes at least: a set of input variables In(v); a set of output variables Out(v); an optional set of local variables Local(v); a variable schema Schema(v) (such as JSON Schema); and a node compute semantic type Kind(v) (such as target node, decomposition node, constraint node, evaluation node, leaf delivery node, etc.).

[0113] The data flow edge 120 includes at least: the memory mapping relationship from output to input; propagation rules; aggregation rules; guard conditions; and priorities. The business logic graph 100 supports tree, directed acyclic graph (DAG), or general directed graph structures, and absolutely does not contain any underlying computing power scheduling or hardware resource limiting instructions. The business logic graph can represent business solution structures, variable dependency structures, or task orchestration structures.

[0114] (2) Runtime Control Graph 200

[0115] Used to define the candidate pool of solution methods and execution rules at the computer's underlying level, mathematically represented as CG = (V_ctrl, E_ctrl, S_ctrl). It is important to emphasize that the control graph itself is a candidate capability space containing multiple sets of selectable strategies, rather than a single configuration hard-coded for a specific scenario. Control node 210 includes, but is not limited to:

[0116] Scheduled Node 211: Defines the algorithm for CPU traversal of the graph, such as DFS, BFS, or heuristic search algorithms that push node memory addresses into the ready queue.

[0117] BudgetNode 212: Defines the physical consumption limit of computing resources, such as limiting the number of bytes for network API requests (Token threshold), physical time budget, or number of GPU memory calls.

[0118] Stop Node 213: Defines the physical conditions for the computation to terminate, such as completion of all assignments, convergence of the memory matrix values, receipt of an external network interrupt signal, or time limit.

[0119] State Snapshot Node (CheckpointNode) 214: Defines when to serialize memory to disk, what content to save, and how to deserialize and restore.

[0120] ExecutorNode 215: Defines which heterogeneous large model, agent, or local tool executes a certain type of computing node, used for switching network routes.

[0121] Data schema validation node (ValidatorNode) 216: Defines strong rule validation before memory write, such as schema checks and data type checks based on the matching engine.

[0122] Concurrency strategy node: Defines the number of concurrent threads, batch size, and priority of the ready queue.

[0123] Global context node: Used to carry runtime global static parameters, which are parsed into memory before execution. (3) Binding Graph 300

[0124] like Figure 1 As shown by the dashed lines, M = {m1, m2, …, mn} is defined. The binding graph contains multiple configuration profiles (such as Profile-Low, Profile-Mid, Profile-High). Each profile contains a set of binding edges, which use target selectors (such as node configuration prefixes, node types, labels, etc.) to bind candidate control nodes 210 in the runtime control graph 200 to target memory objects in the business logic graph 100. The target object can be: a global graph, a local subgraph, a specific compute node 110, a specific data flow edge 120, or a certain type of variable.

[0125] For example in Figure 1 In Profile-Low, executor allocation node 215 (low-cost model) is bound to all business nodes; while in Profile-High, executor allocation node 215 (expert model) is bound only to a specific compute node 112, and other nodes are bound to the regular model.

[0126] The generation and advantages of the self-contained execution data package of the technical solution of the present invention are that the computer system serializes and packages the above-mentioned business logic diagram 100, operation control diagram 200, binding relationship diagram 300, along with optional prompt templates, external tool lists, default contexts and historical checkpoints, into a self-contained execution data package in JSON / YAML format.

[0127] This execution data package has the following significant advantages: it achieves "problem definition and solution path delivery together"; users do not need to understand the underlying system configuration to run it; the business logic diagram 100 can be reused independently, and the operation control diagram 200 can be hot-swapped at any time; multiple operation configuration versions can be attached to the same logic diagram; it is very suitable for overall network transmission, version management and execution across heterogeneous environments.

[0128] The system's underlying components and the complete data flow processing are combined Figure 2 The flowchart and underlying entity components of the system (graph compilation and parsing module 410, state and memory management module 420, runtime scheduling engine 430, model call interface 440) illustrate the complete data flow steps of this invention as follows:

[0129] Step S201: Load the execution package

[0130] The status and memory management module 420 deserializes the execution data packets on the disk, loads them into main memory, and restores the ternary structure.

[0131] Step S202: Static compilation of the business logic diagram;

[0132] Before consuming significant model computational power, the graph compilation and parsing module 410 performs rigorous memory-level checks on the business logic graph 100. These checks include: required input variable checks; free variable checks; input source pointer tracing checks; data type and domain checks; graph structure validity checks; DAG topological sorting checks; strong connected component (SCC) analysis of general directed graphs; and dead node and dangling edge checks.

[0133] Step S203: Static compilation and runtime control chart

[0134] The checks include: whether the scheduling policy node 211 is valid; whether the computing power quota node 212 is configured completely; whether the stop condition node 213 is conflicting; whether the state snapshot node 214 policy is executable; whether the executor allocation node 215 is compatible with the target node; and whether there are priority conflicts between different control nodes.

[0135] It should be noted that if the compilation fails in step S202 or step S203 above, an error / execution refusal will be output.

[0136] Step S204: Select the target profile and compile the binding graph to generate a runtime contract.

[0137] like Figure 3As shown, the graph compilation and parsing module 410 selects a target profile based on the system's current budget or user instructions, expands the binding edges under that profile, performs compatibility checks and conflict resolution, and parses and loads candidate control nodes into a runtime context 310 and a node-level runtime execution contract in memory. Specifically, this includes: parsing into global runtime variables; local execution strategies; node execution contracts; propagation or verification rules; and snapshot and verification contexts.

[0138] Step S205: Initialize state

[0139] The State and Memory Management module 420 initializes the variable assignment table in memory based on the root node input, the default context, or the history checkpoint file.

[0140] Step S206: Generate a set of ready frontier nodes.

[0141] The runtime scheduling engine 430 traverses the topology of the business logic graph 100, uses the dependency counter to extract the computing nodes 110 whose current input dependency conditions have been met, and pushes the memory address blocks of these nodes into the executable Ready Frontier queue.

[0142] Step S207: Scheduling Decision

[0143] The runtime scheduling engine 430 reads the strategy from the context 310 and selects the node or subgraph to advance. Scheduling methods include: DFS, BFS, specified layer limit, concurrent batch processing, etc.

[0144] Step S208: Node assignment execution

[0145] The runtime scheduling engine 430 assembles the input variables of the target node into a request data stream. The model call interface 440 allocates nodes 215 according to the executor, triggering the network API or local GPU nodes of different large models to perform tensor calculations and structured assignments on the output variables that have not yet been assigned values.

[0146] Step S209: Result Verification

[0147] The status and memory management module 420 uses the verification rules derived from the data pattern verification node 216 to perform the following verifications on the data returned by the model: schema verification, type verification, domain verification, and source tracing verification. If the verification result fails, the current computing node is added back to the execution set, or a backup executor is switched to recalculate according to the execution contract, or an abnormal termination is triggered.

[0148] Step S210: Write Back and Propagate Updates

[0149] After successful verification, the assignment result is written to main memory. The scheduling engine 430 maps and propagates the output data of this node along data flow edge 120 to the input memory area of ​​the downstream node, updating the graph state.

[0150] Step S211: Save the checkpoint snapshot; the checkpoint snapshot also includes a control chart version identifier, a target profile identifier, or a runtime contract summary, to verify the consistency between the recovery environment and the execution environment before the interruption when the breakpoint is restored;

[0151] According to the rules of state snapshot node 214, the state and memory management module 420 persists the following content to disk: current variable assignment table, current Frontier queue, current computing power consumption statistics, and next round recovery position pointer.

[0152] Step S212: Determine if the stopping condition is met

[0153] The process terminates based on the stopping condition node 213. If not met, the data flow returns to step S206; if met, it proceeds to step S213, outputting the final graph state, leaf deliverables, and execution evidence. The hierarchical constraints of the node outputs, such as... Figure 4 As shown, in this invention, the assignment result of a parent node 401 represents both "the calculation of this node is complete" and "the definer of the solution space of the downstream child node 402". It can define the input space of the downstream node (input domain 403), constrain the local shape of the subgraph, propagate the topic range or local computing power quota, form the intermediate layer summary skeleton, and support local recovery and continued execution with this as the anchor point.

[0154] A complete data flow processing case combining the system's underlying logic, such as Example 1: Tree structure traversal and physical computing power control:

[0155] The business logic diagram 100 is instantiated in the computer memory heap as a data structure containing input / output pointers, used to define the generation dependencies of complex tree-like content. The runtime control diagram 200 configures the scheduling strategy node 211 as "breadth-first search (BFS) traversal followed by depth-first search (DFS) traversal," which is parsed by the CPU into a specific ready queue pointer push algorithm. Simultaneously, the runtime control diagram 200 sets the computing power quota node 212 (i.e., limiting token consumption, call count, execution time, cost budget, or memory usage limits) and the state snapshot node 214. During runtime, the scheduling engine 430 first generates the overall framework and then expands the content layer by layer. If the token consumption, number of calls, execution time, cost budget, or video memory usage limit reaches the threshold of computing power quota node 212, the system performs physical truncation and actively suspends the process; after replenishing the computing power indicators, the status and memory management module 420 directly deserializes the most recent checkpoint from the disk, the engine 430 restores the ready queue pointer and continues to execute the next level, achieving precise breakpoint resume.

[0156] Example 2: Dynamic route binding based on multiple profiles under the same operation control graph;

[0157] This invention achieves pure low-level technical control switching by binding multiple profiles in the relationship diagram 300, without modifying the business logic diagram 100 and the operation control diagram 200.

[0158] Builder-side configuration: The same runtime control graph 200 incorporates multiple candidate control nodes, including actuator nodes (low-cost model, expert model), concurrent nodes (single-threaded, multi-threaded), and verification nodes (normal verification, strict verification). The binding relationship graph 300 contains three profiles:

[0159] Profile-Low (low-end mode): Binds all business nodes to a low-cost model and single-threaded strategy by binding edges.

[0160] Profile-Mid (Mid Configuration Mode): By using a target selector (such as a specific node prefix), critical business nodes are bound to the expert model and multi-threaded concurrency strategy, while ordinary nodes are still bound to the low-cost model.

[0161] Profile-High (High Configuration Mode): Based on Profile-Mid, it replaces the verification nodes of critical nodes with strict verification mode through overriding rules and enables the highest computing power quota.

[0162] Runtime data flow: When the system receives an external call request, it dynamically activates Profile-High based on the current account balance or SLA level (e.g., a VIP user submitting a high-configuration instruction). The graph compilation and parsing module 410 only parses the binding edges corresponding to Profile-High and generates the corresponding node execution contract. Without changing the business ontology model and the underlying control capability pool, it achieves perfect adaptation to different delivery requirements and computing power environments, avoiding system rigidity caused by hard-coded configurations.

[0163] Example 3: Multi-interface concurrent relay and asynchronous I / O interrupt scenario; This example demonstrates in detail the data flow of multi-actuator network routing relay and asynchronous I / O interrupt.

[0164] Builder configuration: Business logic diagram 100 includes nodes A, B, C1 / C2, D, and E (internal asynchronous confirmation signal input node). Run control diagram 200 includes computing power quota node 212 (100,000 Token threshold) and is configured with multiple executor allocation nodes 215: interface X, interface Y, and interface Z. The current profile in the binding relationship diagram binds interface X to node A, interface Y to nodes B, C1, and C2, and interface Z to node D.

[0165] Runtime data flow: Engine starts, Ready Frontier is {A}. Model call interface 440 sends tensor requests to "interface X" API according to the node-level runtime execution contract, completing node A, and state and memory management module 420 writes a snapshot to disk.

[0166] The state is propagated to node B, and the Ready Frontier is updated to {B}. The model calls interface 440 to dynamically switch network routes, calls "interface Y" to complete node B, outputs constraint variables, and saves a snapshot to disk.

[0167] like Figure 5 As shown, the state is propagated to concurrent nodes 501 (corresponding to C1) and 502 (corresponding to C2), and the Ready Frontier is updated to {C1, C2}. The runtime scheduling engine 430, based on the concurrency strategy, starts two threads and concurrently calls the "interface Y" compute nodes C1 and C2.

[0168] Breakpoint recovery of data flow: If the generation of node C1 triggers the threshold limit of computing power quota node 212, causing a hardware interruption, the system receives a recovery command. The status and memory management module 420 reads the checkpoint snapshot 510 from the disk, and the main memory is instantly rebuilt to the state of "Node B has completed calculation, Ready Frontier={C1, C2}". The scheduling engine 430 directly initiates requests from concurrent nodes 501 and 502, completely avoiding the waste of computing power caused by re-calling the interface to execute nodes A and B.

[0169] External asynchronous interrupt mechanism: After all concurrent nodes complete their tasks, the state propagates to node D, and the model calls interface 440 to switch to "interface Z" to complete the review calculation. When the final state reaches node E, the system triggers an external asynchronous interrupt and network I / O monitoring mechanism: it actively suspends the current computation thread, serializes the memory state to disk, and starts listening on a specific network port. Only after receiving an external asynchronous input data packet containing a valid verification signature is the thread awakened to deserialize the memory and continue execution, ultimately completing the determination of the stopping condition node 213 and outputting the result.

[0170] Example 4: Mathematical iteration convergence of general directed graphs at the SCC level; such as Figure 6 As shown, in the business logic graph 100 containing feedback loops, the graph compilation and parsing module 410 identifies strongly connected components (SCCs) 600 using the Tarjan algorithm. During runtime, the runtime scheduling engine 430 uses a fixed-point iterative algorithm to repeatedly call the network interface between internal nodes 601 and 602 within the strongly connected component 600. The state and memory management module 420 monitors the rate of change of the memory variable matrix between adjacent iterations in real time. When the rate of change falls below the mathematical threshold set by the stopping condition node 213, or reaches the maximum number of iterations defined in the node-level runtime execution contract, the system forcibly exits the loop and propagates the memory state to the outside of the strongly connected component 600 along the propagation edge 610. This mechanism solves the technical problem of large models without control flow easily falling into infinite loops at the underlying algorithm level, transforming nondeterministic generation into a purely mathematical convergence process.

[0171] The above description is merely a specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in the present invention should be included within the scope of protection of the present invention.

[0172] According to embodiments of the present invention, the present invention also provides a readable storage medium and a computer program product. The computer-readable storage medium stores a computer program thereon, which, when executed by a processor, implements the method described above; an electronic device includes the processor, the processor being configured to perform the method described above.

[0173] The example electronic devices of embodiments of the present invention are intended to represent various forms of digital computers, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. The electronic devices may also represent various forms of mobile devices, such as personal digital processors, cellular phones, smartphones, wearable devices, and other similar computing devices. The components shown herein, their connections and relationships, and their patterns are merely examples and are not intended to limit the implementation of the invention described and / or claimed herein.

[0174] The electronic device includes a computing unit that can perform various appropriate actions and processes based on a computer program stored in a read-only memory (ROM) or a computer program loaded from a storage unit into a random access memory (RAM). The RAM may also store various programs and data required for the operation of the electronic device. The computing unit, ROM, and RAM are interconnected via a bus. Input / output (I / O) interfaces are also connected to the bus.

[0175] Multiple components in an electronic device are connected to an I / O interface, including: input units such as keyboards and mice; output units such as various types of displays and speakers; storage units such as disks and optical discs; and communication units such as network interface cards (NICs), modems, and wireless transceivers. The communication unit allows the electronic device to exchange information / data with other devices through computer networks such as the Internet and / or various telecommunications networks.

Claims

1. An artificial intelligence task execution method based on three-graph decoupling and profile binding, executed by a computer device, specifically including: Obtain a serialized self-contained execution data packet, the execution data packet including an independently encapsulated business logic diagram, a runtime control diagram, and a binding relationship diagram containing multiple configuration profiles; wherein, the business logic diagram includes computing nodes with defined unassigned variables, and the runtime control diagram includes multiple candidate control nodes for constraining computer hardware resources and execution strategies; Based on the current operating environment, user commands, resource constraints, or service level parameters, determine the target configuration profile from the binding relationship diagram; Based on the target configuration profile, target selector expansion and conflict resolution are performed on the binding relationship graph, and candidate control nodes in the runtime control graph are compiled and parsed into node-level runtime execution contracts corresponding to the target objects in the business logic graph. Based on the topology of the business logic graph and the current variable assignment state, dynamically determine the executable computing nodes that currently meet the input dependency conditions; According to the node-level runtime execution contract, the target executor is triggered to perform tensor calculations and variable assignments on the executable computing node, and update the memory state of the business logic graph until the preset calculation termination condition is met.

2. The method according to claim 1, characterized in that, Each binding edge in the binding relationship graph includes at least one of the following: business logic graph target selector, runtime control graph node reference identifier, scope, configuration profile identifier, activation condition, priority, merging rule, or conflict resolution rule.

3. The method according to claim 2, characterized in that, The business logic diagram target selector is used to select at least one of the following: the overall business logic diagram, a local subgraph, a layer level, a set of node types, a set of node labels, a specific business node, a specific data flow edge, a set of variables, or an execution phase.

4. The method according to claim 2, characterized in that, The candidate control nodes in the operation control diagram include at least one of the following: concurrent and traversal routing nodes, computing power quota nodes, computing termination nodes, state snapshot nodes, executor allocation nodes, data pattern verification nodes, and global static parameter nodes.

5. The method according to claim 2, characterized in that, Before performing target selector expansion and conflict resolution on the binding graph based on the target configuration profile, the method further includes: A static graph compilation check is performed on the self-contained execution data package to verify the topological legality of the business logic graph, the version compatibility of the target configuration profile and the candidate control node, and the data source completeness of the unassigned variables, thereby intercepting illegal memory access and invalid binding.

6. The method according to claim 1, characterized in that, The static graph compilation check performed on the self-contained execution data package includes: The business logic diagram is subjected to input source tracing checks, data type domain checks, and dead node checks. When the business logic graph is a directed acyclic graph, a topology sorting check is performed; When the business logic graph is a general directed graph, strong connectivity component analysis is performed to identify feedback loops.

7. The method according to claim 5, characterized in that, The step of compiling and parsing the candidate control nodes in the runtime control graph into node-level runtime execution contracts corresponding to the target objects in the business logic graph based on the target configuration profile includes: If the binding edge in the target configuration profile indicates that the control node acts on the global domain of the business logic graph, then the control node is resolved into a global runtime variable; If the binding edge in the target configuration profile indicates that the control node acts on a local subgraph, then the control node is resolved as a local execution strategy; If the binding edge in the target configuration profile indicates that the control node acts on a specific compute node, then the control node is resolved to the node-level runtime execution contract of the compute node.

8. The method according to claim 1, characterized in that, The dynamic determination of the executable computing node that currently satisfies the input dependency conditions includes: Traverse the topology of the business logic graph, extract the computing nodes where all current input data has resided in memory, and dynamically generate a set of ready nodes. The triggering target executor performs tensor calculations and variable assignments on the executable computing node, including: Read the concurrent and traversal routing nodes in the node-level runtime execution contract to determine the graph traversal algorithm and concurrency. Based on the graph traversal algorithm and concurrency, one or more target nodes are extracted from the ready node set, and the target executor is concurrently invoked for computation. The runtime control graph contains multiple candidate executor allocation nodes; different configuration profiles bind target objects in the same business logic graph to different candidate executor allocation nodes in the runtime control graph by activating different binding edges. The triggering target executor performs tensor calculations and variable assignments on the executable computing node, including: Based on the node-level runtime execution contract, identify the target executor allocation node to which the currently executable computing node is bound; Based on the target executor allocation node, the network routing interface or memory context is dynamically switched, and a specific parameter scale model or heterogeneous agent matching the executable computing node is invoked for relay computing. In this process, at least one configuration profile in the binding relationship graph inherits some binding edges from another configuration profile, and replaces executor allocation nodes, concurrent and traversal routing nodes, computing power quota nodes, or computing termination nodes bound to specific business nodes, node types, or local subgraphs by overriding these binding edges.

9. The method according to claim 1, characterized in that, Updating the memory state of the business logic graph includes: The pattern and type of the variable assignment result are validated using the validation rules derived from the data pattern validation node. After the verification is passed, the output variables of the computing node are mapped and propagated to the input variable domain of the downstream nodes; Based on the rules defined for the state snapshot nodes, the current variable assignment table, the current set of ready nodes, and the current computing power consumption statistics are serialized and saved to a non-volatile storage medium to generate a checkpoint snapshot that can be used for breakpoint recovery. The method also includes a breakpoint recovery mechanism, comprising: When a computing power quota exhaustion exception or external interruption signal is detected, the current computing process is suspended. In response to a recovery command, the most recently saved checkpoint snapshot is deserialized and loaded from the non-volatile storage medium; The variable assignment table and ready node set in main memory are reconstructed using the checkpoint snapshot, and the calculation of subsequent nodes continues directly from the reconstructed ready node set. Specifically, when the business logic graph is a general directed graph containing feedback loops, and the static graph compilation check identifies strongly connected components, updating the memory state of the business logic graph includes: A fixed-point iterative algorithm is used to repeatedly calculate within the strongly connected component, and the rate of change of the variable matrix within the strongly connected component is monitored in real time. When the rate of change of the numerical value is lower than the preset convergence threshold, or when the number of iterations reaches the maximum number of iteration rounds defined in the node-level runtime execution contract, it is determined that the calculation of the strongly connected component is completed, and the memory state is propagated to the downstream nodes outside the strongly connected component.

10. A method for generating a self-contained execution data package for artificial intelligence, executed by a computer device, specifically including: In response to the first structure construction instruction, a business logic diagram is generated. The computing nodes of the business logic diagram only contain data input / output declarations and variable patterns, and do not contain resource call instructions. In response to the second structure construction instruction, an operation control diagram independent of the business logic diagram is generated. The operation control diagram contains multiple candidate control nodes for constraining computing power quotas, state snapshots, and concurrency and traversal routing strategies. In response to the mapping configuration command, a binding relationship graph containing multiple configuration profiles is generated. The binding edges in the binding relationship graph, under different configuration profiles, will directionally bind the candidate control nodes in the operation control graph to the specified objects in the business logic graph. The business logic diagram, the operation control diagram, and the binding relationship diagram are serialized and encoded, and packaged to generate a self-contained execution data package. This enables heterogeneous computing engines to perform calculations based on the same business logic diagram and the same operation control diagram, simply by switching configuration profiles to load different computing power and state control strategies.

11. A computer system comprising a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the steps of the method as described in any one of claims 1-10.

12. A computer-readable storage medium having a computer program stored thereon, the computer program being executed by a processor to implement the steps of the method as described in any one of claims 1-10.

Images