A large model service arrangement method, device and storage medium based on task tree

Abstract

The present application discloses a large-model service orchestration method, device and storage medium based on a task tree, which relates to the field of artificial intelligence technology. The method includes: traversing the application system to be orchestrated to construct a multi-node task tree of the application system to be orchestrated; parsing the problem information input by the user, and based on the parsing result, determining the corresponding task execution path in the multi-node task tree; based on the problem information, determining whether the condition information for executing each node task in the task execution path is sufficient; if the condition information is insufficient, constructing a condition request question, and sending the condition request question to the user interface for round-trip questioning and answering until the acquired condition information satisfies the execution of each node task. The present application realizes accurate task orchestration and condition judgment when executing complex tasks on a large model through the above method.

Description

Technical Field

[0001] The present application relates to the field of artificial intelligence technology, and in particular to a large-scale model service orchestration method, device, and storage medium based on a task tree. Background Art

[0002] Although language models such as GPT and PaLM were originally designed for text generation, their large-scale versions have demonstrated increasingly powerful multi-task reasoning capabilities, capable of performing mathematical, symbolic, commonsense, and knowledge-based reasoning. When models exceed a certain scale, performance improves significantly, and generation capabilities emerge. Powerful logical reasoning is one of the core capabilities of the "intelligent emergence" of large language models. The COT (Consciousness on the Go) can be viewed as a discrete cue learning technique. This allows large language models to predict the "thought process" corresponding to the question, rather than simply the final answer. This significantly enhances the complex reasoning capabilities of large-scale language models.

[0003] With the enhancement of large model reasoning capabilities and the development of prompt engineering technology, a series of prompt engineering design technologies such as thinking tree (TOT) and thinking map (GOT) have been derived based on the thinking chain, allowing thinking to move from chain to tree to map, and continuously improving the ability of LLM to construct reasoning processes.

[0004] A series of works, such as thought chaining, use prompt engineering to guide large language models to decompose complex tasks into chains, trees, and graphs, thereby improving their performance in complex reasoning tasks. This approach forces large models to enhance their reasoning capabilities through thought processes. However, as models transition from linear chains to hierarchical trees and complex graph structures, the interplay of thoughts becomes increasingly complex, gradually enhancing their ability to solve complex problems. However, as the complexity of topological structures increases, these methods impose more constraints on task selection, significantly reducing their generalizability and making their application more difficult. Extending methods based on complex topological structures to general domains remains a challenge, relying more heavily on the capabilities of the large model itself. While thought chaining significantly enhances the reasoning capabilities of large language models in scenarios such as mathematical computation and code generation, it is more limited when it comes to executing reasoning in specific applications.

[0005] In practical applications, we expect large models to independently complete complex tasks and execute them automatically. Complex tasks in practice often involve knowledge beyond the large model's cognitive scope and system-level task orchestration. Relying solely on the chain of thought and the large model's inherent logical reasoning capabilities makes it difficult to achieve accurate task orchestration and conditional judgment. Therefore, achieving precise task orchestration and conditional judgment when large models execute complex tasks has become a pressing technical challenge. Summary of the Invention

[0006] The embodiments of the present application provide a large model service orchestration method, device and storage medium based on a task tree to solve the following technical problem: how to achieve accurate task orchestration and condition judgment when executing complex tasks in a large model.

[0007] In the first aspect, an embodiment of the present application provides a large-model service orchestration method based on a task tree, characterized in that the method includes: traversing the application system to be serviced and orchestrated to construct a multi-node task tree of the application system to be serviced and orchestrated; parsing the problem information input by the user, and based on the parsing result, determining the corresponding task execution path in the multi-node task tree; based on the problem information, determining whether the condition information for executing each node task in the task execution path is sufficient; if the condition information is insufficient, constructing a conditional request question, and sending the conditional request question to the user interface for round-robin questioning and answering until the obtained condition information satisfies the execution of each node task.

[0008] In one implementation of the present application, the application system to be serviced is traversed to construct a multi-node task tree for the application system to be serviced, specifically including: traversing all functional modules and operations in the application system through a depth-first search or breadth-first search strategy; creating a task tree node for each functional module and operation, and setting the attribute information of the node; wherein the attribute information includes node ID, node type, parent node ID, child node ID list, node description and execution function; establishing a connection relationship between nodes according to the dependency relationship and execution order between each functional module or operation to form a multi-node task tree.

