Loop task processing method and device, electronic equipment and storage medium

Abstract

The invention provides a loop task processing method and device, electronic equipment and a storage medium. According to the method, a loop task is split into a plurality of independent sub-tasks which can be executed in parallel through a pre-trained first large language model, and a sub-task list is constructed. And generating a sub-session of each sub-task through a local loop execution component deployed in the agent, and promoting the second large language model to execute the corresponding sub-task through the sub-session. And one sub-session corresponds to one sub-task, and the second large language model can accurately determine the task to be executed currently according to the sub-session, so that the accuracy of the whole task is guaranteed. And the local loop execution component circularly traverses the whole sub-task list according to the sub-response of each sub-task by the second large language model to ensure that each sub-task is completely executed without omission. The method effectively solves the problem that a large language model cannot determine a task needing to be executed currently due to the fact that the context of a single session is too long.

Description

Technical Field

[0001] This invention relates to the field of computer technology, and more specifically to a method, apparatus, electronic device, and storage medium for processing cyclic tasks. Background Technology

[0002] Recurring tasks refer to batch tasks that are processed repeatedly using the same processing flow. In recurring task scenarios, large model LLMs encounter the problem of rapid context expansion. As the context becomes larger, large model LLMs struggle to grasp the tasks that need to be executed, and the execution effect gradually declines. Often, they can only execute a few tasks before automatically terminating. Summary of the Invention

[0003] Purpose of the invention: The present invention aims to provide a method, apparatus, electronic device and storage medium for handling recurring tasks, so as to solve the shortcomings of large model LLM when facing recurring tasks.

[0004] Summary of the Invention: To achieve the above objectives, the present invention proposes the following technical solution: Firstly, a method for processing recurring tasks is provided, the method comprising: In response to receiving a recurring task published by the user, the large model agent calls a pre-trained first large language model and uses the first large language model to construct a sub-task list based on the recurring task. The sub-task list contains multiple independent sub-tasks that can be executed in parallel. The large model agent invokes a pre-deployed local loop component, and uses the local loop component to generate a sub-session for each sub-task in the sub-task list to trigger the second large language model to execute the corresponding sub-task. The local loop component sends the sub-session to the second large language model so that the second large language model can execute the corresponding sub-tasks in parallel and obtain the sub-task response fed back by the second large language model after completing the sub-task; The local loop component iterates through the subtask list based on the subtask response to determine the completion status of the subtask. When all subtasks are completed, the local loop component constructs total response information based on the subtask responses of all subtasks. The large model agent feeds back the total response information to the user.

[0005] As an optional implementation of the method described in the first aspect, the training method of the first large language model specifically includes: Obtain a text sample of the recurring task; The recurring task described by the recurring task text sample is decomposed into independent subtasks that can be executed in parallel, and a list of subtasks is constructed as training labels for the recurring task text sample. The recurring task text sample is input into the pre-built first large language model, triggering the first large language model to generate a sub-task list based on the recurring task text sample; A loss function is constructed based on the sub-task list generated by the first large language model and the training labels, and the first large language model is trained using the loss function.

[0006] As an optional implementation of the method described in the first aspect, the large model agent invokes a pre-trained first large language model and uses the first large language model to construct a sub-task list based on the cyclic task, specifically including: The large model agent inputs the task description text of the recurring task into the first large language model, and triggers the first large language model to decompose the recurring task into multiple independent sub-tasks that can be executed in parallel by constructing prompt words, and outputs the list of sub-tasks.

[0007] As an optional implementation of the method described in the first aspect, the method further includes: Before the large model agent calls the local loop component, the local loop component is registered in the tools list of the first and second large language models.

