Plug-in parallel scheduling method, electronic equipment and storage medium

Abstract

The invention discloses a plug-in parallel scheduling method, electronic equipment and a storage medium. The method comprises the following steps: analyzing a problem of a user through a plug-in calling planning module and generating a directed acyclic graph containing a plurality of plug-in calling nodes and dependency relationships; extracting the directed acyclic graph based on a task extraction module, and generating a task set containing a task list and a task dependency relationship; the task executor performs parallel execution on the tasks without dependency conflicts based on the task set, and returns an execution result to the plug-in calling planning module; and the plug-in calling planning module dynamically adjusts and generates a new directed acyclic graph according to the returned execution result. According to the embodiment of the invention, the plug-in planning module, the task extraction module and the task executor are matched to realize the parallel plug-in scheduling strategy and the dynamic planning capability, the execution strategy can be dynamically adjusted by depending on the intermediate generation result of the plug-in for a complex task scene, and the requirement of a user for a complex problem scene is met.

Description

Technical Field

[0001] The present application belongs to the field of language model technology, and in particular relates to a plug-in parallel scheduling method, an electronic device, and a storage medium. Background Art

[0002] ReAct (ReAct): Collaborative Reasoning and Action in Language Models. The core idea of ​​ReAct is to combine reasoning and action, achieving synergy between reasoning and action by prompting the Large Language Model (LLM) to generate reasoning trajectories and task-specific actions. The following are the main steps and implementation details of ReAct: 1. Domain Selection: ReAct can be applied to a variety of domains, such as question answering, fact checking, text games, and web navigation. 2. Action Design: Based on the specific task, actions that the Large Language Model (LLM) can perform are designed, such as search and find. For example, in question answering tasks, search actions can be used to retrieve information. In text game tasks, actions such as move and view can be used to interact with the environment. 3. Prompt Design: Example trajectories are generated using annotations, each containing a series of actions, reasoning, and observations. Users guide LLM learning; prompt content is designed based on the task type. 4. LLM Reasoning: Reasoning trajectories are generated based on prompt content, such as decomposing task objectives, extracting information, performing commonsense reasoning, tracking progress, and handling exceptions. Combine the reasoning trajectory with the action and observation results to update the environment state. For example, in question-answering tasks, the answer is generated based on the reasoning results, and in text-based game tasks, the game state is updated based on the action results. 5. Action Execution: Execute the corresponding action based on the generated reasoning trajectory. For example, in question-answering tasks, the reasoning result is converted into an answer; in text-based game tasks, the action instructions are used to interact with the environment. 6. Results Evaluation: Analyze the reasoning and action results of the LLM to evaluate the performance and effectiveness of ReAct.

[0003] Similar products using related technologies primarily include the ByteDance Button Platform Intelligent Agent Plugin. By calling external functions, large models can perform tasks beyond their original training scope, such as querying databases, performing calculations, and calling APIs. For tasks requiring real-time data or specialized knowledge, the model can obtain the latest information by calling the corresponding function, improving the accuracy of the output. The specific steps are as follows: 1. Function Registration: Register the external function in the model's environment, defining the function's signature (name, parameter types, and return type); 2. Intent Recognition: When the model generates text, it attempts to understand the intent of the user's request and determine whether a function call is necessary; 3. Parameter Extraction: If a function call is required, the model extracts the necessary parameters from the generated text; 4. Function Calling: The model calls the corresponding function and passes in the extracted parameters; 5. Result Processing: After the function executes, the result is returned to the model, which then generates further responses based on the result. Large models originally performed inference and text generation based solely on their training data, but through Function Calling, they can transcend these limitations and perform complex tasks.

[0004] The inventors found that the scheduling of skill plug-ins by the large language model intelligent agent Agent, whether the ReAct method or ByteDance's skill plug-in scheduling method, has the following defects: the inability to execute in parallel leads to high system latency: they both adopt a sequential execution method, that is, LLM executes reasoning and Action steps in sequence. This leads to delays and low efficiency, especially in tasks that require a large number of reasoning and Action steps. A static execution plan is used, and there is no ability to dynamically adjust the plan: this will cause LLM to be unable to effectively plan execution when faced with complex or uncertain tasks.

