A task processing method and device based on large language model intelligent agent

Abstract

The present application relates to the technical field of large language model intelligent agents, and in particular to a task processing method and device based on large language model intelligent agents, wherein the task processing method based on large language model intelligent agents includes: decomposing the task to be processed based on the large language model to obtain a two-dimensional grid map; constructing a large language model intelligent agent based on the grid structure of the two-dimensional grid map; inputting the environmental data information of each dynamic intelligent agent in the two-dimensional grid map into the large language model to obtain the task instructions corresponding to each dynamic intelligent agent; according to the task instructions corresponding to each dynamic intelligent agent, controlling the dynamic intelligent agent to move under the direction of the node state intelligent agent, so that all dynamic intelligent agents complete the processing of the target subtasks in each node grid in the two-dimensional grid map. The present application can improve the understanding ability and self-regulation ability of the large language model intelligent agent for different types of tasks, and lay the foundation for the further development of the large language model.

Description

Technical Field

[0001] The embodiments of the present application relate to the technical field of large language model intelligent agents, and in particular, to a task processing method and device based on a large language model intelligent agent. Background Art

[0002] Currently, large language model agents show great potential in directly communicating with programs and handling complex tasks, especially in areas such as analytical tasks, decision support, and knowledge extraction.

[0003] However, the current large language model agent still has a low level of automation in the task processing process, and mainly relies on user input and interaction, which leads to the need for human intervention in the execution of many links, and makes it impossible for the large language model agent to complete the task process independently; and the dependence of the large language model agent limits the potential of the large language model, making it difficult for the large language model to achieve its true autonomy and efficiency, and thus unable to give full play to the understanding and generation capabilities of the large language model in the task processing process. Summary of the invention

[0004] The present application provides a task processing method and device based on a large language model intelligent agent, which can improve the task coverage and task processing efficiency of the large language model intelligent agent in a complex environment, and improve the understanding and self-regulation capabilities of the large language model intelligent agent for different types of tasks, so as to give full play to the understanding and generation capabilities of the large language model in the task processing process.

[0005] In a first aspect, a task processing method based on a large language model agent is provided, comprising: Decomposing the task to be processed based on the large language model to obtain a two-dimensional grid graph; the two-dimensional grid graph includes multiple target subtasks and node grids corresponding to the multiple target subtasks; Based on the grid structure of the two-dimensional grid graph, a large language model agent is constructed; the large language model agent includes multiple node-state agents and multiple dynamic agents; the node-state agent is an agent used to guide the moving direction of the dynamic agent; Input the environmental data information of each dynamic agent in the two-dimensional grid map into the large language model to obtain the task instructions corresponding to each dynamic agent; the task instructions include instructions to command the dynamic agent to move to the node grid corresponding to the target subtask; According to the task instructions corresponding to each dynamic agent, the dynamic agent is controlled to move under the direction of the node state agent, so that all dynamic agents can complete the processing of the target subtasks in each node grid in the two-dimensional grid diagram.

[0006] In a second aspect, a task processing device based on a large language model agent is provided, comprising: A two-dimensional grid graph generation module is used to decompose the task to be processed based on the large language model to obtain a two-dimensional grid graph; the two-dimensional grid graph includes multiple target subtasks and node grids corresponding to the multiple target subtasks; An agent building module is used to build a large language model agent based on a grid structure of a two-dimensional grid graph; the large language model agent includes multiple node-state agents and multiple dynamic agents; the node-state agent is an agent used to guide the moving direction of the dynamic agent; A task instruction generation module is used to input the environmental data information of each dynamic agent in the two-dimensional grid map into the large language model to obtain the task instructions corresponding to each dynamic agent; the task instructions include instructions to command the dynamic agent to move to the node grid corresponding to the target subtask; The target subtask processing module is used to control the dynamic agents to move under the direction of the node state agents according to the task instructions corresponding to each dynamic agent, so that all dynamic agents can complete the processing of the target subtasks in each node grid in the two-dimensional grid diagram.

[0007] According to a third aspect, an electronic device is provided, comprising: a processor and a memory, wherein the memory is used to store a computer program, and the processor is used to call and run the computer program stored in the memory to execute the method in the first aspect or its various implementations.

[0008] According to a fourth aspect, a computer-readable storage medium is provided for storing a computer program, wherein the computer program enables a computer to execute the method according to the first aspect or its various implementations.

[0009] Through the technical solution provided in the present application, the two-dimensional grid map obtained by decomposing the task to be processed by the large language model can provide multiple node-state intelligent agents and multiple dynamic intelligent agents constructed based on the grid structure of the two-dimensional grid map with an intuitive understanding of the logic of the task to be processed; then based on the large language model, the corresponding task instructions of each dynamic intelligent agent are determined by analyzing the environmental data information of each dynamic intelligent agent in the two-dimensional grid map, so that the dynamic intelligent agent moves under the guidance of the node-state intelligent agent according to the task instructions, so as to complete the processing of the target subtasks in each node grid in the two-dimensional grid map, improve the task coverage and task processing efficiency of the large language intelligent agent in a complex environment, so as to improve the understanding ability and self-regulation ability of the large language model intelligent agent for different types of tasks, and give full play to the understanding and generation ability of the large language model, laying the foundation for the further development of the large language model.

[0010] Other features and advantages of the present disclosure will be described in detail in the following detailed description. BRIEF DESCRIPTION OF THE DRAWINGS

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

[0012] Figure 1 An application scenario diagram provided for an embodiment of the present application; Figure 2 A flowchart of a task processing method based on a large language model agent provided in an embodiment of the present application; Figure 3 A flowchart of another task processing method based on a large language model agent provided in an embodiment of the present application; Figure 4 A schematic diagram of a task processing device based on a large language model agent provided in an embodiment of the present application; Figure 5 It is a schematic block diagram of an electronic device provided in an embodiment of the present application. DETAILED DESCRIPTION

[0013] The following will be combined with the drawings in the embodiments of the present application to clearly and completely describe the technical solutions in the embodiments of the present application. Obviously, the described embodiments are only part of the embodiments of the present application, not all of the embodiments. Based on the embodiments in the present application, all other embodiments obtained by ordinary technicians in this field without making creative work are within the scope of protection of this application.

[0014] It should be noted that the terms "first", "second", etc. in the specification and claims of the present application and the above-mentioned drawings are used to distinguish similar objects, and are not necessarily used to describe a specific order or sequence. It should be understood that the data used in this way can be interchangeable where appropriate, so that the embodiments of the present application described herein can be implemented in an order other than those illustrated or described herein. In addition, the terms "including" and "having" and any of their variations are intended to cover non-exclusive inclusions, for example, a process, method, system, product or server that includes a series of steps or units is not necessarily limited to those steps or units clearly listed, but may include other steps or units that are not clearly listed or inherent to these processes, methods, products or devices.

[0015] As mentioned above, large language model agents often require multiple rounds of human-computer interaction during task completion, rather than completing the task process independently. This not only increases the operational burden of task processing, but also affects the efficiency and consistency of task processing. Therefore, improving the automation and self-regulation capabilities of large language model agents to give full play to the understanding and generation capabilities of large language models has become an important direction for the further development of large language model agents.

[0016] In order to solve the above technical problems, the inventive concept of the present application is: based on a large language model, the task to be processed is decomposed to obtain a two-dimensional grid map; the two-dimensional grid map includes multiple target sub-tasks and node grids corresponding to the multiple target sub-tasks; based on the grid structure of the two-dimensional grid map, a large language model agent is constructed; the large language model agent includes multiple node-state agents and multiple dynamic agents; the node-state agent is an agent used to guide the movement direction of the dynamic agent; the environmental data information of each dynamic agent in the two-dimensional grid map is input into the large language model to obtain the task instructions corresponding to each dynamic agent; the task instructions include instructions to command the dynamic agent to move to the node grid corresponding to the target sub-task; according to the task instructions corresponding to each dynamic agent, the dynamic agent is controlled to move under the direction of the node-state agent, so that all dynamic agents complete the processing of the target sub-tasks in each node grid in the two-dimensional grid map. This application can not only improve the task coverage and task processing efficiency of large language agents in complex environments, but also improve the understanding and self-regulation capabilities of large language model agents for different types of tasks, thereby giving full play to the understanding and generation capabilities of large language models and laying the foundation for the further development of large language models.