[0008] Secondly, a recurring task processing apparatus is provided, the apparatus comprising: The data acquisition module is used to acquire recurring tasks published by users; The task decomposition module is used to call a pre-trained first large language model through a large model agent, and use the first large language model to construct a sub-task list based on the cyclic task. The sub-task list contains multiple independent sub-tasks that can be executed in parallel. The session generation module is used to call a pre-deployed local loop component through the large model agent, and use the local loop component to generate a sub-session for each sub-task in the sub-task list to trigger the second large language model to execute the corresponding sub-task. The response module is used to send the sub-session to the second large language model through the local loop component, so that the second large language model can execute the corresponding sub-tasks in parallel, and obtain the sub-task response fed back by the second large language model after completing the sub-task; the local loop component traverses the sub-task list based on the sub-task response to determine the completion status of the sub-tasks; when all sub-tasks are completed, the local loop component constructs total response information based on the sub-task responses of all sub-tasks; the large model agent feeds back the total response information to the user.

[0009] As an optional embodiment of the apparatus described in the second aspect, the apparatus further includes: The training module is used to acquire recurring task text samples; decompose the recurring task described by the recurring task text samples into independent subtasks that can be executed in parallel, and construct a list of subtasks as training labels for the recurring task text samples; input the recurring task text samples into a pre-built first large language model, triggering the first large language model to generate a list of subtasks based on the recurring task text samples; construct a loss function based on the list of subtasks generated by the first large language model and the training labels, and train the first large language model using the loss function.

[0010] As an optional implementation of the apparatus described in the second aspect, the task decomposition module is specifically used for: The large model agent inputs the task description text of the recurring task into the first large language model, and triggers the first large language model to decompose the recurring task into multiple independent sub-tasks that can be executed in parallel by constructing prompt words, and outputs the list of sub-tasks.

[0011] As an optional embodiment of the apparatus described in the second aspect, the apparatus further includes: The registration module is used to register the local loop component to the tools list of the first and second large language models before the large model agent calls the local loop component.

[0012] Thirdly, a storage medium is provided, on which a computer program is stored, which, when executed by a processor, implements the above-described cyclic task processing method.

[0013] Fourthly, an electronic device is provided, comprising: One or more processors; and a memory associated with the one or more processors, the memory being used to store program instructions that, when read and executed by the one or more processors, perform the described loop task processing method.

[0014] Beneficial effects: Compared with the prior art, the recurring task processing method proposed in this invention has the following advantages: This method decomposes a recurring task into multiple independent subtasks that can be executed in parallel using a pre-trained primary language model, and constructs a list of subtasks. Then, a local recurring execution component deployed within the agent generates a sub-session for each subtask, which prompts a secondary language model to execute the corresponding subtask. One sub-session corresponds to one subtask, allowing the secondary language model to accurately determine the task to be executed based on the sub-session, thus ensuring the overall task accuracy. The local recurring execution component iterates through the entire list of subtasks based on the secondary language model's sub-responses for each subtask, ensuring that each subtask is fully executed without omission. This method effectively solves the problem that excessively long single-session contexts can prevent the primary language model from determining the task to be executed.

[0015] It should be noted that the cyclic task processing device, electronic device, and storage medium proposed in this invention also possess the aforementioned beneficial effects. Attached Figure Description

[0016] Figure 1 This is a flowchart illustrating a recurring task processing method according to an embodiment. Figure 2 This is a schematic diagram of the structure of a loop task processing device according to an embodiment.

[0017] Figure 3 This is a schematic diagram of the structure of an electronic device according to an embodiment. Detailed Implementation

[0018] The present invention will now be further described in conjunction with the accompanying drawings and specific embodiments. However, it should be understood that the present invention can be implemented in various forms. The exemplary and non-limiting embodiments shown in the drawings and described below are not intended to limit the invention to the specific embodiments illustrated.

[0019] It should be understood that, where technically feasible, the technical features listed above for different embodiments can be combined with each other to form other embodiments within the scope of this invention. Furthermore, the specific examples and embodiments described in this invention are non-limiting, and corresponding modifications can be made to the structures, steps, and order described above without departing from the protection scope of this invention.

[0020] Please refer to Figure 1 , Figure 1 An exemplary flowchart of a recurring task processing method is provided. Figure 1 As shown, the method includes steps S100 to S108.

[0021] S100: In response to receiving a recurring task published by the user, the large model agent calls the pre-trained first large language model and uses the first large language model to construct a list of subtasks based on the recurring task.