[0005] The core concept of ReAct is the alternating execution of reasoning and action, with each step of action depending on the result of the previous round of reasoning. This design is inherently serial. Each reasoning and action step strictly depends on the result of the previous step, and the model needs to wait until the current step is completed before generating the next step. For example, the model may need to complete information retrieval first and then decide on the next action based on the retrieval results. This dependency makes parallel execution impossible. Even if there may be no dependencies between tasks (such as querying two unrelated pieces of information at the same time), ReAct's step-by-step generation strategy cannot initiate these queries at the same time. Parallel execution requires that the dependencies between tasks be clearly modeled to identify which tasks can be performed independently, but ReAct does not have such a mechanism. When ReAct interacts with external tools (such as calling APIs or querying databases), it needs to rely on feedback from the results of synchronous execution.

[0006] The inventors also discovered that the ReAct method's inability to efficiently perform dynamic replanning stems primarily from core limitations of its design: a fixed order of reasoning and action, and a lack of explicit dependency management between tasks. Each action in the model depends on the reasoning of the previous step, lacking a global perspective. It's impossible to predict which tasks are independent and can be completed in parallel. The reasoning trajectory in the ReAct method is a static artifact of its generation and lacks the flexibility to adjust. If the reasoning trajectory errs, it cannot be promptly corrected, as with dynamic replanning. Summary of the Invention

[0007] The embodiments of the present application aim to solve at least one of the above technical problems.

[0008] In the first aspect, an embodiment of the present application provides a plug-in parallel scheduling method, including: parsing the user's problem through a plug-in call planning module and generating a directed acyclic graph containing multiple plug-in call nodes and dependency relationships; extracting the directed acyclic graph based on a task extraction module, and generating a task set containing a task list and task dependency relationships; the task executor executes tasks without dependency conflicts in parallel based on the task set, and returns the execution results to the plug-in call planning module; the plug-in call planning module dynamically adjusts and generates a new directed acyclic graph based on the returned execution results.

[0009] In a second aspect, an embodiment of the present application provides a training method for a large language model, which is used for the above-mentioned plug-in parallel scheduling method. The method includes: obtaining a skill plug-in data set from the platform, and verifying whether the skill plug-in data set conforms to the data format required for training the large language model; if the skill plug-in data set conforms to the training requirements, directly training the large language model; if the skill plug-in data set does not conform to the training requirements, normalizing the skill plug-in data set, and using the normalized data set to train the large language model.

[0010] In a third aspect, an embodiment of the present application provides an electronic device comprising: at least one processor, and a memory communicatively connected to the at least one processor, wherein the memory stores instructions executable 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 execute any one of the above-mentioned plug-in parallel scheduling methods of the present application.

[0011] In a fourth aspect, an embodiment of the present application provides a storage medium, which stores one or more programs including execution instructions, and the execution instructions can be read and executed by an electronic device (including but not limited to a computer, a server, or a network device, etc.) to execute any of the above-mentioned plug-in parallel scheduling methods of the present application.

[0012] In a fifth aspect, an embodiment of the present application further provides a computer program product, which includes a computer program stored on a storage medium, and the computer program includes program instructions. When the program instructions are executed by a computer, the computer executes any one of the above-mentioned plug-in parallel scheduling methods.

[0013] The present embodiment designs a separate plug-in scheduling module to generate a directed acyclic graph for plug-in scheduling. The task extraction module extracts the single or multiple tasks that need to be executed, and the task executor executes the tasks in parallel. The plug-in planning module, task extraction module, and task executor work together to implement a parallel plug-in scheduling strategy and dynamic planning capabilities. For complex task scenarios, the execution strategy can be dynamically adjusted based on the intermediate generation results of the plug-in, solving the needs of users in complex problem scenarios. BRIEF DESCRIPTION OF THE DRAWINGS

[0014] In order to more clearly illustrate the technical solutions of the embodiments of the present application, the following briefly introduces the drawings required for use in the description of the embodiments. Obviously, the drawings described below are some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without any creative work.