[0017] It should be understood that the technical solution of the present application can be applied to the following scenarios, but is not limited to: In some possible implementations, Figure 1 An application scenario diagram provided for an embodiment of the present application, such as Figure 1 As shown, the application scenario may include an electronic device 110 and a network device 120. The electronic device 110 may establish a connection with the network device 120 via a wired network or a wireless network.

[0018] Exemplarily, the electronic device 110 may be a desktop computer, a laptop computer, a tablet computer, etc., but is not limited thereto. The network device 120 may be a terminal device or a server, but is not limited thereto. In one embodiment of the present application, the electronic device 110 may send a request message to the network device 120, and the request message may be used to request to decompose the task to be processed based on the large language model to obtain a two-dimensional grid map. Further, the electronic device 110 may receive a response message sent by the network device 120, and the response message includes calling the large language model to decompose the task to be processed to obtain a two-dimensional grid map.

[0019] also, Figure 1 An electronic device 110 and a network device 120 are provided as an example, but other numbers of electronic devices and network devices may actually be included, and the present application does not impose any limitation on this.

[0020] In other possible implementations, the technical solution of the present application may also be executed by the above-mentioned electronic device 110, or the technical solution of the present application may also be executed by the above-mentioned network device 120, and the present application does not impose any limitation on this.

[0021] After introducing the application scenarios of the embodiments of the present application, the technical solution of the present application will be described in detail below: Figure 2 A flowchart of a task processing method based on a large language model agent provided in an embodiment of the present application, the method can be as follows Figure 1 The electronic device 110 shown in the figure performs, but is not limited to this. Figure 2 As shown, the method may include the following steps: S210 , decomposing the task to be processed based on the large language model to obtain a two-dimensional grid graph.

[0022] The two-dimensional grid graph includes a plurality of target subtasks and node grids corresponding to the plurality of target subtasks.

[0023] It should be noted that the large language model is a deep learning model trained using a large amount of text data, which can generate natural language text or understand language text; the position of the node grid corresponding to each target subtask in the two-dimensional grid diagram is determined according to the dependency relationship between the execution order of each target subtask.

[0024] Here, by decomposing the task to be processed into multiple target subtasks, and generating a two-dimensional grid diagram of the multiple target subtasks and the node grids corresponding to the multiple target subtasks, the dependency relationship transformation between the multiple target subtasks is realized, so that the node-state agent and the dynamic agent in the subsequent steps can intuitively understand the logic of the task to be processed, thereby reducing the divergence of the dynamic agent's moving path, so as to improve the execution efficiency and accuracy of the entire large language model agent.

[0025] For example, taking the task to be processed as "medical task" as an example, the task to be processed is decomposed based on the large language model to obtain a two-dimensional grid graph, and the target subtask corresponding to each node grid in the two-dimensional grid graph is an execution operation in the medical task, where the execution operation can be "patient information collection", "preliminary diagnosis", "drug preparation", "ward arrangement", etc.

[0026] As another example, taking the pending task as "project progress management task", the pending task is decomposed based on the large language model to obtain a two-dimensional grid diagram, and the target subtask corresponding to each node grid in the two-dimensional grid diagram is an execution operation in the project progress management task, where the execution operation can be "requirement collation", "task allocation", "progress tracking", "results delivery", etc.

[0027] In this step, the two-dimensional grid diagram obtained by decomposing the task to be processed by the large language model can provide clear navigation and decision-making basis for the node-state agent and the dynamic agent, making the logical connection of each target subtask clear in space, improving the efficiency and accuracy of task execution of the large language model agent, and laying the foundation for collaborative task processing of multiple types of large language model agents.

[0028] S220. Construct a large language model agent based on a grid structure of a two-dimensional grid graph.

[0029] Here, the large language model agent includes multiple node-state agents and multiple dynamic agents.

[0030] Among them, the node-state agent is an agent used to guide the moving direction of the dynamic agent.

[0031] It should be noted that the large language model agent is an intelligent computing entity that can perceive the environment, make decisions and execute actions on a two-dimensional grid map; the node state agent is a static agent that can be locked in place, and the node state agent can provide a direction of advance to the dynamic agent within its communication distance to guide the dynamic agent to advance in the two-dimensional grid map and explore further. The dynamic agent can interact with the target subtask located in the two-dimensional grid map according to the specific needs of the target subtask. At the same time, the dynamic agent can also adapt to changes in environmental data information in the two-dimensional grid map.

[0032] Through the grid structure of the two-dimensional grid graph, multiple node-state agents and multiple dynamic agents are constructed, and the overall large language model agent can be adaptively distributed on the two-dimensional grid graph according to the tasks to be processed, and the dynamic agent can move under the guidance of the node-state agent, thereby ensuring the exploration range and flexibility of the entire large language agent and improving the task execution efficiency of the entire large language agent in complex environments.

[0033] S230, inputting the environmental data information of each dynamic agent in the two-dimensional grid map into the large language model to obtain the task instructions corresponding to each dynamic agent.

[0034] It should be noted that, since the two-dimensional grid map obtained in step S210 is a task space generated for the task to be processed based on the large language model, the environmental data information here can be a set of task status information of each target subtask in the two-dimensional grid map; the task status information may include at least one of the progress status, resource status, dependency status, problem feedback status, priority status and dynamic change status, wherein the progress status can be used to describe the current stage or completion ratio of the target subtask, such as "not started", "in progress", "completed"; the resource status can be used to describe the resource configuration and availability required for the target subtask, such as "sufficient resources" and "insufficient resources"; the dependency status can be used to describe the association status of a target subtask with other target subtasks, such as "dependency not met" and "dependency satisfied"; the problem feedback status can be used to describe the obstacles or anomalies encountered by the target subtask during execution, such as "normal", "blocked" and "error"; the priority status can be used to describe the importance or urgency of the target subtask, such as "high priority" and "low priority"; the dynamic change status can be used for real-time update of the target subtask status or the influence of external conditions, such as "stable status" and "condition change".

[0035] For example, following the example of "medical task" in step S210, when the target subtask A is "drug preparation" and when the target subtask B is "ward arrangement", the environmental data information may include task status information A corresponding to the target subtask A, and task status information B corresponding to the target subtask B, wherein the task status information A is "drug inventory status" and the task status information B is "ward vacancy status". For another example, following the example of "project progress management task" in step S210, when the target subtask C is "task allocation" and when the target subtask D is "progress tracking", the environmental data information may include task status information C corresponding to the target subtask C and task status information D corresponding to the target subtask D, wherein the task status information C is "team member status" and the task status information D is "resource usage status".

[0036] Among them, the task instructions include instructions for commanding the dynamic agent to move to the node grid corresponding to the target subtask.

[0037] Here, by calling the large language model to determine the task instructions corresponding to each dynamic agent based on the environmental data information of each dynamic agent, the dynamic agent can move according to the actual environmental conditions of the two-dimensional grid map, so that the dynamic agent can process the target data in the two-dimensional grid corresponding to different tasks to be processed, thereby ensuring the flexibility of the entire large language model agent and improving the execution efficiency of the large language model agent.

[0038] For example, taking the target subtask as "drug preparation" and the task status information corresponding to the target subtask as "drug inventory status", the large language model can generate a task instruction for the dynamic agent used for intelligent drug delivery based on the target subtask and the task status information, which can be "deliver drug X to ward Y."

[0039] As another example, taking the target subtask as "task assignment" and the task status information corresponding to the target subtask as "team member status", the large language model can generate a task instruction for the dynamic agent used for task coordination based on the target subtask and the task status information, which can be "remind team members to update task status."

[0040] S240. According to the task instructions corresponding to each dynamic agent, the dynamic agent is controlled to move under the direction of the node state agent, so that all dynamic agents complete the processing of the target subtasks in each node grid in the two-dimensional grid diagram.

[0041] Here, multiple dynamic agents can move simultaneously in the two-dimensional grid map under the guidance of the node-state agent, so as to realize the collaborative work of multiple dynamic agents and improve the processing efficiency of the tasks to be processed; for example: the task instruction corresponding to dynamic agent A is "arrange patient A to ward Y", and the task instruction corresponding to dynamic agent B is "deliver drug X to ward Y", so as to ensure the smooth diagnosis and treatment process of patients, and at the same time, improve the utilization efficiency of hospital resources and improve the diagnosis and treatment efficiency of patients in the hospital; for example: the task instruction corresponding to dynamic agent C is "remind team members to update task status", and the task instruction corresponding to dynamic agent D is "generate a to-do list based on meeting minutes". The above dynamic agents A, dynamic agent B, dynamic agent C and dynamic agent D can move simultaneously in the two-dimensional grid map under the guidance of the node-state agent to realize the simultaneous processing of different target subtasks.