[0022] The aforementioned list of subtasks contains multiple independent subtasks that can be executed in parallel. To enable the first language model to generate a list of subtasks based on recurring tasks, it needs to be trained. The training method specifically includes the following steps: S1000: Obtain a text sample of the recurring task.

[0023] The above sample text for a recurring task refers to the description text of a recurring task. The description of a recurring task can take the following form, for example: "To modify all implementation classes of the IExecutor interface InterfaceA in the project, all implementation classes of the IExecutor interface are [AExecutor, BExecutor, ...]".

[0024] S1002: Decompose the recurrent task described by the recurrent task text sample into independent subtasks that can be executed in parallel, and construct a list of subtasks as training labels for the recurrent task text sample.

[0025] This step can be done manually, that is, manually breaking down the recurring task described in the recurring task text sample into independent subtasks that can be executed in parallel, and listing the subtasks.

[0026] S1004: Input the recurring task text sample into the pre-built first language model, triggering the first language model to generate a sub-task list based on the recurring task text sample.

[0027] Specifically, context cues can be constructed to encourage large language models to build a list of subtasks based on recurring tasks. Context cues can adopt the following paradigms: "If there are many tasks to be executed, return a list of tasks to be executed and call the local loop component to execute them. For example, if a user wants to modify all implementation classes of the IExecutor interface InterfaceA in the project, first obtain all implementation classes of the IExecutor interface [AExecutor, BExecutor, ...], and then generate a task list {"tasks":[{"name": "Modify the interface InterfaceA of AExecutor","description":"Modify this interface","parameters":""},{"name": "Modify the interface InterfaceA of BExecutor","description":"Modify this interface","parameters":""},...] .

[0028] The first major language model mentioned above can be implemented using an existing LLM model. This embodiment does not impose any restrictions on the structure of the first major language model.

[0029] S1006: Construct a loss function based on the sub-task list and training labels generated by the first large language model, and use the loss function to train the large language model.

[0030] Specifically, cross-entropy can be used to describe the difference between the sub-task list generated by the first-largest language model and the training labels, serving as the loss function. This loss function is then used to update the parameters of the first-largest language model, resulting in a first-largest language model that meets the requirements.

[0031] The first trained language model has the ability to build a list of subtasks based on cyclic tasks. The large model agent can construct context prompts to prompt the large language model to build a list of subtasks based on cyclic tasks.

[0032] Contextual prompts can adopt the following paradigms: "If there are many tasks to be executed, return a list of tasks to be executed and call the local loop component to execute them. For example, if a user wants to modify all implementation classes of the IExecutor interface InterfaceA in the project, first obtain all implementation classes of the IExecutor interface [AExecutor, BExecutor, ...], and then generate a task list {"tasks":[{"name": "Modify the interface InterfaceA of AExecutor","description":"Modify this interface","parameters":""},{"name": "Modify the interface InterfaceA of BExecutor","description":"Modify this interface","parameters":""},...] .

[0033] S102: The large model agent calls a pre-deployed local loop component and uses the local loop component to generate a sub-session for each sub-task in the sub-task list to trigger the second large language model to execute the corresponding sub-task.

[0034] It should be noted that the second major language model mentioned above can be any major model that can complete sub-tasks based on sub-conversations. The second major language model and the first major language model can be the same major model or different major models. This embodiment does not impose any restrictions on this.

[0035] Before the large model agent calls the local loop component, the local loop component needs to be registered in the tools list of the first and second large language models.

[0036] After registration, the local loop component generates a sub-session for each subtask in the subtask list. This sub-session serves as a prompt word for the second language model, prompting it to execute the corresponding subtask and provide a response. Because these sub-sessions are independent new sessions, the second language model can accurately capture the subtask to be executed, effectively avoiding the problem of the second language model being unable to determine the task to be executed due to excessively long context.

[0037] S104: The local loop component sends the sub-session to the second language model so that the second language model can execute the corresponding sub-tasks in parallel and obtain the sub-task response fed back by the second language model after completing the sub-task.

[0038] In one implementation, since the large language model itself has the ability to handle high-concurrency business, multiple sub-sessions of sub-tasks can be sent to the same second large language model so that the second large language model can execute the corresponding sub-tasks in parallel.