[0015] Figure 1 This is a flowchart of an embodiment of the plug-in parallel scheduling method of the present application; Figure 2 This is a flowchart of another embodiment of the plug-in parallel scheduling method of the present application; Figure 3 A flowchart of a large language model training method provided in this application; Figure 4 This is a schematic diagram comparing the example process of the plug-in parallel scheduling method of this application with the plug-in ReAct process; Figure 5 A flowchart of the implementation process of a plug-in parallel scheduling method provided by this application; Figure 6 This is a schematic structural diagram of an embodiment of an electronic device of the present application. DETAILED DESCRIPTION

[0016] To make the purpose, technical solutions, and advantages of the embodiments of this application more clear, the technical solutions in the embodiments of this application will be clearly and completely described below in conjunction with the drawings in the embodiments of this application. Obviously, the described embodiments are part of the embodiments of this application, not all of the embodiments. 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.

[0017] It should be noted that, unless there is any conflict, the embodiments and features in the embodiments of this application can be combined with each other.

[0018] The present application may be described in the general context of computer-executable instructions executed by a computer, such as program modules. Generally, program modules include routines, programs, objects, components, data structures, etc. that perform specific tasks or implement specific abstract data types. The present application may also be practiced in distributed computing environments where tasks are performed by remote processing devices connected through a communications network. In a distributed computing environment, program modules may be located in local and remote computer storage media, including storage devices.

[0019] In this application, "module", "device", "system" and the like refer to related entities applied to a computer, such as hardware, a combination of hardware and software, software or software in execution, etc. Specifically, for example, an element can be, but is not limited to, a process running on a processor, a processor, an object, an executable element, an execution thread, a program and / or a computer. In addition, an application or script running on a server, or a server can all be an element. One or more elements can be in an execution process and / or thread, and an element can be localized on a computer and / or distributed between two or more computers, and can be run by various computer-readable media. An element can also communicate via local and / or remote processes based on a signal having one or more data packets, for example, a signal from a data packet interacting with another element in a local system, a distributed system, and / or a signal from a network on the Internet that interacts with other systems via signals.

[0020] Finally, it should be noted that, in this document, relational terms such as first and second, etc., are used only to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any actual relationship or order between these entities or operations. Moreover, the terms "include" and "comprise" include not only those elements, but also other elements not explicitly listed, or elements inherent to such process, method, article or device. In the absence of further limitations, the elements defined by the phrase "include..." do not exclude the presence of other identical elements in the process, method, article or device that includes the elements.

[0021] The present invention provides a method for parallel scheduling of plug-ins, which can be applied to electronic devices. The electronic devices can be computers, servers, or other electronic products, and the present invention does not limit them.

[0022] Please refer to Figure 1 , which illustrates a plug-in parallel scheduling method provided by an embodiment of the present application.

[0023] like Figure 1 As shown, in step 101, the user's problem is parsed through the plug-in call planning module and a directed acyclic graph including multiple plug-in call nodes and dependency relationships is generated; In step 102, the directed acyclic graph is extracted based on a task extraction module, and a task set including a task list and task dependencies is generated; In step 103, the task executor executes the tasks without dependency conflicts in parallel based on the task set, and returns the execution results to the plug-in call planning module; In step 104, the plug-in call planning module dynamically adjusts and generates a new directed acyclic graph according to the returned execution result.

[0024] In this embodiment, for step 101, the user's problem is parsed through the plug-in call planning module and a directed acyclic graph containing multiple plug-in call nodes and dependency relationships is generated. For example, the user's problem is received and analyzed through the plug-in call planning module, and then a corresponding plug-in call directed acyclic graph (DAG) is generated based on the pre-trained large model, where the directed acyclic graph DAG contains multiple task nodes and their dependency relationships. This is equivalent to analyzing the user's problem through a fine-tuned large language model (LLM) to generate a directed acyclic graph (DAG) of plug-in calls, wherein, combined with the description information of the skill plug-in, a directed acyclic graph containing the task execution order and dependency relationships is generated. The plug-in call planning module plans the plug-ins required for the user's problem and generates a directed acyclic graph of plug-in calls, wherein the plug-in call planning module is a pre-trained module.