[0042] It should be noted that the node-state agent here is locked in place in the two-dimensional grid map, and multiple node-state agents form a communication network constructed for the two-dimensional grid map. Since the node-state agent can guide the movement direction of the dynamic agent, according to the task instructions corresponding to each dynamic agent, in the communication network formed by multiple node-state agents, each dynamic agent can explore more effectively in the two-dimensional grid map under the guidance of the node-state agent, so as to improve the discovery rate of the two-dimensional network map of the entire large language model.

[0043] Exemplarily, the dynamic agent is controlled to move under the direction of the node state agent in the following manner: Program output → large language model { "type": "direction_request", "agent_id": "Agent-X", "current_state": "node", "current_location": [x, y], "goal": "Guide nearby agents" } Large language model output → program { "type": "direction_response", "agent_id": "Agent-X", "suggested_direction": {"angle": 45, "distance": 5} } By adopting the above method, the two-dimensional grid map obtained by decomposing the task to be processed by the large language model can provide the node-state intelligent agent and the dynamic intelligent agent constructed based on the grid structure of the two-dimensional grid map with an intuitive understanding of the logic of the task to be processed; then, the task instructions corresponding to each dynamic intelligent agent are determined by analyzing the environmental data information of each dynamic intelligent agent in the two-dimensional grid map based on the large language model, so that the dynamic intelligent agent moves under the guidance of the node-state intelligent agent according to the task instructions to complete the processing of the target subtasks in each node grid in the two-dimensional grid map, thereby improving the task coverage and task processing efficiency of the large language agent in a complex environment, and laying the foundation for the collaborative task processing of multiple types of large language model agents.

[0044] In some possible embodiments, the dynamic agent includes a free-state agent and an exploratory-state agent.

[0045] Here, the free-state agent is a dynamic agent that lacks autonomy. It is easily guided by the direction of the node-state agent and advances step by step to the node grid at the end of the two-dimensional grid map under the direction of multiple node-state agents, so as to find the target subtask in the explored area on the two-dimensional grid map; the exploration-state agent is a dynamic agent that explores in the unexplored area on the two-dimensional grid.

[0046] Accordingly, based on the grid structure of the two-dimensional grid graph, a large language model agent is constructed, see Figure 3 , which may include the following steps: S310. Based on the grid structure of the two-dimensional grid graph, construct multiple node-state intelligent agents for the two-dimensional grid graph.

[0047] Since the node-state intelligent agent can provide guidance on the moving direction for other intelligent agents, such as free-state intelligent agents and exploratory-state intelligent agents, in the two-dimensional grid map, multiple node-state intelligent agents are locked at their corresponding current positions based on the grid structure of the two-dimensional grid map, so that multiple node-state intelligent agents can form a communication network constructed for the two-dimensional grid map, so that other intelligent agents can move and explore in the communication network formed by multiple node-state intelligent agents, and then other intelligent agents can complete the processing of target subtasks in each node grid in the two-dimensional grid map according to task instructions.

[0048] S320. Based on the current position information corresponding to multiple node-state agents, call the large language model to determine whether each node-state agent is in an extreme state.

[0049] Here, the extreme states include a lost connection state or an out-of-group state.

[0050] It should be noted that when calling the large language model to determine whether each node-state intelligent agent is in an extreme state, it can be determined based on the current position information corresponding to each node-state intelligent agent whether each node-state intelligent agent in the middle position is connected to other node-state intelligent agents. If a node-state intelligent agent is not connected to other node-state intelligent agents, it is determined that the node-state intelligent agent is in a lost connection state; or based on the current position information corresponding to each node-state intelligent agent, it can be determined whether each node-state intelligent agent at the edge position is far away from other node-state intelligent agents. If a node-state intelligent agent is far away from other node-state intelligent agents, it is determined that the node-state intelligent agent is in an outlier state.

[0051] Exemplarily, the large language model can be called in the following way to determine whether each node state agent is in an extreme state: Program output → large language model { "type": "connection_check", "agent_id": "Agent-X", "current_location": [x, y] } Large language model output → program { "type": "connection_status", "agent_id": "Agent-X", "connected": false } S330. If a node-state agent is in an extreme state, the large language model is called to convert the node-state agent into a free-state agent.

[0052] When a node-state agent is in an extreme state, the node-state agent is in an unconstrained state. Therefore, the node-state agent is converted into a free-state agent here, which can move under the guidance of multiple node-state agents, thereby improving the dynamics and flexibility of the entire large language agent system.

[0053] Exemplarily, when the node-state agent is in an extreme state, the node-state agent is converted into a free-state agent by calling the large language model in the following manner: Program output → large language model { "type": "state_change_request", "agent_id": "Agent-X", "new_state": "free", "reason": "Lost connection to group" } Large language model output → program { "type": "state_change_confirmation", "agent_id": "Agent-X", "new_state": "free", "status": "success" } S340. Based on the current position information and detection range corresponding to the multiple free-state intelligent agents and the environment overview information corresponding to the two-dimensional grid map, the large language model is called to determine whether each free-state intelligent agent has contacted the node grid located at the boundary of the unexplored area.

[0054] Here, the environment overview information is obtained by inputting the environment data information of the node-state intelligent agent and / or the environment data information of the free-state intelligent agent into the large language model. The environment overview information is used to display the area status corresponding to each area in the two-dimensional grid map, and the positions corresponding to the node-state intelligent agent and the free-state intelligent agent in the two-dimensional grid map; the environment overview information includes the explored area information, the unexplored area information, and the current position information corresponding to the node-state intelligent agent and the free-state intelligent agent in the two-dimensional grid map; wherein the environment data information includes the current position information of the node-state intelligent agent or the free-state intelligent agent, and the scanning information; the scanning information The information is the task status information corresponding to the target subtask collected by the node-state agent or the free-state agent at the current position; for example: in the scenario where the task to be processed is "medical task", if the target subtask scanned by the free-state agent at the current position is "drug preparation", then the scanning information collected by the free-state agent for the target subtask is "drug inventory status"; for another example: in the scenario where the task to be processed is "project progress management task", if the target subtask scanned by the free-state agent at the current position is "task allocation", then the scanning information collected by the free-state agent for the target subtask is "team member status".

[0055] In order to enable the large language agent in this application to process unknown tasks to be processed, the free-state agent on the node grid located at the boundary of the exploration area is judged, so that the free-state intelligence on the node grid located at the boundary of the exploration area can be converted into an exploration-state agent that is more suitable for exploring unknown areas through subsequent steps, so as to improve the processing efficiency of the tasks to be processed.

[0056] Exemplarily, the large language model can be called in the following manner to determine whether each free-state agent has contacted a node grid located at the boundary of the unexplored area: Program output → large language model { "type": "boundary_check", "agent_id": "Agent-X", "current_location": [x, y], "detection_range": "D" } Large language model output → program { "type": "boundary_report", "agent_id": "Agent-X", "unknown_area_detected": true} S350. If a free-state agent contacts a node grid located at the boundary of an unexplored area, the large language model is called to convert the free-state agent into an exploratory agent.

[0057] By calling the large language model to convert a free-state agent into an exploratory agent when the free-state agent contacts a node grid located at the boundary of an unexplored area, the free-state agent located at the boundary of the unexplored area can be enabled to explore the unexplored area first when the free-state agent is converted to an exploratory agent, thereby enabling the exploratory agent to explore the unexplored area efficiently.

[0058] Here, the free-state agent can be converted into an exploratory agent by calling the large language model as follows: Program output → large language model { "type": "state_change_request", "agent_id": "Agent-X", "new_state": "explore", "reason": "Unknown area detected at boundary" } Large language model output → program { "type": "state_change_confirmation", "agent_id": "Agent-X", "new_state": "explore", "status": "success" } After calling the large language model to convert the free-state agent into an exploratory-state agent, the environment overview information is also updated so that the environment overview information also includes the current location information and status information corresponding to the exploratory-state agent.

[0059] S360. For each exploratory agent, when the number of node-state agents around the exploratory agent is less than a preset number, the large language model is called to determine whether the node-state agents around the exploratory agent have reached the communication limit based on the communication range corresponding to the node-state agents around the exploratory agent.

[0060] Here, the number of node-state agents around the exploration-state agent can be obtained based on the environment overview information; the preset number can be 1 or other positive integers.