[0009] In one implementation of the present application, the question information input by the user is parsed, and based on the parsing results, the corresponding task execution path is determined in the multi-node task tree, specifically including: performing natural language processing on the question information input by the user to extract the key intent and conditional information parameters of the question information; based on the key intent, performing a node search in the multi-node task tree to determine the corresponding starting node and target node; and according to the node connection relationship in the multi-node task tree, determining the shortest path from the starting node to the target node as the task execution path.

[0010] In one implementation of the present application, based on problem information, it is determined whether the condition information for executing each node task in the task execution path is sufficient, specifically including: analyzing the condition information required for executing each node task in the task execution path; comparing the required condition information with the condition information parameters to determine whether all the required condition information has been obtained; in the case where the condition information for a node task is insufficient, marking the node as an insufficient condition node and recording the required supplementary condition information.

[0011] In one implementation of the present application, a conditional request question is constructed and sent to a user interface for round-robin questioning and answering until the acquired condition information satisfies the execution of each node task, specifically comprising: constructing a corresponding conditional request question based on the required supplementary condition information; sending the conditional request question to the user interface and waiting for the user to answer; receiving the user's answer information and parsing the answer information to verify whether the answer information satisfies the required supplementary condition information; if the answer information does not meet the requirements, reconstructing the conditional request question for round-robin questioning and answering until the acquired required supplementary condition information is satisfied.

[0012] In one implementation of the present application, the method also includes: when conditional information is sufficient, executing each node task in sequence according to the task execution path until the entire service orchestration process is completed; monitoring the execution status of the node tasks, and updating the execution status of the task execution path after each node task is executed.

[0013] In one implementation of the present application, the method also includes: during the task execution process, if a node task fails to execute, triggering an error handling process; recording the failed node task information and performing a rollback operation; if the rollback operation cannot be successfully executed a preset number of times, feedback error information to the user, and rebuilding the task execution path and executing it.

[0014] In one implementation of the present application, after constructing a multi-node task tree for the application system to be serviced and orchestrated, the method further includes: receiving custom revision information uploaded by the user based on a preset visual task tree editing interface; and updating the multi-node task tree based on the custom revision information.

[0015] In the second aspect, an embodiment of the present application also provides a large-model service orchestration device based on a task tree, characterized in that the device includes: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions that can be executed by the at least one processor, and the instructions are executed by the at least one processor so that the at least one processor can: traverse the application system to be serviced and orchestrated to build a multi-node task tree for the application system to be serviced and orchestrated; parse the problem information input by the user, and based on the parsing result, determine the corresponding task execution path in the multi-node task tree; based on the problem information, determine whether the condition information for executing each node task in the task execution path is sufficient; if the condition information is insufficient, construct a conditional request question, and send the conditional request question to the user interface for round-robin questioning and answering until the acquired condition information satisfies the execution of each node task.

[0016] On the third aspect, an embodiment of the present application also provides a non-volatile computer storage medium for large-scale model service orchestration based on a task tree, which stores computer-executable instructions, and is characterized in that the computer-executable instructions are set to: traverse the application system to be serviced and orchestrated to construct a multi-node task tree of the application system to be serviced and orchestrated; parse the problem information input by the user, and based on the parsing result, determine the corresponding task execution path in the multi-node task tree; based on the problem information, determine whether the condition information for executing each node task in the task execution path is sufficient; if the condition information is insufficient, construct a conditional request question, and send the conditional request question to the user interface for round-robin questioning and answering until the obtained condition information satisfies the execution of each node task.

[0017] The present invention provides a large-scale model service orchestration method, device, and storage medium based on a task tree, which manages and executes tasks in an application system by building a multi-node task tree. This method brings many beneficial effects:

[0018] 1. Improve the efficiency and accuracy of service orchestration: By building a multi-node task tree, the dependencies and execution order between various functional modules and operations in the application system can be clearly represented, which helps to automatically determine the task execution path and reduce the need for manual intervention, thereby improving the efficiency and accuracy of service orchestration.

[0019] 2. Optimize the user interaction experience: By parsing the question information entered by the user and determining the corresponding task execution path in the task tree based on the parsing results, users can describe their needs in natural language without having to possess professional technical knowledge, thereby optimizing the user interaction experience.

[0020] 3. Automatic Condition Information Completion Mechanism: Before executing a task, the system checks whether the necessary condition information for each node task is sufficient. If the conditions are insufficient, it constructs condition-requiring questions and conducts round-robin question-and-answer sessions with the user until all necessary conditions are obtained. This ensures smooth task execution and reduces task failures due to insufficient conditions.

[0021] 4. Enhanced flexibility and robustness of task execution: Given sufficient conditional information, tasks at each node are executed sequentially along the task execution path, while also monitoring the execution status. If a node task fails, an error handling process is triggered, including logging the failure information, performing a rollback, and providing error feedback to the user after multiple rollback failures. This enhances the flexibility and robustness of task execution.