[0025] Afterwards, for step 102, the directed acyclic graph is extracted based on the task extraction module, and a task set including a task list and task dependencies is generated. The task extraction module generates an executable task set including a task list and task dependencies based on the directed acyclic graph. Based on the directed acyclic graph generated above, the task extraction module generates a task list and the dependencies between tasks. The task extraction module parses the directed acyclic graph and extracts the task list and the dependencies between tasks in the directed acyclic graph. The task extraction module can convert the directed acyclic graph into a task list or a task set. The task list or task set includes tasks that can be executed in parallel and their dependencies.

[0026] Then, for step 103, the task executor executes the tasks without dependency conflicts in parallel based on the task set and returns the execution results to the plug-in call planning module. The task executor executes the tasks in parallel according to the task list or task set and returns the execution results to the plug-in call planning module. The task executor executes the tasks in parallel according to the above-mentioned task list and returns the results of the task execution to the plug-in call planning module.

[0027] Finally, in step 104, the plug-in call planning module dynamically adjusts and generates a new directed acyclic graph based on the returned execution results. The plug-in call planning module determines whether a new plug-in call directed acyclic graph needs to be generated based on the results returned by the task executor. The plug-in scheduling module dynamically determines whether a new directed acyclic graph needs to be generated based on the execution results to achieve dynamic task planning.

[0028] The method of the present application implements parallel plug-in scheduling strategies and dynamic planning capabilities through the collaboration of a plug-in planning module, a task extraction module, and a task executor. For complex task scenarios, the method dynamically adjusts the execution strategy based on the plug-in's intermediate generation results, addressing the needs of complex user scenarios. This method enables parallel task execution, reduces Agent system latency, and utilizes the intermediate results of plug-in task execution to achieve dynamic task planning and improve the accuracy of complex problems.

[0029] Please refer to Figure 2 , which illustrates another plug-in parallel scheduling method provided by an embodiment of the present application.

[0030] like Figure 2 As shown, in step 201, the plug-in calls the planning module to determine whether a new directed acyclic graph needs to be generated based on the execution result. If necessary, the new directed acyclic graph is extracted to regenerate a new task set including a task list and task dependencies; In step 202, if not necessary, the unfinished tasks in the task list continue to be executed until the task list is empty.

[0031] In this embodiment, for step 201, the plug-in call planning module determines whether a new directed acyclic graph needs to be generated based on the execution result. If so, the new directed acyclic graph is extracted and a new task set containing a task list and task dependencies is regenerated. The plug-in scheduling planning module determines whether a new directed acyclic graph needs to be generated based on the returned result. If so, it returns to step 101 and performs subsequent processing on the generated new directed acyclic graph.

[0032] Then, for step 202, if not needed, continue to execute the unfinished tasks in the task list until the task list is empty. If not needed, continue to execute the unfinished tasks until the task list is empty.

[0033] The method of the embodiment of the present application realizes dynamic task planning and improves the accuracy of complex problems by utilizing the intermediate results of plug-in task execution.

[0034] In some optional embodiments, the plugin call planning module includes a pre-trained large language model. The plugin call planning module parses the user's question and generates a directed acyclic graph containing multiple plugin call nodes and dependencies. This includes analyzing the user's question using the large language model, which can generate a directed acyclic graph containing the task execution sequence and dependencies. The user's question is analyzed using the fine-tuned large language model, combined with the description information of the skill plugin, to generate a directed acyclic graph containing the task execution sequence and dependencies.

[0035] In some optional embodiments, the task executor determines a set of tasks to be executed in parallel based on the dependencies in the task list, executes tasks without dependencies concurrently, and executes tasks with dependencies sequentially. A plug-in call planning module is used to generate a directed acyclic graph of plug-in calls; a task extraction module is used to convert the directed acyclic graph into a task list; the task executor is used to execute tasks in parallel based on the task list and feed back the execution results to the plug-in call planning module; the plug-in call planning module dynamically generates a new directed acyclic graph based on the fed-back execution results to form a closed-loop scheduling.

[0036] In some optional embodiments, after the parallel execution of tasks without dependency conflicts is completed, the large language model is called to integrate the execution results, generate a final answer, and return it to the user. After the task execution is completed, the large language model is called to integrate the execution results, generate a final answer, and return it to the user.