[0061] The number of node-state agents around the exploration-state agent can be determined as follows: Program output → large language model { "type": "proximity_check", "agent_id": "Agent-X", "current_location": [x, y], "communication_radius": "R" } Large language model output → program { "type": "proximity_report", "nearby_nodes": ["Node-1", "Node-2"], "within_communication_range": true } It should be noted that, for each exploratory agent, when calling the large language model to determine whether the exploratory agent has reached the communication limit, when the distance between the exploratory agent and the node-state agents surrounding the exploratory agent is greater than the communication range corresponding to the node-state agents surrounding the exploratory agent, it can be determined that the node-state agents surrounding the exploratory agent have reached the communication limit.

[0062] Exemplarily, when the number of node-state agents around the exploratory agent is less than a preset number, the large language model may be called in the following manner to determine whether the node-state agents around the exploratory agent have reached the communication limit: Program Output → LLM { "type": "communication_check", "agent_id": "Agent-X", "current_location": [x, y], "communication_radius": "R" } Large language model output → program { "type": "communication_status", "agent_id": "Agent-X", "within_communication_range": false } S370. If the number of node-state agents around an exploratory-state agent reaches the communication limit, the large language model is called to convert the exploratory-state agent into a node-state agent.

[0063] When the node-state agents around an exploratory agent reach the communication limit, it can be considered that the communication network formed by the node-state agents around the exploratory agent lacks adjacent nodes. Therefore, the exploratory agent is converted into a node-state agent here, which can fill the adjacent nodes lacking in the communication network and realize the support and expansion of the entire communication network, so as to ensure the stability of the communication network.

[0064] Exemplarily, when the node-state agents around the exploration-state agent reach the communication limit, the exploration-state agent can be converted into a node-state agent by calling the large language model in the following manner: Program output → large language model { "type": "state_change_request", "agent_id": "Agent-X", "new_state": "node", "reason": "Low node density within communication range" } Large language model output → program { "type": "state_change_confirmation", "agent_id": "Agent-X", "new_state": "node", "status": "success" } After calling the large language model to convert the exploratory agent into a node-state agent, the environment overview information is also updated so that the environment overview information also includes the current position information and status information corresponding to the node-state agent converted by the exploratory agent. This can also be understood as: the current position information and status information corresponding to the node-state agent, free-state agent and exploratory agent in the environment overview information change according to the conversion result of the agent state.

[0065] S380. Use the node-state agent converted from the exploration-state agent and the node-state agent that has not been converted as new node-state agents, and repeat the above steps until the large language model determines that the converted node-state agent, free-state agent and exploration-state agent do not need to change state.

[0066] Through this step, the node-state agents, free-state agents and exploration-state agents can be reasonably converted, so that the entire large language agent can be adaptively distributed on the two-dimensional grid map according to the tasks to be processed, and the movement path of each agent on the two-dimensional grid can be optimized, thereby improving the processing efficiency of the large language agent for the tasks to be processed.

[0067] By adopting the above method, through the construction and reasonable conversion of multiple node-state agents, multiple free-state agents and multiple exploration-state agents, the entire large language agent can be adaptively distributed on a two-dimensional grid map according to the tasks to be processed, thereby ensuring the exploration scope and flexibility of the entire large language agent and improving the task coverage and execution efficiency of the entire large language agent in complex environments.

[0068] Furthermore, the task instructions include a first task instruction corresponding to the free state agent and a second task instruction corresponding to the exploration state agent. Accordingly, inputting the environmental data information of the dynamic agent in the two-dimensional grid map into the large language model to obtain the task instruction of the dynamic agent may include the following steps: S410. Based on the environmental data information of the dynamic intelligent body, the large language model is called to update the environmental overview information to obtain new environmental overview information.

[0069] Since free-state agents tend to explore in explored areas, while exploratory agents tend to explore in unexplored areas, and after the exploratory agents complete their exploration of unexplored areas, the unexplored areas become explored areas, and the environmental overview information corresponding to the two-dimensional grid map will also change accordingly, the environmental data information of the dynamic agent is updated in real time according to the large language model to obtain the real-time environmental overview information corresponding to the two-dimensional grid map, thereby facilitating the adjustment of task instructions for the free-state agent and the exploratory agent according to the current environmental overview information.

[0070] Among them, calling the large language model to update the environment overview information can be achieved in the following ways: Program output → large language model { "type": "scan_report", "agent_id": "State-Free-1", "location": [x, y], "scan_data": { "obstacles": [...], "open_areas": [...] } } S420: According to the new environment overview information, call the large language model to determine the first task instruction and the second task instruction.

[0071] Here, the first task instructions include the first target subtask and movement instructions of each free-state agent in the explored area where it is located, and the movement instructions are used to command each free-state agent to move to the node grid corresponding to the first target subtask; the second task instructions include multiple second target subtasks and exploration instructions of each exploratory state agent in the unexplored area where it is located, and the exploration instructions are used to command the exploratory state agent to explore multiple second target subtasks in the unexplored area.

[0072] Exemplarily, the first task instruction and the second task instruction generated by calling the large language model are as follows: { "type": "commands", "State-Free": [{"agent_id": 1, "action": "move", "target_location":[x', y']}], "State-Explorer": [{"agent_id": 2, "action": "explore", "target_area": ​​"Region-B"}] } Here, the current explored and unexplored areas in the two-dimensional grid map are determined through new environmental overview information, and then the first task instructions and the second task instructions are determined based on the current explored and unexplored areas, so that the determined first task instructions can enable each free-state intelligent agent to move to the node grid corresponding to the first target subtask within the explored area where it is located, and the determined second task instructions can enable each exploratory state intelligent agent to explore multiple second target subtasks within the unexplored area where it is located.

[0073] By adopting the above method, new environmental overview information corresponding to the current two-dimensional grid map can be determined based on the environmental data information of the dynamic intelligent agent, and then based on the new environmental overview information, the large language model is called to determine the first task instructions corresponding to the free-state intelligent agent and the second task instructions corresponding to the exploratory intelligent agent, so as to enhance the flexibility of the entire large language model intelligent agent.

[0074] In some possible embodiments, calling a large language model to determine the first task instruction and the second task instruction according to the new environment overview information may include the following steps: S510: For each explored area, based on the new environment overview information, call the large language model to determine whether the first area environment information corresponding to the explored area has changed.

[0075] Here, the first area environmental information can be a collection of states of each target subtask in the explored area; the first area environmental information includes the first agent position information and the first area scanning information corresponding to the free-state agent, and the first area position information corresponding to the explored area; the first area scanning information is the task state information corresponding to the target subtask collected by the free-state agent in the explored area.

[0076] In this step, since it is possible to determine whether the two-dimensional grid map has changed based on the change in the environmental information of the first area corresponding to the explored area, that is, whether the task to be processed is updated or whether the task to be processed is a new task, the large language model is used here to determine whether the environmental information of the first area corresponding to the explored area has changed, which can facilitate the assignment of new task instructions to the exploratory intelligent agent or the adjustment of existing task instructions.

[0077] S520. If the first area environmental information corresponding to an explored area changes, then based on the first area environmental information, the large language model is called to assign a new first target subtask and movement instructions to the free-state agent located in the explored area.

[0078] Here, when the first area environmental information corresponding to an explored area changes, the large language module can assign a new first target subtask and movement instructions to the free-state intelligent agent according to the current first area environmental information and the current environmental conditions of the explored area, so as to optimize the movement path of the free-state intelligent agent according to the current environmental conditions of the explored area, so as to improve the processing efficiency of the free-state intelligent agent on the first target subtask corresponding to the explored area.

[0079] In addition, before calling the large language model to assign a new first target subtask and movement instructions to the free-state agent in the explored area, it also includes: calling the large language model to generate an overview report of the subtask status corresponding to the two-dimensional grid map for recording, monitoring or providing to an operator. The overview report includes whether each area in the two-dimensional grid map is an explored area or an unexplored area, and the processing progress information of each target subtask.

[0080] S530: For each unexplored area, based on the environment overview information, call the large language model to determine whether the second area environment information corresponding to the unexplored area has changed.

[0081] Here, the second area environmental information can be a collection of the states of each target subtask in the unexplored area; the second area environmental information includes the second agent position information and the second area scanning information corresponding to the unexplored area, and the second area position information corresponding to the unexplored area; the second area scanning information is the task state information corresponding to the target subtask collected by the exploration agent located in the unexplored area.