[0022] 5. Support custom revisions: Provides a visual task tree editing interface, allowing users to upload custom revision information to update multi-node task trees, allowing users to flexibly adjust the structure and node properties of the task tree according to their own needs, further improving the scalability and adaptability of the system. BRIEF DESCRIPTION OF THE DRAWINGS

[0023] The drawings described herein are used to provide a further understanding of the present application and constitute a part of the present application. The illustrative embodiments of the present application and their descriptions are used to explain the present application and do not constitute an improper limitation on the present application. In the drawings:

[0024] Figure 1 A flowchart of a large model service orchestration method based on a task tree provided in an embodiment of the present application;

[0025] Figure 2 A schematic diagram of the internal structure of a large-scale service orchestration device based on a task tree provided in an embodiment of the present application. DETAILED DESCRIPTION

[0026] To make the purpose, technical solutions, and advantages of this application more clear, the technical solutions of this application will be clearly and completely described below in conjunction with the specific embodiments of this application and the corresponding drawings. Obviously, the embodiments described are only part of the embodiments of this application, not all of them. Based on the embodiments in this application, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of this application.

[0027] The embodiments of the present application provide a large model service orchestration method, device and storage medium based on a task tree to solve the following technical problem: how to achieve accurate task orchestration and condition judgment when executing complex tasks in a large model.

[0028] The technical solutions proposed in the embodiments of the present application are described in detail below with reference to the accompanying drawings.

[0029] Figure 1 This is a flow chart of a large model service arrangement method based on a task tree provided in an embodiment of the present application. Figure 1 As shown, the embodiment of the present application provides a large model service orchestration method based on a task tree, which specifically includes the following steps:

[0030] Step 101: traverse the application system to be serviced and orchestrated to construct a multi-node task tree of the application system to be serviced and orchestrated.

[0031] In one embodiment of the present application, in order to implement a large-model service orchestration method based on a task tree, it is first necessary to traverse the application system to be serviced and orchestrated to construct a multi-node task tree of the application system to be serviced and orchestrated.

[0032] Specifically, all functional modules and operations in the application system are traversed through a depth-first search or breadth-first search strategy; a task tree node is created for each functional module and operation, and the attribute information of the node is set; wherein the attribute information includes node ID, node type, parent node ID, child node ID list, node description and execution function; according to the dependency relationship and execution order between each functional module or operation, the connection relationship between nodes is established to form a multi-node task tree.

[0033] In one embodiment, the present application adopts a systematic approach to constructing a multi-node task tree for an application system to be orchestrated. First, choosing an appropriate search strategy is crucial, as it determines how effectively the entire application system can be traversed. The present application employs either a depth-first search (DFS) or breadth-first search (BFS) strategy. Both strategies are commonly used traversal algorithms in graph theory and can help comprehensively and systematically explore all functional modules and operations in the application system. When applying these two search strategies, starting from the entry point of the application system, each functional module and operation in the system is gradually traversed in-depth or extensively. Whenever a new functional module or operation is discovered, a task tree node is created for it. This process is automated, ensuring that every component of the application system is accurately represented in the task tree. During the creation of the task tree nodes, detailed attribute information is assigned to each node. This attribute information includes not only a unique node ID for identification and tracking, but also a node type to distinguish functional modules and operations. To clearly represent the structure of the task tree, each node is assigned a parent node ID and a list of child node IDs, accurately depicting the hierarchical relationships between nodes. Furthermore, the node description provides detailed information about the functional module or operation, facilitating subsequent understanding and maintenance. The execution function, on the other hand, is the specific operation associated with the node, defining the actions to be performed when the node is triggered. After establishing all task tree nodes, the connections between the nodes need to be established based on the actual dependencies and execution order between the functional modules or operations in the application system. This is a critical step, as it ensures the logical correctness and executable nature of the task tree. These dependencies are determined by carefully analyzing the application system's business logic and operational processes.

[0034] In one embodiment of the present application, after constructing a multi-node task tree for the application system to be serviced and orchestrated, the method further includes: receiving custom revision information uploaded by the user based on a preset visual task tree editing interface; and updating the multi-node task tree based on the custom revision information.