[0037] In some optional embodiments, before parsing the user's question through the plug-in call planning module and generating a directed acyclic graph containing multiple plug-in call nodes and dependencies, it includes: obtaining the user's question and determining whether it is necessary to generate an execution plan; if it is necessary to generate an execution plan, the trained large language model is used as the plug-in call planning module in the parallel plug-in scheduling system, and a corresponding directed acyclic graph is generated; if it is not necessary to generate an execution plan, the answer is directly summarized through the large language model and returned to the user. After receiving the user's question, it is determined whether an execution plan needs to be generated. If so, the corresponding directed acyclic graph is generated through the fine-tuned large model; if not, the answer is directly generated through the large model and fed back to the user. For example, the user's question is obtained, and it is determined whether an execution plan needs to be generated. If so, the fine-tuned large model is used as the skill call planning model in the parallel plug-in scheduling system to generate a corresponding directed acyclic graph. If not, the answer is directly summarized through the large language model and returned to the user.

[0038] Please refer to Figure 3 , which shows a training method for a large language model provided by the present application, wherein the large language model is used for the above-mentioned plug-in parallel scheduling method.

[0039] like Figure 3 As shown, in step 301, a skill plug-in dataset is obtained from the platform, and the skill plug-in dataset is verified to be in the data format required for the large language model training; In step 302, if the skill plug-in dataset meets the training requirements, the large language model is directly trained; In step 303, if the skill plug-in dataset does not meet the training requirements, the skill plug-in dataset is normalized, and the large language model is trained using the normalized dataset.

[0040] In step 301, a skill plug-in dataset is obtained from the platform and verified to see if it conforms to the data format required for large language model training. For example, detailed data of the skill plug-in is obtained from the DUI platform to determine if it conforms to the format requirements for LLM large language model fine-tuning training data.

[0041] Then, in step 302, if the skill plug-in dataset meets the training requirements, the large language model is trained directly. For example, if the detailed data of the skill plug-in obtained from the DUI platform meets the format requirements for large language model fine-tuning training data, this data is used as the training set for large language model fine-tuning, and the plug-in call planning module is fine-tuned.

[0042] Finally, in step 303, if the skill plug-in dataset does not meet the training requirements, the skill plug-in dataset is normalized and the large language model is trained using the normalized dataset. If the detailed data of the skill plug-in obtained from the DUI platform does not meet the format requirements of the large language model fine-tuning training data, data normalization is performed. Normalization mainly includes: text cleaning, text cropping and splicing. The text cleaning steps are: 1. Removing useless characters; 2. Removing useless tag data (HTML tags and Markdown tags). Text cropping and splicing are mainly to limit the maximum length of the model input.

[0043] The method of the embodiment of the present application trains a large language model and then uses the large language model to fine-tune the plug-in call planning module, so that the plug-in call planning module can generate a directed acyclic graph, so that subsequent tasks can be executed concurrently, thereby reducing system latency.

[0044] It should be noted that the existing similar technologies generally have high latency for large model Agent systems: the usual solutions include parallel scheduling of plug-ins, limiting the number of interactions with large models, limiting prompt length, and optimizing model inference speed. Regarding the ability of dynamic re-planning in the plug-in parallel scheduling system: In the plug-in parallel scheduling system, the execution result of the plug-in is passed back to the planning module as intermediate information, and the execution plan of the new plug-in task is generated in parallel. This application adopts a plug-in parallel scheduling method. This method relies on the detailed description information of large models for different types of plug-ins in different fields in vertical scenarios, and it is necessary to design a framework that supports parallel scheduling of plug-ins from the perspective of system architecture, and it needs to be customized and developed for the company's business scenarios.

[0045] Please refer to Figure 4 , which presents a schematic diagram comparing an example process of the plug-in parallel scheduling method provided in this application with the plug-in ReAct process.

[0046] like Figure 4 As shown in the figure, the large model agent technology enables the large language model (LLM) to expand its inherent knowledge and can expand the capabilities of the large model by calling plug-ins. The ReAct plug-in calling framework continuously decomposes the problem and calls plug-ins by alternating the Reason and Action steps to solve the user's problem. However, the serial method of ReAct causes a large delay in the agent, especially when the user's problem is complex and requires multiple plug-in calls to obtain the final result. Figure 4 As shown in the ReAct process on the left, the agent must serially call four plug-ins to obtain the desired result. Furthermore, the process is relatively fixed: inference - plug-in scheduling - observation. These three steps are repeated continuously until the user's query is satisfied. There is no dynamic programming capability.