[0082] In this step, since it is possible to determine whether the two-dimensional grid map has changed based on the change in the environmental information of the second area corresponding to the unexplored area, that is, whether the task to be processed is updated or whether the task to be processed is a new task, the large language model is used here to determine whether the environmental information of the second area corresponding to the unexplored area has changed, which can facilitate the assignment of new task instructions to the exploratory agent or adjustment of existing task instructions to optimize the exploration path of the exploratory agent.

[0083] S540: If the second area environment information corresponding to an unexplored area changes, the large language model is called according to the second area environment information to assign new unexplored areas and exploration instructions to the exploratory agent.

[0084] Here, the new unexplored area includes a new second target subtask; wherein the new second target subtask can be understood as each target subtask in the node grid corresponding to the new unexplored area.

[0085] In this step, when the second area environmental information corresponding to an unexplored area changes, the large language module can allocate new unexplored areas and exploration instructions to the exploration state agent according to the current second area environmental information and the current environmental conditions of the unexplored area, so as to optimize the exploration path of the exploration state agent according to the current environmental conditions of the unexplored area, so as to improve the processing efficiency of the exploration state agent for the second target subtask corresponding to the unexplored area.

[0086] By adopting the above method, it is possible to determine whether the first area environmental information corresponding to the explored area and the second area environmental information corresponding to the unexplored area have changed based on the new environmental overview information corresponding to the two-dimensional grid map, and when the first area environmental information and the second area environmental information change, adjust the first task instruction and the second task instruction respectively, so as to optimize the exploration paths of the free-state intelligent agent and the exploratory-state intelligent agent according to the current environmental conditions of the two-dimensional grid map, thereby improving the processing efficiency of the overall large language intelligent agent on the target subtasks in the two-dimensional grid.

[0087] In some possible embodiments, if the first area environment information corresponding to an explored area changes, calling the large language model to assign a new first target subtask and movement instruction to the free-state agent located in the explored area according to the first area environment information may include the following steps: S610. For each explored area, analyze the first agent position information and the first area position information corresponding to the explored area based on the large language model to determine the path adjustment information of the free-state agent in the explored area.

[0088] It can be understood that based on the large language model and the first agent position information corresponding to an explored area and the first area position information, the first target subtask to be processed by the free-state agent corresponding to the explored area can be determined to provide the free-state agent with path adjustment information within the explored area, so as to avoid repeated processing of the first target subtask within the explored area by the free-state agents corresponding to other explored areas.

[0089] S620: Determine region status information of each explored region based on analysis of first region scan information corresponding to each explored region by the large language model.

[0090] Here, the area status information includes a release status and a blocking status; the first area scanning information may include obstacle information or open area information.

[0091] S630. For each explored area, call the large language model to adjust the moving path of the free-state agent according to the path adjustment information and the area status information to obtain an adjusted moving instruction.

[0092] Here, the movement instruction includes a movement direction and a movement distance.

[0093] Exemplarily, the large language model can be called in the following manner to adjust the moving path of the free-state agent according to the path adjustment information and the regional state information: Program output → large language model { "type": "movement_request", "agent_id": "Agent-X", "current_state": "free", "strategy": "random" } Large language model output → program { "type": "movement_instructions", "agent_id": "Agent-X", "new_direction": {"angle": 120, "distance": 3} } The moving path of the free-state intelligent body in the explored area is adjusted according to the path adjustment information of the free-state intelligent body in the explored area and the corresponding area status information of the explored area. This can not only avoid the repeated exploration of different exploration areas by the free-state intelligent body, but also adaptively adjust the moving path of the free-state intelligent body according to the area status information of each explored area, thereby improving the processing efficiency of the free-state intelligent body on the first target subtask in the explored area.

[0094] The above method can avoid the free-state intelligent agent's blind exploration of the explored area and the inefficient processing of the first target subtask in the explored area, thereby expanding the boundary of the explored area more quickly.

[0095] Furthermore, if the second area environment information corresponding to an unexplored area changes, calling the large language model to assign a new unexplored area and exploration instructions to the exploratory agent according to the second area environment information may include the following steps: S710: For each unexplored area, input second area scanning information corresponding to the unexplored area into a large language model to determine environmental feature information of the unexplored area.

[0096] Here, the second area scanning information may include area location information, temperature information, and terrain information.

[0097] S720: Based on the environmental feature information, call the large language model to mark key points of the unexplored area.

[0098] Among them, key points may include location features and important features.

[0099] For example, the large language model can be called to mark key points in the unexplored area in the following manner: { "type": "key_findings", "agent_id": "State-Explorer-2", "findings": [ {"location": [x, y], "type": "mineral", "value": "high"} ] } S730. Input the key points corresponding to each unexplored area into the large language model to determine the exploration instructions corresponding to the exploratory agent in each unexplored area.

[0100] Here, the exploration instruction includes exploration path information and exploration depth information; the exploration path information includes exploration path direction and exploration path distance; the exploration depth information can be a detailed exploration of the unexplored area by the exploration state intelligent agent.

[0101] Since the key points corresponding to different unexplored areas are different, the exploration requirements for different unexplored areas will also be different. Therefore, here we call the large language model to analyze the key points corresponding to each unexplored area, and determine the exploration instructions corresponding to the exploratory agent in each unexplored area, so as to improve the exploration efficiency of the exploratory agent in the unexplored area, and then improve the processing efficiency of the exploratory agent on the second target subtask in the unexplored area.

[0102] Among them, the large language model can be called through the following example to determine the exploration instructions corresponding to the exploratory agent in each unexplored area: Program output → large language model { "type": "exploration_request", "agent_id": "Agent-X", "current_state": "explore", "goal": "Move towards unknown area" } Large language model output → program { "type": "exploration_instructions", "agent_id": "Agent-X", "new_direction": {"angle": 90, "distance": 10} } By adopting the above method, it is possible to determine the exploration instructions corresponding to the exploratory agent in each unexplored area, avoid the blind exploration of the unexplored area by the exploratory agent, and the inefficient processing of the second target subtask in the unexplored area, thereby improving the exploration efficiency of the exploratory agent in the unexplored area.

[0103] In some possible implementations, decomposing the task to be processed based on the large language model to obtain a two-dimensional grid graph may include the following steps: S810: Based on the characteristics of the task to be processed, call the large language model to perform a first-level decomposition on the task to be processed to obtain an initial grid flow chart.

[0104] Here, the initial grid flowchart includes a plurality of task steps decomposed from the task to be processed, and a step grid corresponding to each task step.

[0105] It should be noted that the multiple task steps decomposed from the task to be processed all have clear step positions. Therefore, after the large language model performs a first-level decomposition on the unknown task to be processed, the multiple task steps obtained have a clear step sequence, so that the dependency relationship between the multiple task steps can be determined based on the step sequence; in addition, the step grid corresponding to each task step also has clear position information, and the grid positions of the multiple step grids correspond to the step positions of the task steps one by one. Therefore, the task steps included in the task to be processed and the process of the task steps can be intuitively displayed through the initial grid flowchart.

[0106] Among them, calling the large language model to perform a first-level decomposition of the task to be processed can be achieved in the following ways: Program output → large language model { "type": "task_analysis_request", "task_description": "", "goal": "Identify and enumerate the steps required for the task, withdependencies between steps." } Large language model output → program { "type": "task_steps_identification", "steps": [ {"step_id": "1", "name": "Step Name 1", "dependencies": []}, {"step_id": "2", "name": "Step Name 2", "dependencies": ["1"]}, ... ] } S820. For each task step, based on the dependency relationship between the task step and its previous task step and / or the next task step, call the large language model to perform secondary decomposition on the task step to obtain multiple target subtasks corresponding to the task step.

[0107] For example, when calling a large language model to perform a two-level decomposition of task steps, it can be implemented in the following manner: Program output → large language model { "type": "layout_request", "steps_with_dependencies": [ {"step_id": "1", "name": "Step Name 1", "dependencies": []}, {"step_id": "2", "name": "Step Name 2", "dependencies": ["1"]}, ... ] } Large language model output → program { "type": "layout_plan", "grid_layout": [ {"step_id": "1", "name": "Step Name 1", "location": [0, 0]}, {"step_id": "2", "name": "Step Name 2", "location": [0, 1]}, ... ] } Among them, the dependency relationship can be understood as the process dependency relationship between two task steps. If the step position relationship between the two task steps is a front-and-back relationship, it can be considered that there is a process dependency relationship between the two task steps; if the step position relationship between the two task steps is not a front-and-back relationship, it can be considered that there is no process dependency relationship between the two task steps.