[0035] In one embodiment, after successfully constructing a multi-node task tree for a service-orchestrated application system, to further enhance flexibility and customizability, users are allowed to perform custom revisions through a pre-defined visual task tree editing interface. First, this interface graphically displays the structure of the multi-node task tree, allowing users to clearly see the relationships between the individual nodes and the overall direction of the task flow. Users can easily interact with the task tree through operations such as dragging and clicking. Using a series of tools and functions provided within this editing interface, users can customize the task tree according to their needs. These revisions may include, but are not limited to, adding new nodes, deleting existing nodes, modifying node properties, and adjusting the connections between nodes. Users can use these operations to optimize task flows to better meet actual business needs and operational habits. Once the user completes the customized revision, the editing interface saves the revision information in a specific data format. This data contains all changes made to the task tree by the user, such as information about newly added nodes, identifiers of deleted nodes, and modified node properties. The system then receives and processes this customized revision information. By parsing this data, the system can accurately identify every modification made by the user to the task tree. Next, the system updates the original multi-node task tree according to these modification instructions. This includes adding new user-defined nodes, removing no longer needed nodes, updating node attributes, and reestablishing connections between nodes. Throughout this process, the system ensures that all modifications adhere to the task tree's logical structure and business rules. If user revisions could cause logical errors or inconsistencies in the task tree, the system will promptly notify and reject these modifications, ensuring the correctness and usability of the updated multi-node task tree.

[0036] Step 102: parse the question information input by the user, and determine the corresponding task execution path in the multi-node task tree based on the parsing result.

[0037] In one embodiment of the present application, after constructing a multi-node task tree of the application system to be serviced and orchestrated, the problem information input by the user is parsed, and based on the parsing result, the corresponding task execution path is determined in the multi-node task tree.

[0038] Specifically, natural language processing is performed on the question information input by the user to extract the key intent and conditional information parameters of the question information; based on the key intent, a node search is performed in the multi-node task tree to determine the corresponding start node and target node; according to the node connection relationship in the multi-node task tree, the shortest path from the start node to the target node is determined as the task execution path.

[0039] In one embodiment, after successfully constructing a multi-node task tree for the service orchestration application system, the next key step is to parse the user's input question information and determine the corresponding task execution path within the task tree. This process aims to ensure that the user's intent is accurately understood and converted into a specific execution path within the system. First, the user's input question information is received. This information may be a request, query, or command in natural language. To accurately understand the user's intent, natural language processing techniques are used to conduct in-depth analysis of the input question information. This includes, but is not limited to, lexical analysis, syntactic analysis, and semantic understanding, aiming to extract key intent and conditional information parameters from the complex language structure. The key intent reflects the core action or goal that the user wants the system to perform, while the conditional information parameters are the specific details required to perform the action, such as time, location, and quantity. By accurately extracting this information, the user's needs within the task tree can be more accurately identified. Once the key intent is extracted, a node search is performed within the multi-node task tree. This process involves matching the attribute information and description of each node in the task tree to find the start and target nodes that are most relevant to the user's intent. The start node typically represents the starting point of task execution, while the target node represents the desired end point of the task. After determining the start and target nodes, the task execution path needs to be determined based on the node connectivity within the multi-node task tree. This application uses a shortest path algorithm from graph theory, such as Dijkstra's algorithm or Floyd's algorithm, to find the shortest path from the start node to the target node. This path is considered the task execution path that meets the user's needs, as it ensures that the task can be completed in the most efficient manner.

[0040] Step 103: Based on the problem information, determine whether the condition information for executing each node task in the task execution path is sufficient.

[0041] In one embodiment of the present application, after determining the corresponding task execution path in the multi-node task tree, it is determined whether the condition information for executing each node task in the task execution path is sufficient based on the problem information.

[0042] Specifically, the required condition information for executing each node task in the task execution path is analyzed; the required condition information is compared with the condition information parameters to determine whether all the required condition information has been obtained; if the condition information of a node task is insufficient, the node is marked as an insufficient condition node, and the required supplementary condition information is recorded.

[0043] In one embodiment, after determining the corresponding task execution path in a multi-node task tree, the next important step is to verify whether the condition information required to execute each node task along this path is sufficient. This is a critical step in ensuring smooth task execution. First, the condition information required for executing each node task in the task execution path is thoroughly analyzed. This condition information may include specific data inputs, system resources, external dependencies, or permissions. By carefully reviewing the properties and execution functions of each node, the conditions necessary to execute each node task can be accurately listed. Next, the required condition information is compared with the condition information parameters previously extracted from the user question information. This comparison process confirms whether all the condition information required to execute each node task has been obtained. If the required conditions for a node completely match the existing condition information parameters, the condition information for that node is considered sufficient. However, if the comparison process finds that the condition information for a node task is insufficient, that is, the required condition information is not met, the node is marked as an insufficient condition node. At the same time, the missing condition information is recorded in detail, as this information must be supplemented before task execution. Marking nodes with insufficient conditions and recording the required supplementary conditions helps to promptly identify and resolve potential problems before task execution, ensuring that each node has the necessary conditions at the time of execution. This not only improves the success rate of task execution, but also enhances the robustness and reliability of the system.