[0047] against Figure 4 The left part of the ReAct framework, this application proposes a new parallel plug-in scheduling framework, such as Figure 4 As shown on the right side of the diagram, this application addresses the high latency issue of serial scheduling by designing a separate plug-in scheduling module to generate a directed acyclic graph (DAG) for plug-in scheduling. The task extraction module extracts the single or multiple tasks to be executed, and the task executor executes the tasks in parallel. The collaboration of these three modules enables parallel execution of tasks when scheduling multiple plug-ins for complex problems, optimizing overall system latency.

[0048] The task executor's execution results are then returned to the plug-in scheduler, generating a new directed acyclic graph of task execution under specific circumstances, enabling dynamic planning capabilities. For complex task scenarios, the plug-in's intermediate generation results can be used to dynamically adjust execution strategies, addressing complex user scenarios.

[0049] Concept and principle: Through the cooperation between the plug-in planning module, task extraction module, and task executor, parallel plug-in scheduling strategy and dynamic planning capabilities are implemented to meet the needs of users in complex scenarios.

[0050] step: 1) The plug-in call planning module plans the plug-ins required for the user's problem and generates a directed acyclic graph of plug-in calls; 2) Based on the generated directed acyclic graph, the task extraction module generates a task list and the dependencies between tasks; 3) The task executor executes the tasks in parallel according to the above task list and returns the results of the task execution to step 1; 4) The plug-in call planning module decides whether to generate a new plug-in call directed acyclic graph based on the return result of the task executor. If necessary, go to step 1; if not, go to step 3 and continue executing tasks until the task list is empty.

[0051] It can realize parallel task execution and reduce the delay of Agent system; it can use the intermediate results of plug-in task execution to realize dynamic task planning and improve the accuracy of complex problems.

[0052] Please refer to Figure 5 , which presents an implementation flow chart of the plug-in parallel scheduling method of this application.

[0053] like Figure 5 As shown, Figure 5 The detailed technical solution for this application includes three parts: LLM fine-tuning module, plug-in scheduling module, and DUI skill plug-in. The main steps are described below: Step 1: Obtain detailed data of the skill plug-in from the DUI platform and determine whether this data meets the format requirements of LLM fine-tuning training data; Step 2: If the data in step 1 above meets the requirements, use this data as the training set for LLM fine-tuning to fine-tune the pre-trained plug-in call planning module. If it does not meet the requirements, perform data normalization. Step 3: Obtain the user's question and determine whether an execution plan needs to be generated. If so, use the plug-in call planning module fine-tuned in step 2 as the skill call planning model in the parallel plug-in scheduling system to generate the corresponding directed acyclic graph (DAG). If not, directly summarize the answer using the LLM and return it to the user. Step 4: Convert the DAG generated in step 3 into a task list through the task extraction module; Step 5: The task executor reads the tasks in the task list, executes the tasks in parallel according to their dependencies, and returns the execution results to the skill planning module; Step 6: The skill planning module determines whether a new DAG needs to be generated. If so, it proceeds to step 3. If not, it waits until all tasks in the task list are completed. Step 7: Finally, call the LLM summary capability to summarize the problem and return it to the user.

[0054] It's important to note that this application uses a skill call planning model to generate a directed acyclic graph (DAG), enabling subsequent tasks to execute concurrently and reducing system latency. Table 1 shows a test report showing a significant improvement in latency compared to the ReAct framework. In particular, when there are many plug-ins, latency is approximately doubled.

[0055] The plug-in in this application returns the corresponding execution results to the plug-in scheduling and planning module, allowing the planning module to regenerate the DAG based on the intermediate results, thereby improving the system's accuracy for complex problems. As can be seen from the experimental data in Table 1, the accuracy has also been significantly improved for complex problems.