[0108] It should be noted that before calling the large language model to perform secondary decomposition on the task steps, it also includes: judging the dependency relationship between the task steps to be decomposed at the secondary level and other task steps. If there is no dependency relationship between the task steps to be decomposed at the secondary level and other task steps, calling the large language model to generate an initialization instruction for the task steps to be decomposed at the secondary level to complete the initialization of the task steps to be decomposed at the secondary level; if there is a dependency relationship between the task steps to be decomposed at the secondary level and other task steps, that is, the task steps to be decomposed at the secondary level have the previous task steps and / or the next task steps with which they have a process dependency relationship, calling the large language model to generate an execution instruction, so that the task steps to be decomposed at the secondary level are decomposed into multiple target subtasks at the secondary level; wherein the execution task includes data input and data processing methods.

[0109] Here, when there is no dependency between the task step to be decomposed at the second level and other task steps, the large language model is called in the following way to generate initialization instructions for the task step to be decomposed at the second level: Program output → large language model { "type": "step_initialization", "step_id": "1", "step_name": "Step Name 1", "location": [0, 0] } Large language model output → program { "type": "initialization_instructions", "step_id": "1", "instructions": "", "next_steps": ["2"] / / } When there is a dependency relationship between the task step to be decomposed at the second level and other task steps, the large language model is called to generate a second level decomposition of the task step to be decomposed in the following way: Task step output → large language model { "type": "step_execution_request", "step_id": "2", "step_name": "Step Name 2", "location": [0, 1], "dependencies": ["1"] } Large language model output → target subtask { "type": "execution_instructions", "step_id": "2", "instructions": "", "input_requirements": {"previous_step_data": ["Step Name 1"]}, "next_steps": ["3"] } In this step, based on the dependency relationship between each task step and its previous task step and / or next task step, the large language model is called to perform a secondary decomposition of the task step, so that the multiple target subtasks obtained by the secondary decomposition can be intuitively displayed in the form of adjacent step grids to reduce the repeated decomposition of each task step. At the same time, it can also facilitate the integration of the multiple target subtasks corresponding to each task step in step S830 with the corresponding step grids in the initial grid flowchart according to the dependency relationship between each task step.

[0110] S830, integrating the multiple target subtasks corresponding to each task step with each step grid in the initial grid flow chart to obtain a final two-dimensional grid chart.

[0111] Here, for each task step, the position information of each target subtask in the step grid corresponding to the task step is determined according to the execution order of multiple target subtasks in the task step; then, based on the position information of each target subtask in the step grid, each target subtask is integrated into the step grid, so that the step grid corresponding to the task step is divided into multiple node grids corresponding to the positions of each target subtask.

[0112] Among them, the multiple target subtasks corresponding to each task step can be integrated with each step grid in the initial grid flowchart in the following way: Program output → large language model { "type": "flowchart_summary_request", "grid_layout": [ {"step_id": "1", "location": [0, 0]}, {"step_id": "2", "location": [0, 1]}, ... ] } Large language model output → program { "type": "flowchart_summary", "flowchart": [ {"step_id": "1", "location": [0, 0], "name": "Step Name 1"}, {"step_id": "2", "location": [0, 1], "name": "Step Name 2"}, ... ] } The final two-dimensional grid diagram obtained according to the above example is as follows: { "flowchart": [ {"step_id": "1", "name": "Step Name 1", "location": [0, 0]}, {"step_id": "2", "name": "Step Name 2", "location": [0, 1]}, {"step_id": "3", "name": "Step Name 3", "location": [1, 0]}, ... ] } By adopting the above method, intelligent agents in different states can more effectively understand the dependencies between various task steps based on the final two-dimensional grid diagram when processing tasks. At the same time, intelligent agents in different states can also intuitively display the step tasks through the adjacent node grids in the two-dimensional grid diagram, and process multiple target subtasks corresponding to each step task, which can reduce the divergence of the dynamic intelligent agent's movement paths on the two-dimensional grid diagram and the repeated processing of a certain target subtask.

[0113] Figure 4 FIG. 1 is a schematic diagram of a task processing device based on a large language model agent according to an embodiment of the present invention. Figure 4 As shown, the device comprises: A two-dimensional grid graph generation module 910 is used to decompose the task to be processed based on the large language model to obtain a two-dimensional grid graph; the two-dimensional grid graph includes multiple target subtasks and node grids corresponding to the multiple target subtasks; The agent building module 920 is used to build a large language model agent based on the grid structure of the two-dimensional grid graph; the large language model agent includes multiple node-state agents and multiple dynamic agents; the node-state agent is an agent used to guide the moving direction of the dynamic agent; The task instruction generation module 930 is used to input the environmental data information of each dynamic agent in the two-dimensional grid map into the large language model to obtain the task instruction corresponding to each dynamic agent; the task instruction includes an instruction to command the dynamic agent to move to the node grid corresponding to the target subtask; The target subtask processing module 940 is used to control the dynamic agents to move under the direction of the node state agents according to the task instructions corresponding to each dynamic agent, so that all dynamic agents can complete the processing of the target subtasks in each node grid in the two-dimensional grid diagram.

[0114] In some implementations, the dynamic agent includes a free-state agent and an exploratory-state agent; the agent building module 920 includes: A node-state intelligent agent construction unit is used to construct a plurality of node-state intelligent agents for the two-dimensional grid graph based on the grid structure of the two-dimensional grid graph; The first agent judgment unit is used to call the large language model to judge whether each node-state agent is in an extreme state according to the current position information corresponding to the multiple node-state agents; the extreme state includes a lost connection state or an out-of-group state; A first state conversion unit, for converting a node-state agent into a free-state agent by calling a large language model if the node-state agent is in an extreme state; A second agent judgment unit is used to call the large language model to judge whether each free-state agent has contacted a node grid located at the boundary of an unexplored area according to current position information and detection ranges corresponding to the plurality of free-state agents and environment overview information corresponding to the two-dimensional grid map; the environment overview information is obtained by inputting the environment data information of the node-state agent and / or the environment data information of the free-state agent into the large language model, and the environment overview information includes explored area information and unexplored area information; A second state conversion unit is used to call the large language model to convert a free-state agent into an exploratory-state agent if the free-state agent contacts a node grid located at the boundary of an unexplored area; The third agent judgment unit is used for, for each exploratory agent, when the number of node-state agents around the exploratory agent is less than a preset number, calling the large language model to judge whether the node-state agents around the exploratory agent have reached the communication limit according to the communication range corresponding to the node-state agents around the exploratory agent; A third state conversion unit is used to call the large language model to convert an exploratory state agent into a node state agent if the node state agents around the exploratory state agent reach the communication limit; The repeating execution unit is used to take the node-state agent converted from the exploration-state agent and the node-state agent that has not been converted as new node-state agents, and repeat the above steps until the large language model determines that the converted node-state agent, the free-state agent and the exploration-state agent do not need to change their states.

[0115] In some implementations, the task instruction includes a first task instruction corresponding to the free state agent and a second task instruction corresponding to the exploration state agent; the task instruction generation module 930 includes: An environment overview information updating unit is used to call a large language model to update the environment overview information according to the environment data information of the dynamic agent to obtain new environment overview information; the environment data information includes agent state information, agent location information and scanning information of the dynamic agent in the two-dimensional grid map; The task instruction allocation unit is used to call the large language model to determine the first task instruction and the second task instruction according to the new environment overview information; the first task instruction includes the first target subtask of each free-state intelligent agent in the explored area and the movement instruction, and the movement instruction is used to command each free-state intelligent agent to move to the node grid corresponding to the first target subtask; the second task instruction includes multiple second target subtasks of each exploring state intelligent agent in the unexplored area and the exploration instruction, and the exploration instruction is used to command the exploring state intelligent agent to explore multiple second target subtasks in the unexplored area.

[0116] In some possible implementations, the task instruction allocation unit includes: The first area environment judgment subunit is used to call the large language model to judge whether the first area environment information corresponding to the explored area has changed according to the new environment overview information for each explored area; the first area environment information includes the first agent position information and the first area scanning information corresponding to the free-state agent, and the first area position information corresponding to the explored area; A first target subtask assignment unit is used to assign a new first target subtask and movement instruction to the free-state agent located in the explored area by calling the large language model according to the first area environment information if the first area environment information corresponding to the explored area changes; The second area environment judgment subunit is used to call the large language model to judge whether the second area environment information corresponding to the unexplored area has changed according to the environment overview information for each unexplored area; the second area environment information includes the second agent position information and the second area scanning information corresponding to the unexplored state agent, and the second area position information corresponding to the unexplored area; The second target subtask allocation unit is used to call the large language model to allocate a new unexplored area and exploration instructions to the exploratory agent according to the second area environmental information if the second area environmental information corresponding to an unexplored area changes, and the new unexplored area contains a new second target subtask.