[0044] Step 104: If the condition information is insufficient, construct a conditional request question and send the conditional request question to the user interface for round-robin questioning and answering until the acquired condition information satisfies the execution of each node task.

[0045] In one embodiment of the present application, when condition information is insufficient, a conditional request question is constructed and sent to the user interface for round-robin questioning and answering until the acquired condition information satisfies the execution of each node task.

[0046] Specifically, based on the required supplementary condition information, a corresponding conditional request question is constructed; the conditional request question is sent to the user interface and waits for the user to answer; the user's answer information is received and the answer information is parsed to verify whether the answer information meets the required supplementary condition information; if the answer information does not meet the requirements, the conditional request question is reconstructed for round-trip questioning and answering until all the required supplementary condition information is met.

[0047] In one embodiment, when insufficient conditional information is detected in a task execution path, a round-robin process is initiated to obtain the necessary supplementary conditional information from the user. First, based on the previously recorded required supplementary conditional information, corresponding conditional request questions are constructed. These questions are carefully designed to accurately guide the user to provide the specific information required. Questions should be clear and specific to avoid confusion or misunderstanding. Next, the constructed conditional request questions are sent to the user interface, awaiting the user's response. The user interface plays a critical role in this process, not only clearly presenting the question to the user but also providing a convenient input mechanism for users to easily provide their responses. Once the user enters their response, the system immediately receives and parses it. The purpose of parsing is to verify that the user's response meets the required supplementary conditional information. This verification process may involve checking various aspects such as data type, format, and range. If the user's response does not meet the requirements, such as if the provided information is incomplete, incorrectly formatted, or does not match the required conditions, the conditional request questions are reconstructed and sent to the user interface again for round-robin. This round-robin process is repeated until all the conditional information required to execute each node task is obtained.

[0048] In one embodiment of the present application, when there is sufficient conditional information, each node task is executed in sequence according to the task execution path until the entire service orchestration process is completed; the execution status of the node tasks is monitored, and the execution status of the task execution path is updated after each node task is executed.

[0049] In one embodiment, after confirming that all necessary information for executing each node's tasks is sufficient, each node's tasks will be executed sequentially along the previously determined task execution path. This process is automated, ensuring the consistency and efficiency of the service orchestration process. First, starting from the starting node of the task execution path, the execution function of each node is triggered in sequence. These execution functions are defined based on the specific functionality and business requirements of each node and perform corresponding operations or call related services. During the execution of each node's tasks, the task's execution status is strictly monitored. This includes tracking the task's start and end time, any exceptions or errors during execution, and the task's execution results. Through real-time monitoring, problems can be promptly identified and appropriate measures taken to ensure that each node's tasks are completed as expected. Whenever a node task completes, the execution status of the task execution path is immediately updated. This includes marking the completed node as "completed" and recording the relevant execution results and status information. The progress of the entire task execution path is also updated, allowing users or system administrators to clearly understand the current progress of the service orchestration. If a node task fails or encounters an exception, the error information is recorded, and appropriate remedial measures are taken according to the pre-defined error handling mechanism. This might include retrying failed tasks, skipping certain non-critical tasks, or notifying users or administrators for manual intervention.

[0050] In one embodiment of the present application, during the task execution process, if a node task fails to execute, an error handling process is triggered; the failed node task information is recorded, and a rollback operation is performed; if the rollback operation cannot be successfully executed a preset number of times, error information is fed back to the user, and the task execution path is rebuilt and executed.

[0051] In one embodiment, considering the possibility of node task execution failure during task execution, this application has also designed a comprehensive error handling process to address such issues. First, when a node task fails, the system immediately triggers the error handling process. This process first records the failed node task information, including the name of the failed node, the reason for failure, and the time of failure, to facilitate subsequent troubleshooting and problem location. Next, to restore normal task execution as much as possible, the system attempts a rollback. A rollback primarily restores the task state to its pre-failure state, ensuring that previously successfully executed node tasks are unaffected and attempting to re-execute the failed node task. During a rollback, the system first checks the pre-set rollback policy to determine the specific steps and scope of the rollback. The system then undoes the execution results of the failed node and its subsequent nodes based on these policies, ensuring that the system state remains consistent with that before the failed node was executed. However, if the failed node task still fails to execute successfully after a pre-set number of rollback attempts, the system will deem that there is an issue with the task that cannot be resolved through automatic rollback. At this point, the system provides detailed error information to the user, including information about the failed node, the cause of the failure, and any rollback attempts, so that the user can understand the specifics of the problem and take appropriate action. Furthermore, to ensure the continued operation of the service orchestration process, the system attempts to reconstruct the task execution path. During this process, the system analyzes the impact of the failed node on the entire process and attempts to find an alternative path that bypasses the failed node. If a suitable alternative path is found, the system continues executing the remaining tasks along the new task execution path.