[0056] Test set Agent Framework Number of plug-ins Average latency Accuracy Testset (20) ReAct 20 1.8s 74% Testset (20) Parallel Scheduling Framework 20 1.3s 78% Testset (100) ReAct 100 3.4s 54% Testset (100) Parallel Scheduling Framework 100 1.7s 72% Table 1 It should be noted that, for the aforementioned method embodiments, for the sake of simplicity of description, they are all expressed as a series of combined actions, but those skilled in the art should be aware that this application is not limited by the order of the actions described, because according to this application, certain steps can be performed in other orders or simultaneously. Secondly, those skilled in the art should also be aware that the embodiments described in the specification are all preferred embodiments, and the actions and modules involved are not necessarily required by this application. In the above embodiments, the description of each embodiment has its own emphasis. For parts that are not described in detail in a certain embodiment, please refer to the relevant description of other embodiments.

[0057] In some embodiments, an embodiment of the present application provides a non-volatile computer-readable storage medium, which stores one or more programs including execution instructions, and the execution instructions can be read and executed by an electronic device (including but not limited to a computer, a server, or a network device, etc.) to execute any of the above-mentioned plug-in parallel scheduling methods of the present application.

[0058] In some embodiments, the embodiments of the present application also provide a computer program product, which includes a computer program stored on a non-volatile computer-readable storage medium, and the computer program includes program instructions. When the program instructions are executed by a computer, the computer executes any of the above-mentioned plug-in parallel scheduling methods.

[0059] In some embodiments, an embodiment of the present application also provides an electronic device, comprising: at least one processor, and a memory communicatively connected to the at least one processor, wherein the memory stores instructions executable 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 execute the plug-in parallel scheduling method.

[0060] Figure 6 FIG. 1 is a schematic diagram of the hardware structure of an electronic device for executing a plug-in parallel scheduling method provided by another embodiment of the present application, such as Figure 6 As shown, the device includes: One or more processors 610 and memory 620, Figure 6 A processor 610 is taken as an example.

[0061] The device for executing the plug-in parallel scheduling method may further include: an input device 630 and an output device 640 .

[0062] The processor 610, the memory 620, the input device 630 and the output device 640 may be connected via a bus or other means. Figure 6 The bus connection is taken as an example.

[0063] Memory 620, as a non-volatile computer-readable storage medium, can be used to store non-volatile software programs, non-volatile computer executable programs, and modules, such as the program instructions / modules corresponding to the plug-in parallel scheduling method in the embodiments of the present application. Processor 610 executes the non-volatile software programs, instructions, and modules stored in memory 620 to execute various server functional applications and data processing, thereby implementing the plug-in parallel scheduling method in the above method embodiment.

[0064] The memory 620 may include a program storage area and a data storage area, wherein the program storage area may store an operating system and application programs required for at least one function; the data storage area may store data created based on the use of the plug-in parallel scheduling device, etc. In addition, the memory 620 may include a high-speed random access memory and may also include a non-volatile memory, such as at least one disk storage device, a flash memory device, or other non-volatile solid-state storage device. In some embodiments, the memory 620 may optionally include a memory remotely located relative to the processor 610, and these remote memories may be connected to the plug-in parallel scheduling device via a network. Examples of the above-mentioned network include, but are not limited to, the Internet, an intranet, a local area network, a mobile communication network, and combinations thereof.

[0065] The input device 630 can receive input digital or character information and generate signals related to user settings and function control of the plug-in parallel scheduling device. The output device 640 can include a display device such as a display screen.

[0066] The one or more modules are stored in the memory 620 , and when executed by the one or more processors 610 , perform the plug-in parallel scheduling method in any of the above method embodiments.

[0067] The above-mentioned product can execute the method provided in the embodiment of this application, and has the functional modules and beneficial effects corresponding to the execution method. For technical details not fully described in this embodiment, please refer to the method provided in the embodiment of this application.

[0068] The electronic devices of the embodiments of the present application exist in various forms, including but not limited to: (1) Mobile communication devices: These devices are characterized by their mobile communication capabilities and their primary purpose is to provide voice and data communications. These terminals include smartphones, multimedia phones, feature phones, and low-end phones.

[0069] (2) Ultra-mobile personal computer devices: These devices fall under the category of personal computers and have computing and processing capabilities, and generally also have mobile Internet access. These terminals include PDAs, MIDs, and UMPCs.