[0039] In another implementation, multiple second-largest language models can be set up, and the sub-sessions of batch subtasks can be delivered to different second-largest language models for parallel processing, thereby reducing the load pressure on a single second-largest language model.

[0040] S106: The local loop component iterates through the subtask list based on the subtask responses to determine the completion status of the subtasks. When all subtasks are completed, the local loop component constructs the total response information based on the subtask responses of all subtasks.

[0041] Specifically, the local loop component generates a timestamp for each subtask. This timestamp records the time when the local loop component sends the sub-session of the subtask to the second language model. If the local loop component does not receive a sub-response from the second language model for the subtask within a preset time threshold, it regenerates the sub-session of the subtask, sends it to the second language model, and restarts the timing until it receives a sub-response from the second language model for the subtask. If the local loop component receives a sub-response from the second language model for the subtask within the preset time threshold, it determines that the subtask has been completed and saves the sub-response.

[0042] Once all subtasks are completed, the local loop component will construct the total response information from the sub-responses of all subtasks stored locally and feed it back to the large model agent.

[0043] S108: The large model agent feeds back the total response information to the user.

[0044] Corresponding to the above-described method for handling recurring tasks, this embodiment also provides a device for handling recurring tasks. Please refer to... Figure 2 , Figure 2 A schematic diagram of a loop task processing device is shown, which is used to implement the aforementioned loop task processing method. Figure 2 As shown, the device includes: The data acquisition module is used to acquire recurring tasks published by users.

[0045] The task decomposition module is used to call the pre-trained first language model through the large model agent, and use the first language model to build a list of sub-tasks based on the cyclic task. The list of sub-tasks contains multiple independent sub-tasks that can be executed in parallel.

[0046] The session generation module is used to call a pre-deployed local loop component through the large model agent, and use the local loop component to generate a sub-session for each sub-task in the sub-task list to trigger the second large language model to execute the corresponding sub-task.

[0047] The response module sends sub-sessions to the second large language model via a local loop component, enabling the second large language model to execute the corresponding sub-tasks in parallel and obtain the sub-task responses returned by the second large language model after completing the sub-tasks. The local loop component iterates through the sub-task list based on the sub-task responses to determine the completion status of the sub-tasks. When all sub-tasks are completed, the local loop component constructs the total response information based on the sub-task responses of all sub-tasks. The large model agent then feeds back the total response information to the user.

[0048] Optionally, the above device further includes a training module, which is specifically used for: Obtain a text sample of the recurring task; The recurring task described in the recurring task text sample is decomposed into independent subtasks that can be executed in parallel, and a list of subtasks is constructed as training labels for the recurring task text sample. Input the text sample of the recurring task into the pre-built first language model, triggering the first language model to generate a list of subtasks based on the text sample of the recurring task. A loss function is constructed based on the sub-task list and training labels generated by the first language model, and the first language model is trained using the loss function.

[0049] Optionally, the task breakdown module is specifically used for: The large model agent inputs the task description text of the recurring task into the first large language model. By constructing prompt words, the first large language model is triggered to decompose the recurring task into multiple independent subtasks that can be executed in parallel, and outputs a list of subtasks.

[0050] Optionally, the above-mentioned device further includes: The registration module is used to register the local loop component in the tools list of the first and second largest language models before the large model agent calls the local loop component.

[0051] Below, with Figure 2The implementation principle of this device is illustrated using the example of a recurring task processing. Taking a module as a software functional unit as an example, the data acquisition module may include code running on a computing instance. This computing instance may include at least one of a physical host (computing device), a virtual machine, or a container. Furthermore, the aforementioned computing instance may be one or more. For example, the data acquisition module may include code running on multiple hosts / virtual machines / containers. The multiple hosts / virtual machines / containers used to run this code may be distributed in the same region or in different regions. Further, the multiple hosts / virtual machines / containers used to run this code may be distributed in the same availability zone (AZ) or in different AZs, each AZ including one or more geographically proximate data centers. Typically, a region may include multiple AZs.