[0052] The above is an embodiment of the method proposed in this application. Based on the same inventive concept, this application embodiment also provides a large model service arrangement device based on a task tree, whose structure is as follows Figure 2 shown.

[0053] Figure 2 This is a schematic diagram of the internal structure of a large model service arrangement device based on a task tree provided in an embodiment of the present application. Figure 2 As shown, the equipment includes:

[0054] at least one processor 201;

[0055] and, a memory 202 communicatively coupled to the at least one processor;

[0056] The memory 202 stores instructions that can be executed by at least one processor, and the instructions are executed by the at least one processor 201 to enable the at least one processor 201 to:

[0057] Traverse the application system to be serviced and orchestrated to build a multi-node task tree for the application system to be serviced and orchestrated;

[0058] Parse the question information entered by the user and, based on the parsing results, determine the corresponding task execution path in the multi-node task tree;

[0059] Based on the problem information, determine whether the condition information for executing each node task in the task execution path is sufficient;

[0060] In the case of insufficient condition information, a conditional request question is constructed and sent to the user interface for round-robin questioning and answering until the obtained condition information satisfies the execution of each node task.

[0061] Some embodiments of the present application provide corresponding Figure 1 A non-volatile computer storage medium for large-scale model service orchestration based on a task tree stores computer-executable instructions, wherein the computer-executable instructions are configured as follows:

[0062] Traverse the application system to be serviced and orchestrated to build a multi-node task tree for the application system to be serviced and orchestrated;

[0063] Parse the question information entered by the user and, based on the parsing results, determine the corresponding task execution path in the multi-node task tree;

[0064] Based on the problem information, determine whether the condition information for executing each node task in the task execution path is sufficient;

[0065] In the case of insufficient condition information, a conditional request question is constructed and sent to the user interface for round-robin questioning and answering until the obtained condition information satisfies the execution of each node task.

[0066] The various embodiments in this application are described in a progressive manner. Similar portions between the various embodiments can be referenced to each other. Each embodiment focuses on the differences from the other embodiments. In particular, the IoT device and media embodiments are generally similar to the method embodiments, so their description is relatively simple. For relevant portions, refer to the description of the method embodiments.

[0067] The system and medium provided in the embodiments of the present application correspond one-to-one to the method. Therefore, the system and medium also have similar beneficial technical effects to their corresponding methods. Since the beneficial technical effects of the method have been described in detail above, the beneficial technical effects of the system and medium will not be repeated here.

[0068] Those skilled in the art will appreciate that the embodiments of the present application can be provided as methods, systems, or computer program products. Therefore, the present application can adopt the form of a complete hardware embodiment, a complete software embodiment, or an embodiment in combination with software and hardware. Moreover, the present application can adopt the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to magnetic disk storage, CD-ROM, optical storage, etc.) that contain computer-usable program code.

[0069] The present application is described with reference to the flowcharts and / or block diagrams of the methods, devices (systems), and computer program products according to the embodiments of the present application. It should be understood that each process and / or box in the flowchart and / or block diagram, as well as the combination of the processes and / or boxes in the flowchart and / or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing device to produce a machine, so that the instructions executed by the processor of the computer or other programmable data processing device generate instructions for implementing the steps in the process. Figure 1 a process or multiple processes and / or boxes Figure 1 A device that provides the functions specified in a block or multiple blocks.

[0070] These computer program instructions may also be stored in a computer readable memory that can direct a computer or other programmable data processing device to work in a specific manner, so that the instructions stored in the computer readable memory produce an article of manufacture comprising an instruction device, which implements the process Figure 1 a process or multiple processes and / or boxes Figure 1 The function specified in one or more boxes.

[0071] These computer program instructions can also be loaded onto a computer or other programmable data processing device so that a series of operational steps are executed on the computer or other programmable device to produce a computer-implemented process, thereby providing the instructions executed on the computer or other programmable device for implementing the process. Figure 1 a process or multiple processes and / or boxes Figure 1 A step that specifies a function in one or more boxes.