[0117] In some possible implementations, the first target subtask allocation unit includes: A path adjustment information determination subunit is used to analyze the first agent position information and the first area position information corresponding to each explored area based on the large language model to determine the path adjustment information of the free-state agent in the explored area; A region status information determination subunit, configured to determine region status information of each explored region based on analysis of first region scanning information corresponding to each explored region by a large language model; the region status information includes a release status and a blocking status; The movement instruction adjustment subunit is used to call the large language model to adjust the movement path of the free-state intelligent body according to the path adjustment information and the area status information for each explored area, and obtain the adjusted movement instruction; the movement instruction includes the movement direction and the movement distance.

[0118] In some possible implementations, the second target subtask allocation unit includes: an environmental feature information determination subunit, for each unexplored area, inputting second area scanning information corresponding to the unexplored area into the large language model to determine environmental feature information of the unexplored area; The key point marking subunit is used to call the large language model to mark the key points of the unexplored area according to the environmental feature information; The exploration instruction determination subunit is used to input the key points corresponding to each unexplored area into the large language model, and determine the exploration instructions corresponding to the exploratory intelligent agent in each unexplored area; the exploration instructions include exploration path information and exploration depth information; the exploration path information includes exploration path direction and exploration path distance.

[0119] In some implementations, the two-dimensional grid map generation module 910 includes: An initial grid flowchart generating unit is used to call the large language model to perform a first-level decomposition of the task to be processed according to the characteristics of the task to be processed, and obtain an initial grid flowchart; the initial grid flowchart includes a plurality of task steps decomposed from the task to be processed, and a step grid corresponding to each task step; A target subtask generation unit is used to call the large language model to perform secondary decomposition on each task step according to the dependency relationship between the task step and its previous task step and / or the next task step, so as to obtain multiple target subtasks corresponding to the task step; The two-dimensional grid diagram generating unit is used to integrate the multiple target subtasks corresponding to each task step with each step grid in the initial grid flow chart to obtain a final two-dimensional grid diagram.

[0120] It should be understood that the embodiment of the task processing device based on the large language model agent and the embodiment of the task processing method based on the large language model agent may correspond to each other, and similar descriptions may refer to the embodiment of the task processing method based on the large language model agent. To avoid repetition, it will not be repeated here. Specifically, Figure 4 The device shown can execute the above-mentioned task processing method embodiment based on a large language model intelligent agent, and the aforementioned and other operations and / or functions of each module in the device are respectively for realizing the corresponding processes in the above-mentioned task processing method based on a large language model intelligent agent. For the sake of brevity, they will not be repeated here.

[0121] In the above, the apparatus of the embodiment of the present invention is described from the perspective of the functional module in conjunction with the accompanying drawings. It should be understood that the functional module can be implemented in the form of hardware, can be implemented by instructions in the form of software, and can also be implemented by a combination of hardware and software modules. Specifically, the various steps of the task processing method based on the large language model agent and the detection method embodiment in the embodiment of the present invention can be completed by the hardware integrated logic circuit and / or software instructions in the processor, and the steps of the task processing method based on the large language model agent and the detection method disclosed in the embodiment of the present invention can be directly embodied as a hardware decoding processor to execute, or a combination of hardware and software modules in the decoding processor to execute. Optionally, the software module can be located in a mature storage medium in the field such as a random access memory, a flash memory, a read-only memory, a programmable read-only memory, an electrically erasable programmable memory, a register, etc. The storage medium is located in the memory, and the processor reads the information in the memory, and completes the steps in the above-mentioned task processing method based on the large language model agent and the detection method embodiment in conjunction with its hardware.

[0122] Figure 5 is a schematic block diagram of an electronic device 110 according to an embodiment of the present invention.

[0123] like Figure 5 As shown, the task processing device 110 based on the large language model agent may include: The memory 111 and the processor 112, the memory 111 is used to store the computer program and transmit the program code to the processor 112. In other words, the processor 112 can call and run the computer program from the memory 111 to implement the method in the embodiment of the present invention.

[0124] For example, the processor 112 may be configured to execute the above method embodiments according to instructions in the computer program.

[0125] In some embodiments of the present invention, the task processing device 110 based on the large language model agent may include but is not limited to: General-purpose processors, digital signal processors (DSP), application-specific integrated circuits (ASIC), field-programmable gate arrays (FPGA) or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc.

[0126] In some embodiments of the present invention, the memory 111 includes but is not limited to: Volatile memory and / or non-volatile memory. Among them, the non-volatile memory can be read-only memory (ROM), programmable ROM (PROM), erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM) or flash memory. Volatile memory can be random access memory (RAM), which is used as an external cache. By way of example and not limitation, many forms of RAM are available, such as static random access memory (SRAM), dynamic random access memory (DRAM), synchronous dynamic random access memory (SDRAM), double data rate synchronous dynamic random access memory (DDR SDRAM), enhanced synchronous dynamic random access memory (ESDRAM), synchronous link DRAM (SLDRAM), and direct memory bus random access memory (Direct Rambus RAM, DR RAM).

[0127] In some embodiments of the present invention, the computer program may be divided into one or more modules, which are stored in the memory 111 and executed by the processor 112 to complete the method provided by the present invention. The one or more modules may be a series of computer program instruction segments capable of completing specific functions, and the instruction segments are used to describe the execution process of the computer program in the controller.

[0128] like Figure 5 As shown, the task processing device 110 based on the large language model agent may also include: The transceiver 113 may be connected to the processor 112 or the memory 111 .

[0129] The processor 112 may control the transceiver 113 to communicate with other devices, specifically, to send information or data to other devices, or to receive information or data sent by other devices. The transceiver 113 may include a transmitter and a receiver. The transceiver 113 may further include an antenna, and the number of antennas may be one or more.

[0130] It should be understood that the various components in the task processing device based on the large language model agent are connected via a bus system, wherein the bus system includes not only a data bus but also a power bus, a control bus and a status signal bus.

[0131] The present invention also provides a computer storage medium having a computer program stored thereon, which, when executed by a computer, enables the computer to perform the method of the above method embodiment. In other words, an embodiment of the present invention also provides a computer program product containing instructions, which, when executed by a computer, enables the computer to perform the method of the above method embodiment.

[0132] When software is used for implementation, it can be implemented in whole or in part in the form of a computer program product. The computer program product includes one or more computer instructions. When the computer program instructions are loaded and executed on a computer, the process or function according to the embodiment of the present invention is generated in whole or in part. The computer can be a general-purpose computer, a special-purpose computer, a computer network, or other programmable devices. The computer instructions can be stored in a computer-readable storage medium, or transmitted from one computer-readable storage medium to another computer-readable storage medium. For example, the computer instructions can be transmitted from a website site, computer, server or data center to another website site, computer, server or data center by wired (e.g., coaxial cable, optical fiber, digital subscriber line (Digital Subscriber Line, DSL)) or wireless (e.g., infrared, wireless, microwave, etc.) mode. The computer-readable storage medium can be any available medium that a computer can access or a data storage device such as a server or data center that includes one or more available media integration. The available medium can be a magnetic medium (e.g., a floppy disk, a hard disk, a tape), an optical medium (e.g., a digital video disc (Digital Video Disc, DVD)), or a semiconductor medium (e.g., a solid-state drive (SSD)), etc.

[0133] Those skilled in the art will appreciate that the modules and algorithm steps of each example described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are performed in hardware or software depends on the specific application and design constraints of the technical solution. Professional and technical personnel can use different methods to implement the described functions for each specific application, but such implementation should not be considered to be beyond the scope of the present invention.

[0134] In the several embodiments provided by the present invention, it should be understood that the disclosed systems, devices and methods can be implemented in other ways. For example, the device embodiments described above are only schematic. For example, the division of the module is only a logical function division. There may be other division methods in actual implementation, such as multiple modules or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be through some interfaces, indirect coupling or communication connection of devices or modules, which can be electrical, mechanical or other forms.

[0135] The modules described as separate components may or may not be physically separated, and the components displayed as modules may or may not be physical modules, that is, they may be located in one place, or they may be distributed on multiple network units. Some or all of the modules may be selected according to actual needs to achieve the purpose of the scheme of this embodiment. For example, each functional module in each embodiment of the present application may be integrated into a processing module, or each module may exist physically separately, or two or more modules may be integrated into one module.