[0070] (3) Portable entertainment devices: These devices can display and play multimedia content. They include audio and video players, handheld game consoles, e-books, smart toys, and portable car navigation devices.

[0071] (4) Other onboard electronic devices with data interaction functions, such as onboard computer devices installed in vehicles.

[0072] The device embodiments described above are merely illustrative. The units described as separate components may or may not be physically separate, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed across multiple network units. Some or all of the modules may be selected based on actual needs to achieve the objectives of this embodiment.

[0073] Through the description of the above embodiments, those skilled in the art will clearly understand that each embodiment can be implemented using software plus a general hardware platform, or of course, hardware. Based on this understanding, the essence of the above technical solution, or the portion that contributes to the relevant technology, can be embodied in the form of a software product. This computer software product can be stored in a computer-readable storage medium, such as ROM / RAM, a magnetic disk, or an optical disk, and includes a number of instructions for causing a computer device (such as a personal computer, server, or network device) to execute the methods described in each embodiment or certain portions of the embodiments.

[0074] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present application, rather than to limit them. Although the present application has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some of the technical features therein. However, these modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the embodiments of the present application.

Claims

1. A plug-in parallel scheduling method, comprising: The plug-in call planning module analyzes the user's problem and generates a directed acyclic graph containing multiple plug-in call nodes and dependency relationships; Extracting the directed acyclic graph based on a task extraction module and generating a task set including a task list and task dependency relationships; The task executor executes the tasks without dependency conflicts in parallel based on the task set, and returns the execution results to the plug-in call planning module; The plug-in call planning module dynamically adjusts and generates a new directed acyclic graph according to the returned execution result.

2. The method according to claim 1, wherein The plug-in call planning module dynamically adjusts and generates a new directed acyclic graph based on the returned execution results, including: The plug-in calling planning module determines whether a new directed acyclic graph needs to be generated according to the execution result, and if necessary, extracts the new directed acyclic graph and regenerates a new task set including a task list and task dependencies; If not, continue to execute the unfinished tasks in the task list until the task list is empty.

3. The method according to claim 1, wherein The plug-in call planning module includes a pre-trained large language model. The plug-in call planning module parses the user's question and generates a directed acyclic graph containing multiple plug-in call nodes and dependency relationships, including: The user question is analyzed by the large language model, and the large language model can generate a directed acyclic graph including the task execution sequence and dependency relationships.

4. The method according to claim 1, wherein The task executor executes tasks without dependency conflicts in parallel based on the task dependencies, including: The task executor determines a set of tasks to be executed in parallel according to the dependency relationships in the task list, executes tasks without dependency relationships concurrently, and executes tasks with dependency relationships in sequence.

5. The method according to claim 1, wherein After parallel execution of tasks without dependency conflicts, including: The large language model is called to integrate the execution results, generate a final answer and return it to the user.

6. The method according to claim 1, wherein Before parsing the user's problem through the plug-in call planning module and generating a directed acyclic graph including multiple plug-in call nodes and dependency relationships, the following steps are included: Obtain the user question and determine whether an execution plan needs to be generated; If an execution plan needs to be generated, the trained large language model is used as the plug-in call planning module in the parallel plug-in scheduling system, and a corresponding directed acyclic graph is generated; If it is not necessary to generate an execution plan, the answer is directly summarized by the large language model and returned to the user.

7. The method according to claim 1, wherein The directed acyclic graph is converted into a task list by the task extraction module.

8. A method for training a large language model, wherein the large language model is used in the plug-in parallel scheduling method according to any one of claims 1 to 7, wherein: The method comprises: Obtain a skill plug-in dataset from the platform, and verify whether the skill plug-in dataset conforms to the data format required for large language model training; If the skill plug-in dataset meets the training requirements, the large language model is trained directly; If the skill plug-in dataset does not meet the training requirements, the skill plug-in dataset is normalized, and the large language model is trained using the normalized dataset.

9. An electronic device comprising: At least one processor, and a memory communicatively connected to the at least one processor, wherein the memory stores instructions executable 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 perform the steps of the method according to any one of claims 1 to 8.

10. A storage medium having a computer program stored thereon, characterized in that: When the program is executed by a processor, the steps of the method according to any one of claims 1 to 8 are implemented.

Images