[0072] In a typical configuration, a computing device includes one or more processors (CPUs), input / output interfaces, network interfaces, and memory.

[0073] Memory may include non-permanent storage in a computer-readable medium, random access memory (RAM) and / or non-volatile memory in the form of read-only memory (ROM) or flash RAM. Memory is an example of a computer-readable medium.

[0074] Computer-readable media includes permanent and non-permanent, removable and non-removable media that can be implemented by any method or technology to store information. The information can be computer-readable instructions, data structures, program modules or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technology, compact disc read-only memory (CD-ROM), digital versatile disc (DVD) or other optical storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices or any other non-transmission media that can be used to store information that can be accessed by a computing device. As defined herein, computer-readable media does not include transitory computer-readable media (transitory media), such as modulated data signals and carrier waves.

[0075] It should also be noted that the terms "comprises," "includes," or any other variations thereof are intended to encompass non-exclusive inclusion, such that a process, method, commodity, or apparatus that includes a series of elements includes not only those elements but also other elements not explicitly listed, or includes elements inherent to such process, method, commodity, or apparatus. In the absence of further limitations, an element defined by the phrase "comprises a ..." does not exclude the presence of other identical elements in the process, method, commodity, or apparatus that includes the element.

[0076] The foregoing is merely an embodiment of the present application and is not intended to limit the present application. For those skilled in the art, the present application may have various modifications and variations. Any modifications, equivalent replacements, improvements, etc. made within the spirit and principles of the present application should all be included within the scope of the claims of the present application.

Claims

1. A large model service arrangement method based on task tree, characterized in that: The method comprises: Traversing the application system to be serviced to construct a multi-node task tree of the application system to be serviced; Parse the question information entered by the user and, based on the parsing results, determine the corresponding task execution path in the multi-node task tree; Based on the problem information, determining whether condition information for executing each node task in the task execution path is sufficient; If the condition information is insufficient, construct a conditional request question and send the conditional request question to the user interface for round-robin questioning and answering until the acquired condition information satisfies the execution of each node task; Traversing the application system to be serviced to construct a multi-node task tree for the application system to be serviced, specifically including: Traverse all functional modules and operations in the application system through depth-first search or breadth-first search strategy; Create a task tree node for each functional module and operation, and set the node's attribute information; wherein the attribute information includes node ID, node type, parent node ID, child node ID list, node description and execution function; According to the dependency and execution order between each functional module or operation, the connection relationship between nodes is established to form a multi-node task tree; Parse the question information entered by the user and, based on the parsing results, determine the corresponding task execution path in the multi-node task tree, specifically including: Performing natural language processing on the question information input by the user to extract the key intent and condition information parameters of the question information; Based on the key intent, a node search is performed in the multi-node task tree to determine a corresponding start node and a target node; Determine, based on the node connection relationship in the multi-node task tree, the shortest path from the start node to the target node as the task execution path; Based on the problem information, determining whether the condition information for executing each node task in the task execution path is sufficient includes: Analyze the condition information required to execute each node task in the task execution path; Comparing the required condition information with the condition information parameters to determine whether all required condition information has been obtained; If the condition information of a node task is insufficient, mark the node as an insufficient condition node and record the required supplementary condition information; Construct a conditional request question and send it to the user interface for round-robin questioning and answering until the acquired condition information satisfies the execution of each node task, specifically including: Based on the required supplementary condition information, construct corresponding condition request questions; Send the conditional request question to the user interface and wait for the user to answer; Receiving the user's answer information and parsing the answer information to verify whether the answer information meets the required supplementary condition information; In the case that the answer information does not meet the requirements, the conditional question is reconstructed and asked and answered in turns until the required supplementary condition information is met.

2. A large model service arrangement method based on task tree according to claim 1, characterized in that: The method further comprises: When sufficient condition information is available, each node task is executed in sequence according to the task execution path until the entire service orchestration process is completed; Monitor the execution of node tasks and update the execution status of the task execution path after each node task is completed.

3. A large model service arrangement method based on task tree according to claim 1, characterized in that: The method further comprises: During the task execution process, if any node task fails to execute, the error handling process will be triggered; Record the failed node task information and perform rollback operations; If the rollback operation fails to execute successfully after the preset number of times, an error message will be fed back to the user, and the task execution path will be rebuilt and executed.

4. A large model service arrangement method based on task tree according to claim 1, characterized in that: After constructing the multi-node task tree of the application system to be serviced, the method further includes: Based on the preset visual task tree editing interface, it receives customized revision information uploaded by users; Based on the customized revision information, the multi-node task tree is updated.