[0052] Similarly, multiple hosts / virtual machines / containers used to run this code can be distributed within the same Virtual Private Cloud (VPC) or across multiple VPCs. Typically, a VPC is set up within a region. Communication between two VPCs within the same region, as well as between VPCs in different regions, requires a communication gateway to be set up within each VPC to enable interconnection between VPCs.

[0053] As an example of a hardware functional unit, a data acquisition module may include at least one computing device, such as a server. Alternatively, a data acquisition module may also be a device implemented using an application-specific integrated circuit (ASIC) or a programmable logic device (PLD). The aforementioned PLD may be implemented using a complex programmable logical device (CPLD), a field-programmable gate array (FPGA), generic array logic (GAL), or any combination thereof.

[0054] The data acquisition module includes multiple computing devices that can be distributed within the same region or in different regions. Similarly, these computing devices can be distributed within the same Availability Zone (AZ) or in different AZs. Likewise, they can be distributed within the same Virtual Private Cloud (VPC) or multiple VPCs. These computing devices can be any combination of computing devices such as servers, ASICs, PLDs, CPLDs, FPGAs, and GALs.

[0055] In other embodiments, the data acquisition module can be used to execute any step in the above-described cyclic task processing method, the task decomposition module can be used to execute any step in the above-described cyclic task processing method, the session generation module can be used to execute any step in the above-described cyclic task processing method, and the response module can be used to execute any step in the above-described cyclic task processing method. The steps implemented by the data acquisition module, task decomposition module, session generation module, and response module can be specified as needed. By implementing different steps in the above-described cyclic task processing method through the data acquisition module, task decomposition module, session generation module, and response module, all the functions of the above-described cyclic task processing device can be realized.

[0056] In this implementation, the device can also be applied to computing devices such as computers and servers, or to a cluster of computing devices including at least one computing device, to implement specific cyclic task processing.

[0057] One or more embodiments described in this specification also provide an electronic device. Please refer to... Figure 3 The electronic device includes a bus 301, a processor 302, a memory 303, and a communication interface 304. The processor 302, memory 303, and communication interface 304 communicate via the bus 301. This electronic device can be a server or a terminal device. It should be understood that this application does not limit the number of processors and memories in the electronic device.

[0058] Bus 301 can be a Peripheral Component Interconnect (PCI) bus or an Extended Industry Standard Architecture (EISA) bus, etc. Buses can be categorized as address buses, data buses, control buses, etc. For ease of representation, Figure 3 The bus 301 may be represented by a single line, but this does not mean that there is only one bus or one type of bus. The bus 301 may include a path for transmitting information between various components of an electronic device (e.g., processor 302, memory 303, and communication interface 304).

[0059] Processor 302 may include any one or more processors such as a central processing unit (CPU), graphics processing unit (GPU), microprocessor (MP), or digital signal processor (DSP).

[0060] Memory 303 may include volatile memory, such as random access memory (RAM). Memory 303 may also include non-volatile memory, such as read-only memory (ROM), flash memory, hard disk drive (HDD), or solid state drive (SSD).

[0061] The memory 303 stores executable program code, and the processor 302 executes the executable program code to implement the aforementioned loop task processing method.

[0062] Communication interface 304 uses transceiver modules, such as, but not limited to, network interface cards and transceivers, to enable communication between electronic devices and other devices or communication networks.

[0063] One or more embodiments of this specification provide a storage medium that stores a computer program that, when run on an electronic device, causes the electronic device to perform the described cyclic task processing method.

[0064] The storage medium can be any available medium that an electronic device can store, or a data storage device such as a data center that contains one or more available media. The available media can be magnetic media (e.g., floppy disks, hard disks, magnetic tapes), optical media (e.g., DVDs), or semiconductor media (e.g., solid-state drives). The storage medium includes instructions that direct the electronic device to perform the described cyclic task processing method.

[0065] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0066] The embodiments described above are merely illustrative of several implementations of the present invention, and while the descriptions are relatively specific and detailed, they should not be construed as limiting the scope of the invention patent. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of the present invention, and these all fall within the protection scope of the present invention. Therefore, the protection scope of this invention patent should be determined by the appended claims.

Claims