[0136] The above are only specific embodiments of the present invention, but the protection scope of the present invention is not limited thereto. Any person skilled in the art who is familiar with the technical field can easily think of changes or substitutions within the technical scope disclosed in this application, which should be included in the protection scope of the present invention. Therefore, the protection scope of the present invention should be based on the protection scope of the claims.

Claims

1. A task processing method based on a large language model agent, characterized in that: include: Decomposing the task to be processed based on the large language model to obtain a two-dimensional grid graph; the two-dimensional grid graph includes a plurality of target subtasks and node grids corresponding to the plurality of target subtasks; Based on the grid structure of the two-dimensional grid graph, a large language model agent is constructed; the large language model agent includes a plurality of node state agents and a plurality of dynamic agents; the node state agent is an agent used to guide the moving direction of the dynamic agent; Inputting the environmental data information of each of the dynamic agents in the two-dimensional grid map into the large language model to obtain task instructions corresponding to each of the dynamic agents; the task instructions include instructions for commanding the dynamic agents to move to the node grid corresponding to the target subtask; According to the task instructions corresponding to each of the dynamic agents, the dynamic agents are controlled to move under the direction of the node-state agent, so that all of the dynamic agents complete the processing of the target subtasks within each of the node grids in the two-dimensional grid diagram.

2. The method according to claim 1, characterized in that The dynamic agent includes a free state agent and an exploration state agent; the grid structure based on the two-dimensional grid graph is used to construct a large language model agent, including: Based on the grid structure of the two-dimensional grid graph, construct a plurality of node-state intelligent agents for the two-dimensional grid graph; According to the current position information corresponding to the plurality of node-state agents, calling the large language model to determine whether each of the node-state agents is in an extreme state; the extreme state includes a lost connection state or an out-of-group state; If a node-state agent is in the extreme state, calling the large language model to convert the node-state agent into a free-state agent; According to the current position information and detection range corresponding to the plurality of free-state intelligent agents, and the environment overview information corresponding to the two-dimensional grid map, the large language model is called to determine whether each of the free-state intelligent agents contacts the node grid located at the boundary of the unexplored area; the environment overview information is obtained by inputting the environment data information of the node-state intelligent agent and / or the environment data information of the free-state intelligent agent into the large language model; the environment overview information includes the explored area information and the unexplored area information; If a free-state agent contacts a node grid located at the boundary of the unexplored area, calling the large language model to convert the free-state agent into an exploratory agent; For each of the exploratory agents, when the number of node-state agents around the exploratory agent is less than a preset number, calling the large language model to determine whether the node-state agents around the exploratory agent have reached a communication limit according to the communication ranges corresponding to the node-state agents around the exploratory agent; If the node-state agents around the exploration-state agent reach the communication limit, calling the large language model to convert the exploration-state agent into a node-state agent; The node-state agent converted from the exploration-state agent and the unconverted node-state agent are used as new node-state agents, and the above steps are repeated until the large language model determines that the converted node-state agent, free-state agent and exploration-state agent do not need to change their states.

3. The method according to claim 2, characterized in that The task instruction includes a first task instruction corresponding to the free-state agent and a second task instruction corresponding to the exploratory agent; the step of inputting the environmental data information of the dynamic agent in the two-dimensional grid map into the large language model to obtain the task instruction of the dynamic agent includes: According to the environmental data information of the dynamic agent, the large language model is called to update the environmental overview information to obtain new environmental overview information; the environmental data information includes agent state information, agent position information and scanning information of the dynamic agent in the two-dimensional grid map; According to the new environment overview information, the large language model is called to determine the first task instructions and the second task instructions; the first task instructions include the first target subtask and movement instructions of each of the free-state agents in the explored area, and the movement instructions are used to command each of the free-state agents to move to the node grid corresponding to the first target subtask; the second task instructions include multiple second target subtasks and exploration instructions of each of the exploring agents in the unexplored area, and the exploration instructions are used to command the exploring agents to explore the multiple second target subtasks in the unexplored area.

4. The method according to claim 3, characterized in that According to the new environment overview information, calling the large language model to determine the first task instruction and the second task instruction includes: For each of the explored areas, based on the new environment overview information, calling the large language model to determine whether the first area environment information corresponding to the explored area has changed; the first area environment information includes the first agent position information and the first area scanning information corresponding to the free-state agent, and the first area position information corresponding to the explored area; If the first area environment information corresponding to the explored area changes, calling the large language model to assign a new first target subtask and movement instruction to the free-state agent located in the explored area according to the first area environment information; For each of the unexplored areas, based on the environment overview information, calling the large language model to determine whether the second area environment information corresponding to the unexplored area has changed; the second area environment information includes the second agent position information and the second area scanning information corresponding to the unexplored state agent, and the second area position information corresponding to the unexplored area; If the second area environmental information corresponding to the unexplored area changes, the large language model is called to assign a new unexplored area and exploration instructions to the exploratory agent based on the second area environmental information; the new unexplored area contains a new second target subtask.

5. The method according to claim 4, characterized in that If the first area environment information corresponding to the explored area changes, calling the large language model to assign a new first target subtask and movement instruction to the free-state agent located in the explored area according to the first area environment information, includes: For each of the explored areas, analyzing the first agent position information and the first area position information corresponding to the explored area based on the large language model, and determining the path adjustment information of the free-state agent in the explored area; Determine the regional status information of each of the explored areas based on the analysis of the first regional scanning information corresponding to each of the explored areas by the large language model; the regional status information includes a release status and a blocking status; For each of the explored areas, the large language model is called to adjust the moving path of the free-state agent according to the path adjustment information and the area status information to obtain an adjusted moving instruction; the moving instruction includes a moving direction and a moving distance.

6. The method according to claim 4, characterized in that If the second area environment information corresponding to the unexplored area changes, calling the large language model to assign a new unexplored area and exploration instructions to the exploratory agent according to the second area environment information includes: For each of the unexplored areas, inputting second area scanning information corresponding to the unexplored area into the large language model to determine environmental feature information of the unexplored area; According to the environmental feature information, calling the large language model to mark key points of the unexplored area; The key points corresponding to each of the unexplored areas are input into the large language model to determine the exploration instructions corresponding to the exploratory intelligent agents in each of the unexplored areas; the exploration instructions include exploration path information and exploration depth information; the exploration path information includes exploration path direction and exploration path distance.

7. The method according to any one of claims 1 to 6, characterized in that: The task to be processed is decomposed based on the large language model to obtain a two-dimensional grid graph, including: According to the characteristics of the task to be processed, calling the large language model to perform a first-level decomposition on the task to be processed, and obtaining an initial grid flowchart; the initial grid flowchart includes a plurality of task steps decomposed from the task to be processed, and a step grid corresponding to each of the task steps; For each of the task steps, based on the dependency relationship between the task step and its previous task step and / or the next task step, the large language model is called to perform secondary decomposition on the task step to obtain a plurality of target subtasks corresponding to the task step; The multiple target subtasks corresponding to each of the task steps are integrated with each of the step grids in the initial grid flowchart to obtain a final two-dimensional grid diagram.

8. A task processing device based on a large language model agent, characterized in that: include: A two-dimensional grid graph generation module is used to decompose the task to be processed based on the large language model to obtain a two-dimensional grid graph; The two-dimensional grid graph includes a plurality of target subtasks and node grids corresponding to the plurality of target subtasks; An agent building module is used to build a large language model agent based on the grid structure of the two-dimensional grid graph; the large language model agent includes a plurality of node state agents and a plurality of dynamic agents; the node state agent is an agent used to guide the moving direction of the dynamic agent; A task instruction generation module, used for inputting the environmental data information of each of the dynamic agents in the two-dimensional grid map into the large language model to obtain the task instructions corresponding to each of the dynamic agents; the task instructions include instructions for commanding the dynamic agents to move to the node grid corresponding to the target subtask; The target subtask processing module is used to control the dynamic agents to move under the direction of the node-state agents according to the task instructions corresponding to each of the dynamic agents, so that all the dynamic agents can complete the processing of the target subtasks within each of the node grids in the two-dimensional grid diagram.

9. An electronic device, characterized in that: include: A processor and a memory, the memory being used to store a computer program, and the processor being used to call and run the computer program stored in the memory to execute the method according to any one of claims 1 to 7.

10. A computer-readable storage medium, characterized in that: Used to store a computer program, wherein the computer program causes a computer to execute the method according to any one of claims 1 to 7.

Images