5. A large model service arrangement device based on a task tree, characterized in that: The device comprises: at least one processor; and, a memory communicatively coupled to the at least one processor; The memory stores instructions that can be executed by the at least one processor, and the instructions are executed by the at least one processor to enable the at least one processor to: Traversing the application system to be serviced to construct a multi-node task tree of the application system to be serviced; Parse the question information entered by the user and, based on the parsing results, determine the corresponding task execution path in the multi-node task tree; Based on the problem information, determining whether condition information for executing each node task in the task execution path is sufficient; If the condition information is insufficient, construct a conditional request question and send the conditional request question to the user interface for round-robin questioning and answering until the acquired condition information satisfies the execution of each node task; Traversing the application system to be serviced to construct a multi-node task tree for the application system to be serviced, specifically including: Traverse all functional modules and operations in the application system through depth-first search or breadth-first search strategy; Create a task tree node for each functional module and operation, and set the node's attribute information; wherein the attribute information includes node ID, node type, parent node ID, child node ID list, node description and execution function; According to the dependency and execution order between each functional module or operation, the connection relationship between nodes is established to form a multi-node task tree; Parse the question information entered by the user and, based on the parsing results, determine the corresponding task execution path in the multi-node task tree, specifically including: Performing natural language processing on the question information input by the user to extract the key intent and condition information parameters of the question information; Based on the key intent, a node search is performed in the multi-node task tree to determine a corresponding start node and a target node; Determine, based on the node connection relationship in the multi-node task tree, the shortest path from the start node to the target node as the task execution path; Based on the problem information, determining whether the condition information for executing each node task in the task execution path is sufficient includes: Analyze the condition information required to execute each node task in the task execution path; Comparing the required condition information with the condition information parameters to determine whether all required condition information has been obtained; If the condition information of a node task is insufficient, mark the node as an insufficient condition node and record the required supplementary condition information; Construct a conditional request question and send it to the user interface for round-robin questioning and answering until the acquired condition information satisfies the execution of each node task, specifically including: Based on the required supplementary condition information, construct corresponding condition request questions; Send the conditional request question to the user interface and wait for the user to answer; Receiving the user's answer information and parsing the answer information to verify whether the answer information meets the required supplementary condition information; In the case that the answer information does not meet the requirements, the conditional question is reconstructed and asked and answered in turns until the required supplementary condition information is met.

6. A non-volatile computer storage medium for large-scale model service orchestration based on a task tree, storing computer-executable instructions, characterized in that: The computer executable instructions are configured to: Traversing the application system to be serviced to construct a multi-node task tree of the application system to be serviced; Parse the question information entered by the user and, based on the parsing results, determine the corresponding task execution path in the multi-node task tree; Based on the problem information, determining whether condition information for executing each node task in the task execution path is sufficient; If the condition information is insufficient, construct a conditional request question and send the conditional request question to the user interface for round-robin questioning and answering until the acquired condition information satisfies the execution of each node task; Traversing the application system to be serviced to construct a multi-node task tree for the application system to be serviced, specifically including: Traverse all functional modules and operations in the application system through depth-first search or breadth-first search strategy; Create a task tree node for each functional module and operation, and set the node's attribute information; wherein the attribute information includes node ID, node type, parent node ID, child node ID list, node description and execution function; According to the dependency and execution order between each functional module or operation, the connection relationship between nodes is established to form a multi-node task tree; Parse the question information entered by the user and, based on the parsing results, determine the corresponding task execution path in the multi-node task tree, specifically including: Performing natural language processing on the question information input by the user to extract the key intent and condition information parameters of the question information; Based on the key intent, a node search is performed in the multi-node task tree to determine a corresponding start node and a target node; Determine, based on the node connection relationship in the multi-node task tree, the shortest path from the start node to the target node as the task execution path; Based on the problem information, determining whether the condition information for executing each node task in the task execution path is sufficient includes: Analyze the condition information required to execute each node task in the task execution path; Comparing the required condition information with the condition information parameters to determine whether all required condition information has been obtained; If the condition information of a node task is insufficient, mark the node as an insufficient condition node and record the required supplementary condition information; Construct a conditional request question and send it to the user interface for round-robin questioning and answering until the acquired condition information satisfies the execution of each node task, specifically including: Based on the required supplementary condition information, construct corresponding condition request questions; Send the conditional request question to the user interface and wait for the user to answer; Receiving the user's answer information and parsing the answer information to verify whether the answer information meets the required supplementary condition information; In the case that the answer information does not meet the requirements, the conditional question is reconstructed and asked and answered in turns until the required supplementary condition information is met.

Images