1. A method for processing recurring tasks, characterized in that, The method includes: In response to receiving a recurring task published by the user, the large model agent calls a pre-trained first large language model and uses the first large language model to construct a sub-task list based on the recurring task. The sub-task list contains multiple independent sub-tasks that can be executed in parallel. The large model agent invokes a pre-deployed local loop component, and uses the local loop component to generate a sub-session for each sub-task in the sub-task list to trigger the second large language model to execute the corresponding sub-task. The local loop component sends the sub-session to the second large language model so that the second large language model can execute the corresponding sub-tasks in parallel and obtain the sub-task response fed back by the second large language model after completing the sub-task; The local loop component iterates through the subtask list based on the subtask response to determine the completion status of the subtask. When all subtasks are completed, the local loop component constructs total response information based on the subtask responses of all subtasks. The large model agent feeds back the total response information to the user.

2. The method according to claim 1, characterized in that, in, The training methods for the first large language model specifically include: Obtain a text sample of the recurring task; The recurring task described by the recurring task text sample is decomposed into independent subtasks that can be executed in parallel, and a list of subtasks is constructed as training labels for the recurring task text sample. The recurring task text sample is input into the pre-built first large language model, triggering the first large language model to generate a sub-task list based on the recurring task text sample; A loss function is constructed based on the sub-task list generated by the first large language model and the training labels, and the first large language model is trained using the loss function.

3. The method according to claim 1, characterized in that, The large model agent invokes a pre-trained first large language model and uses this first large language model to construct a list of sub-tasks based on the cyclical task, specifically including: The large model agent inputs the task description text of the recurring task into the first large language model, and triggers the first large language model to decompose the recurring task into multiple independent sub-tasks that can be executed in parallel by constructing prompt words, and outputs the list of sub-tasks.

4. The method according to claim 1, characterized in that, The method further includes: Before the large model agent calls the local loop component, the local loop component is registered in the tools list of the first and second large language models.

5. A cyclic task processing device, characterized in that, The device includes: The data acquisition module is used to acquire recurring tasks published by users; The task decomposition module is used to call a pre-trained first large language model through a large model agent, and use the first large language model to construct a sub-task list based on the cyclic task. The sub-task list contains multiple independent sub-tasks that can be executed in parallel. The session generation module is used to call a pre-deployed local loop component through the large model agent, and use the local loop component to generate a sub-session for each sub-task in the sub-task list to trigger the second large language model to execute the corresponding sub-task. The response module is used to send the sub-session to the second large language model through the local loop component, so that the second large language model can execute the corresponding sub-tasks in parallel, and obtain the sub-task response fed back by the second large language model after completing the sub-task; the local loop component traverses the sub-task list based on the sub-task response to determine the completion status of the sub-tasks; when all sub-tasks are completed, the local loop component constructs total response information based on the sub-task responses of all sub-tasks; the large model agent feeds back the total response information to the user.

6. The apparatus according to claim 5, characterized in that, The device further includes: The training module is used to acquire recurring task text samples; decompose the recurring task described by the recurring task text samples into independent subtasks that can be executed in parallel, and construct a list of subtasks as training labels for the recurring task text samples; input the recurring task text samples into a pre-built first large language model, triggering the first large language model to generate a list of subtasks based on the recurring task text samples; construct a loss function based on the list of subtasks generated by the first large language model and the training labels, and train the first large language model using the loss function.

7. The apparatus according to claim 5, characterized in that, The task decomposition module is specifically used for: The large model agent inputs the task description text of the recurring task into the first large language model, and triggers the first large language model to decompose the recurring task into multiple independent sub-tasks that can be executed in parallel by constructing prompt words, and outputs the list of sub-tasks.

8. The apparatus according to claim 5, characterized in that, The device further includes: The registration module is used to register the local loop component to the tools list of the first and second large language models before the large model agent calls the local loop component.

9. A storage medium, characterized in that, The storage medium stores a computer program that, when executed by a processor, implements the method as described in any one of claims 1 to 5.

10. An electronic device, characterized in that, include: One or more processors; And a memory associated with the one or more processors, the memory being used to store program instructions that, when read and executed by the one or more processors, perform the method as described in any one of claims 1 to 5.

Images