Multi-agent efficient cooperative path planning method

Abstract

The invention relates to the technical field of multi-agent collaborative planning, and particularly discloses a multi-agent efficient collaborative path planning method. Comprising a system initialization step, a candidate point set expansion step, an AStar algorithm path planning step, a task execution monitoring step, a candidate point list updating step, an MILP target point selection step, a transition target point selection step and a path planning completion step. According to the method, the optimal path of each agent can be planned by comprehensively considering factors such as the task area, the initial position of the agent, the speed limitation, the target position coordinate, the obstacle area and the minimum execution frequency index. Through reasonable task allocation and obstacle avoidance strategies, it is ensured that the agents can efficiently and safely complete established tasks, and the method is superior to a traditional method in key performance indexes such as path length, task completion time and calculation time.

Description

Technical Field

[0001] The present invention relates to the technical field of multi-agent collaborative planning, and in particular to a multi-agent efficient collaborative path planning method. Background Art

[0002] Multi-agent collaborative path planning is the problem of planning paths for multiple agents. The main constraint is that multiple agents can move along the pre-planned path at the same time without conflict and can complete the task efficiently and safely. Multi-agent collaborative path planning has many applications in various fields, such as logistics scheduling, drone collaborative operations, large warehouse automation management, road network optimization in smart cities, multi-robot collaborative systems, and security monitoring. With the rapid development of these fields, the demand for multi-agent collaborative path planning is growing. However, the dynamic changes in the environment and the increase in the number of agents are a major challenge for multi-agent collaborative path planning.

[0003] Although significant progress has been made in this field in recent years, several challenges remain:

[0004] (1) First, existing technologies are insufficient in terms of adaptability to dynamic environments. Especially when faced with complex and changeable environments or a large number of intelligent agents, the computational efficiency and accuracy of existing algorithms are often unable to meet actual needs.

[0005] (2) Secondly, when planning a path, the agent must not only consider its own action constraints, but also deal with the problem of collision avoidance with other agents. As the number of agents increases, the number of collision avoidance constraints increases exponentially, causing the complexity of solving the problem to increase dramatically.

[0006] (3) In addition, in specific application scenarios, such as automated monitoring or emergency response tasks, intelligent agents must not only avoid obstacles, but also efficiently allocate tasks and complete them collaboratively. How intelligent agents can quickly and accurately reach designated task points and perform tasks while keeping the path shortest and most efficient is a major challenge in current collaborative path planning.

[0007] In view of this, the present invention proposes a multi-agent efficient collaborative path planning method to make up for and improve the shortcomings of the prior art. Summary of the invention

[0008] In order to solve the problems of high computational complexity and low efficiency in completing tasks in multi-agent collaboration, this paper proposes a multi-agent collaborative path planning method that combines mixed integer linear programming (MILP) with the AStar heuristic algorithm. This method can comprehensively consider factors such as the task area, the initial position of the agent, the speed limit, the target position coordinates, the obstacle area, and the minimum number of executions to plan the optimal path for each agent. Through reasonable task allocation and obstacle avoidance strategies, it is ensured that the agent can complete the given task efficiently and safely.

[0009] In order to achieve the above object, the present invention provides a multi-agent efficient collaborative path planning method, comprising the following steps:

[0010] S1. Define the set of intelligent agents and target points, as well as the initial position, speed limit, task execution number limit and task load capacity of the intelligent agents, and set the obstacle area;

[0011] S2, introducing an additional set of candidate points;

[0012] S3, use the AStar algorithm to plan the path to each agent's goal point and calculate the time required to travel along these paths;

[0013] S4, maintain the visit record of each target point, record the time and number of times the agent arrives, and check whether the task execution number indicator is met;

[0014] S5. For the target points that do not meet the indicators, update the candidate point list of the agent;

[0015] S6. Construct a 0-1 matrix to represent the selection relationship between the agent and the candidate point, and construct the objective function as the sum of the distances from all agents to their selected target points. Use the MILP solver to minimize the objective function and satisfy the constraints.

[0016] S7, when any agent first reaches the target point of the current plan, if the execution indicator of the point has been completed and the number of remaining task executions of the agent is not zero, it will directly enter the next step of planning. If the agent still has remaining tasks to execute, it will select a point different from the previous target point and closest to it as the transition target;

[0017] S8. Continuously update and record the target point allocation of each agent until the execution indicators of all target points are met to form a complete path planning.

[0018] Preferably, in the root node initialization of the high-level conflict detection algorithm in step S1, an empty node without time and space constraints and without a solution is first generated as the initialization of the root node.

[0019] Preferably, step S1 specifically includes the following steps:

[0020] S101, set the agent set A = {a1, a2, ..., a n}, target point set T = {t1, t2, …, t m}, obstacle area O;

[0021] S102, for each intelligent agent a i Set the initial position P ai , speed limit V ai , task execution times limit E ai and mission load capacity L aj .

[0022] Preferably, the step S2 specifically includes the following steps:

[0023] S201. Exclude from all potential target points those points that are inside obstacles or too close to obstacles:

[0024]

[0025] Among them, C i ′ is the candidate point set of agent i, is the set of all potential target points, b k represents obstacles, δ is the safety distance;

[0026] S202. Evaluate the accessibility of each potential target point:

[0027] C i ″={p∈C i ′|PathExists(p,o i )}

[0028] Among them, PathExists(p,o i ) is a Boolean function that returns an agent i if i A feasible path to point p, returns true;

[0029] S203: Ensure that the points in the candidate point set can meet the agent's task requirements, such as the number of arrivals and execution area:

[0030] C i,final ={p∈C i ″|T i,p ≤T req,p}

[0031] Among them, T i,p is the number of times agent i executes the task to reach the target point p, T req,p is the number of task execution requirements of target point p;

[0032] S204, optimize the initially generated candidate point set, and give priority to candidate points that are closer to the current position of the agent to reduce movement time and energy consumption:

[0033] C i,dist ={p∈C i,final ∣d(o i ,p)≤D max}

[0034] Among them, D max is the maximum achievable distance;

[0035] S205. Sort the candidate points according to the urgency and importance of the tasks, giving priority to the target points of high-priority tasks:

[0036] C i,priority =SortByPriority(C i,dist )

[0037] Among them, SortByPriority(C i,dist ) is a function that sorts candidate points according to task priority;

[0038] S206. Adjust the candidate point set by predicting potential path conflicts between agents:

[0039] C i,conflict-free ={p∈C i,priority |NoConflict(p,C -i )}

[0040] Among them, NoConflict(p,C -i ) is a Boolean function if the candidate point p is equal to the candidate point set C of other agents. -i If there is no conflict, return true;

[0041] S207: When an environmental change is detected, re-evaluate and adjust the candidate point set:

[0042] C i,env =UpdateForChanges(C i ,conflict-free,E)

[0043] Among them, UpdateForChanges(C i ,conflict-free,E) is a function that updates the candidate point set according to the environmental change E;

[0044] S208. As the state of the agent changes, the candidate point set is updated according to the new constraints:

[0045] C i,status =UpdateForStatus(C i,env ,S i )

[0046] Among them, UpdateForStatus(C i,env ,S i ) is based on the state S of agent i i Function to update the candidate point set;

[0047] S209: After optimization and dynamic adjustment, the final candidate point set is output.

[0048] Preferably, the core of the AStar algorithm is two functions: a cost function g(n) and a heuristic function h(n), and the cost row number is:

[0049] g(n)=cost(n,parent(n))

[0050] Among them, cost(n,parent(n)) represents the cost of moving from the parent node of node n to node n, and the heuristic function is:

[0051]

[0052] Among them, (x n ,y n ) and (x g ,y g ) are the coordinates of node n and the target point respectively, and the total cost is estimated as:

[0053] f(n)=g(n)+h(n)

[0054] where f(n) is the total estimated generation from the starting point through node n to the target point.

[0055] Preferably, step S3 specifically includes the following steps:

[0056] S301, set the starting point o i Add to open list, set g(o i )=0 and h(o i ) is calculated based on the target point;

[0057] S302, select the node n with the lowest f(n) value from the open list, if n is the target point g i , then the path search is completed, otherwise n is moved from the open list to the closed list, and all neighbor nodes of n are explored;

[0058] S303, for each neighbor node m, if m is not in the closed list, calculate g(m) and f(m) of m, and add m to the open list;

[0059] S304, from the target point g i Back to the starting point o i , build the path by tracking the parent node of each node, and finally perform path and time calculation. Once you find the parent node from o i to g i Calculate the total time T of the entire path path,i :

[0060]

[0061] Where time(u,v) is the travel time from node u to node v.

[0062] Preferably, step S4 specifically includes the following steps:

[0063] S401. Maintain a visit record V for each agent i and each target point j i,j ,This record tracks the number of times the agent reaches each target point, and the number of visits is updated:

[0064]

[0065] Among them, V i,j (t) represents the number of times agent i visits target point j at time t, is an indicator function, which is 1 when agent i reaches the target point j at time t, otherwise it is 0;

[0066] S402, each target point j has a preset task execution times index T req,j , represents the minimum number of visits required to complete the task, and checks the current task completion status:

[0067]

[0068] Among them, C i,j (t) indicates whether the task requirement for target point j is completed at time t;

[0069] S403, monitor the task execution of each agent i and ensure that they can meet their respective task requirements. Task execution monitoring logic:

[0070] S i (t) = ∧ j∈J C i,j (t)

[0071] Among them, S i(t) represents the logical expression of whether agent i has completed all its tasks at time t, J is the set of target points, and ∧ represents the logical AND operation;

[0072] S404. If an agent fails to complete its task, the task is re-planned according to the current state and environment. The task re-planning conditions are:

[0073]

[0074] Among them, R i (t) indicates whether the task of agent i needs to be replanned at time t;

[0075] S405. Record the total time required for each agent to complete the task:

[0076] T i,finish =min{t|S i (t) = True}

[0077] Among them, T i,finish is the earliest time that agent i can complete all its tasks.

[0078] Preferably, step S5 specifically includes the following steps:

[0079] S501, screening candidate points, the candidate point screening logic is:

[0080] C i,j ′={p∈P\{p i,last}|V i,p <T req,p}

[0081] Among them, C i,j ′ is the updated candidate point set of agent i for target point j, P is the set of all possible target points, p i,last is the target point visited by agent i, V i,p is the number of times agent i visits the target point p, T req ,p is the number of task execution requirements of target point p;

[0082] S502: Summarize the candidate point list of each agent to prepare for the next step of target point allocation:

[0083] C i ′=∪ j∈J C i,j '

[0084] Among them, C i ′ is the summary candidate point list of agent i, and J is the index set of target points;

[0085] S503, verify the reachability of the summarized candidate points to ensure that the agent can actually reach these points, reachability verification:

[0086] C i ″={p∈C i ′|isReachable(p,o i )}

[0087] Among them, C i ″ is the list of candidate points after reachability verification, isReachable(p,o i ) is a function that, if from the current position o of agent i i If there is a reachable path to the candidate point p, it returns true;

[0088] S504: Priority sorting of candidate points:

[0089] C i ″′=sort(C i ″,priorityRule)

[0090] Among them, C i ″′ is the sorted list of candidate points, sort is the sorting function, priorityRule is the rule that defines the priority of candidate points, based on distance, task urgency or other criteria;

[0091] S505, output the candidate point list output (C i ″′).

[0092] Preferably, step S6 specifically includes the following steps:

[0093] S601, for each agent i and its candidate point list C i For each point p in ″′, define a binary decision variable x i,p :

[0094]

[0095] S602, construct objective function:

[0096]

[0097] Where I is the set of agents, o i is the current position of agent i, p is the candidate point, d(o i ,p) is the distance from the current position of agent i to the candidate point p;

[0098] S603, ensure that each agent selects only one target point and satisfies other operation constraints. One-to-one selection constraint:

[0099]

[0100] It ensures that each agent i only selects from its candidate point list C i Select a target point in ″′, and optional point constraints:

[0101]

[0102] Among them, MaxPoints is the maximum number of target points that each agent can choose, usually 1;

[0103] S604. Use MILP solver to solve the model. The solving process is as follows:

[0104] Solve MILP(I,{C i ″′},{d(o i ,p)})

[0105] Where Solve MILP is the function for solving the MILP problem, I is the set of agents, {C i ″′} is the candidate point list set of the agent, {d(o i ,p)} is the distance set;

[0106] S605: Output the solution results, determine the next target point for each agent, and output the selection:

[0107]

[0108] Among them, SelectPoint is a function that determines the i,p The value of selects the target point for agent i.

[0109] Preferably, step S7 specifically includes the following steps:

[0110] S701, determine whether agent i has completed all task requirements of its current target point:

[0111]

[0112] Among them, A i,p is an indicator function. If agent i performs the task V at target point p i,p Met or exceeded the mission requirements req,p And agent i has remaining tasks R i >0, then it is 1, otherwise it is 0;

[0113] S702: If agent i has completed the task of the current target point and has remaining tasks, proceed to the next step of planning. The next step of planning conditions are:

[0114]

[0115] Among them, PlanNext(i) is a Boolean function, which is true if agent i meets the next planning condition;

[0116] S703: If agent i has completed the task of its current target point but still has remaining tasks to perform, select a transition target point:

[0117]

[0118] Among them, p next It is the intelligent agent i starting from the current position p to the next candidate point set C i The point with the shortest distance between them;

[0119] S704, after agent i reaches the transition target point, it updates its state and position o i ′=p next , where o i ′ is the updated position of agent i, and the number of remaining tasks is updated: R i ′=R i -1, where R i ′ is the number of remaining tasks after agent i is updated;

[0120] S705: If agent i still has remaining tasks, repeat the path planning process until all tasks are completed.

[0121] Preferably, step S8 specifically includes the following steps:

[0122] S801. Verify whether each target point has reached the predetermined execution index:

[0123]

[0124] Among them, V i,p represents the number of visits of agent i to target point p, T req,p is the number of task execution requirements for target point p, I is the set of agents, and P is the set of all target points;

[0125] S802, record the visit of each agent to each target point during the planning process:

[0126]

[0127] Among them, A i,p (t) is an indicator function indicating whether agent i has visited the target point p at time t;

[0128] S803. Record all verification points and transition points in order to form a complete path plan:

[0129] Path i ={o i ,p i,1 ,p i,2 ,…,p i,n ,o final,i}

[0130] Among them, Path i is the complete path of agent i, o i is the starting position, p i,j is the target point visited at time j, o final,i is the final return position;

[0131] S804, optimize the path to reduce the total moving distance or time:

[0132] OptimizedPath i =Optimize(Path i )

[0133] Among them, Optimize(Path i ) is a path optimization function;

[0134] S805: Send the optimized path to agent i to perform the task.

[0135] Compared with the prior art, the present invention has the following beneficial effects:

[0136] 1. The present invention combines mixed integer linear programming (MILP) with the heuristic algorithm AStar. MILP performs well in global optimization, while the heuristic algorithm has advantages in local search efficiency. This combination not only improves the efficiency of path planning, but also enhances the adaptability of the algorithm in dynamic environments. Compared with traditional single algorithms (such as Hybrid AStar algorithm and Dijkstra algorithm), the hybrid algorithm of the present invention can converge to the optimal solution faster when processing large-scale multi-agent systems while maintaining a high solution quality. Through simulation experiments, the method of the present invention is superior to traditional methods in key performance indicators such as path length, task completion time and calculation time.

[0137] 2. The present invention adopts a dynamic task allocation strategy. After the agent completes the current task, the system will reallocate the next task according to the real-time situation. This strategy enables the agent to flexibly respond to environmental changes and improves the flexibility and efficiency of task execution. Through simulation experiments in different scenarios, the significant advantages of the dynamic task allocation strategy in improving task completion rate and reducing path conflicts have been verified. BRIEF DESCRIPTION OF THE DRAWINGS

[0138] Figure 1 It is the pseudo code of the multi-agent path planning algorithm in the present invention.

[0139] Figure 2 This is the overall simulation result diagram of 10 target points of 4 agents in the present invention.

[0140] Figure 3 It is a graph of the path planning results for 10 target points by the agents with IDs 0 and 1 among the four agents in the present invention.

[0141] Figure 4 This is a simulation result diagram of 42 target points of 5 intelligent agents in the present invention.

[0142] Figure 5 This is a graph of the path planning results of 5 agents with id 0 for 42 target points in the present invention. DETAILED DESCRIPTION

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

[0144] Agent collaborative path planning is essentially a highly complex combinatorial optimization problem, and its difficulty lies in the dynamics and uncertainty of the problem. At every moment, a large amount of new information is input into the system, which is likely to have a fundamental impact on the existing task allocation. Mixed integer linear programming, as an effective task allocation solution, has been widely used in agent task allocation algorithms.

[0145] The present invention takes minimizing the total task completion time as the optimization goal. Considering that the speed of all agents is known, the sum of the agent's travel time is used as the optimization index. A strategy of gradually allocating target points is adopted, that is, after the agent reaches the currently planned target point, it plans the next target point and satisfies all constraints at the same time. Since each agent has task time and distance constraints, and each task point does not need to travel here after meeting the arrival number index requirements, only those target points that meet the constraints and have not yet completed the task indicators are considered in the allocation process. By constructing a cost function, the sum of the path distances between the target point and the agent is used as the optimization goal, and each agent is constrained to select a target point from the points taken into consideration, and the points not taken into consideration are not used as target points. The MILP solver is used to determine the next target point for each agent.

[0146] The present invention provides a multi-agent efficient collaborative path planning method based on mixed integer linear programming (MILP) and heuristic algorithm, including system initialization step, candidate point set expansion step, AStar algorithm path planning step, task execution monitoring step, candidate point list update step, MILP target point selection step, transition target point selection step and path planning completion step, which can efficiently plan the optimal collaborative path of each agent according to the given agent initial position, target point, obstacle area and task requirements. After setting the agent set and the target point set, the architecture of the method mainly plans and optimizes the path of the agent through the MILP optimization module and the AStar search module to obtain the final collaborative path planning solution.

[0147] The present invention proposes a multi-agent efficient collaborative path planning method, comprising the following steps:

[0148] Step S1, define the set of agents and the set of target points, as well as the initial position, speed limit, task execution number limit and task load capacity of the agents, and set the obstacle area. This step is aimed at environmental modeling and agent configuration. Describe the process of environmental modeling in detail, including the geometry, size, position of obstacles and their possible dynamic changes. In addition, consider the topological structure of the environment, such as road networks, indoor layouts, etc. Set detailed initial parameters for each agent, such as initial position, speed limit, sensor range, communication range and task load capacity. At the same time, define the dynamic model of the agent in represents the position of agent i, v i is its speed, u i is the direction vector. The specific steps include:

[0149] (1) Set the agent set A = {a1, a2, ..., a n}, target point set T = {t1, t2, …, t m}, obstacle area O;

[0150] (2) For each agent a i Set initial position Speed ​​Limit Task execution times limit and mission payload capability

[0151] Step S2: Introduce an additional set of candidate points. First, the system needs to conduct a detailed analysis of the current environment, including but not limited to the location and size of obstacles, as well as the real-time location and task status of other agents. At the same time, analyze the task requirements of each agent, including the coordinates of the target point, the minimum number of task executions, and the execution area radius. Specifically, the following steps are included:

[0152] (1) Candidate point generation. Based on the results of the environment and task analysis, the system generates a set of candidate points for each agent. Candidate points are those points that can be reached in theory and meet the task requirements. The generation process is as follows:

[0153] Ⅰ. Obstacle elimination: Eliminate those points that are inside obstacles or too close to obstacles from all potential target points.

[0154]

[0155] Among them, C i ′ is the candidate point set of agent i, is the set of all potential target points, b k represents an obstacle, and δ is the safety distance.

[0156] II. Reachability evaluation: Evaluate the reachability of each potential target point, taking into account the agent’s movement speed and the constraints of the path planning algorithm.

[0157] C i ″={p∈C i ′|PathExists(p,o i )}

[0158] Among them, PathExists(p,o i ) is a Boolean function that returns an agent i if i A feasible path to point p is returned true.

[0159] III. Task requirement matching: Ensure that the points in the candidate point set can meet the task requirements of the agent, such as the number of arrivals and the execution area.

[0160] C i,final ={p∈C i ″|T i,p ≤T req,p}

[0161] Among them, T i,p is the number of times agent i executes the task to reach the target point p, T req ,p is the required number of task executions at target point p.

[0162] (2) Candidate point optimization. After generating a preliminary set of candidate points, the system will perform optimization to reduce the agent’s computational burden and improve the efficiency of path planning:

[0163] Ⅰ. Distance priority: Prioritize candidate points that are closer to the agent’s current position to reduce movement time and energy consumption.

[0164] C i,dist ={p∈C i,final ∣d(o i ,p)≤D max}

[0165] Among them, D max is the maximum achievable distance.

[0166] Ⅱ. Task priority: Sort candidate points according to the urgency and importance of the tasks, giving priority to target points of high-priority tasks.

[0167] C i,priority =SortByPriority(C i,dist )

[0168] Among them, SortByPriority(C i,dist ) is a function that sorts candidate points according to task priority. III. Conflict avoidance: By predicting potential path conflicts between agents, the candidate point set is adjusted to reduce the possibility of conflicts.

[0169] C i,conflict-free ={p∈C i,priority |NoConflict(p,C -i )}

[0170] Among them, NoConflict(p,C -i ) is a Boolean function if the candidate point p is equal to the candidate point set C of other agents. -i Returns true if there is no conflict.

[0171] (3) Dynamic adjustment. Considering the dynamic nature of the environment, the system needs to monitor environmental changes in real time and dynamically adjust the candidate point set:

[0172] Ⅰ. Response to environmental changes: When environmental changes are detected (such as obstacle movement or new tasks), the system will re-evaluate and adjust the set of candidate points.

[0173] C i,env =UpdateForChanges(C i ,conflict-free,E)

[0174] Among them, UpdateForChanges(Ci ,conflict-free,E) is a function that updates the candidate point set according to the environmental change E.

[0175] Ⅱ. Agent state update: As the agent state changes, the system will update the candidate point set according to the new constraints.

[0176] C i,status =UpdateForStatus(C i,env ,S i )

[0177] Among them, UpdateForStatus(C i,env ,S i ) is based on the state S of agent i i A function that updates the set of candidate points.

[0178] (4) Output of candidate point set. After optimization and dynamic adjustment, the system will output the final candidate point set for use in subsequent path planning steps. The candidate point set of each agent reflects the best choice in the current environment, laying the foundation for efficient collaborative path planning.

[0179] Step S3: Use the AStar algorithm to plan the path to the target point for each agent and calculate the time required to travel along these paths. The AStar algorithm is a heuristic search algorithm used to find the shortest path from the starting point to the target point in a graph. The algorithm uses a heuristic method to estimate the distance from the current node to the target node, thereby optimizing the path search process. For each agent i, the AStar algorithm is used to start from its current position o i Plan to its target point g i The core of the algorithm is two functions: g(n) and h(n), where g(n) is the actual cost from the starting point to the current node n, and h(n) is the estimated cost from node n to the target point. The cost function is

[0180] g(n)=cost(n,parent(n))

[0181] Among them, cost(n,parent(n)) represents the cost of moving from the parent node of node n to node n. The heuristic function is

[0182]

[0183] Among them, (x n ,y n ) and (x g ,y g ) are the coordinates of node n and the target point respectively. The total cost is estimated as:

[0184] f(n)=g(n)+h(n)

[0185] Where f(n) is the total estimated cost from the starting point through node n to the target point. The following is the path search process. The AStar algorithm uses an open list to store the nodes to be explored and a closed list to store the nodes that have been explored. The specific steps are as follows:

[0186] (1) Initialization: Set the starting point o i Add to open list, set g(o i )=0 and h(o i ) is calculated based on the target point. (2) Iteration process: Select the node n with the lowest f(n) value from the open list. If n is the target point g i , then the path search is complete. Otherwise, move n from the open list to the closed list and explore all neighbor nodes of n.

[0187] (3) Neighbor node exploration: For each neighbor node m, if m is not in the closed list, calculate g(m) and f(m) of m, and add m to the open list.

[0188] (4) Path backtracking: From the target point g i Back to the starting point o i , build the path by tracking the parent node of each node. Finally, calculate the path and time. Once you find the path from o i to g i Calculate the total time T of the entire path path,i :

[0189] T path,i =∑ edges(u,v)∈path time(u,v)

[0190] Where time(u,v) is the travel time from node u to node v, which depends on the speed of the agent and the distance of the path segment. Step 3 not only ensures the accuracy and efficiency of path planning, but also provides clear guidance for the agent's path planning through explicit calculation steps. The implementation of this method significantly improves the collaborative performance of the multi-agent system and the efficiency of task execution.

[0191] Step S4: Maintain the visit record of each target point, record the time and number of times the agent arrives, and check whether the task execution number indicator is met. This step is a key step to ensure that the agent performs the task according to the established plan and meets the task requirements. It involves monitoring the agent's visits to the target points and ensuring that each target point is visited enough times to complete the task requirements. Specifically, it includes the following steps:

[0192] (1) Target point visit record. Maintain a visit record V for each agent i and each target point j i,j ,This record keeps track of the number of times the agent reaches each target point. Visit count update:

[0193]

[0194] Among them, V i,j (t) represents the number of times agent i visits target point j at time t, is an indicator function whose value is 1 when agent i reaches the target point j at time t, and 0 otherwise.

[0195] (2) Check the task execution times index. Each target point j has a preset task execution times index T req,j , represents the minimum number of visits required to complete the task. View the current task completion status:

[0196]

[0197] Among them, C i,j (t) indicates whether the task requirement for target point j is completed at time t.

[0198] (3) Agent task execution monitoring. Monitor the task execution of each agent and ensure that they can meet their respective task requirements. Task execution monitoring logic:

[0199] S i (t) = ∧ j∈J C i,j (t)

[0200] Among them, S i (t) is a logical expression indicating whether agent i has completed all its tasks at time t, J is a set of target points, and ∧ represents a logical AND operation.

[0201] (4) Task re-planning. If an agent fails to complete its task, the system will re-plan the task based on the current state and environment. Task re-planning conditions:

[0202]

[0203] Among them, R i (t) indicates whether the task of agent i needs to be replanned at time t.

[0204] (5) Task execution time record. Record the total time required for each agent to complete the task to evaluate system performance. Task completion time:

[0205] T i,finish =min{t|S i(t) = True}

[0206] Among them, T i,finish is the earliest time that agent i completes all its tasks. This step not only ensures the accuracy of monitoring and recording of task execution, but also provides clear guidance for the agent's task execution through clear logic and conditions.

[0207] Step S5: For the target points that do not meet the indicators, update the candidate point list of the agent. Among the points to be executed that have not completed the indicators, calculate the candidate points of each agent that meet the execution number limit and are different from the previous target point, and summarize the numbers of these points into a list as the candidate points for the next target allocation. Specifically, it includes the following steps.

[0208] (1) Candidate point screening conditions. In this step, it is necessary to update the candidate point list for each agent to ensure that the agent can efficiently plan its next path. The candidate point screening logic is:

[0209] C i,j ′={p∈P\{p i,last}|V i,p <T req,p}

[0210] Among them, C i,j ′ is the updated candidate point set of agent i for target point j, P is the set of all possible target points, p i,last is the target point visited by agent i, V i,p is the number of times agent i visits the target point p, T req ,p is the required number of task executions at target point p.

[0211] (2) Summary of candidate point lists. Summarize the candidate point lists of each agent to prepare for the next step of target point allocation:

[0212] C i ′=∪ j∈J C i,j '

[0213] Among them, C i ′ is the summary candidate point list of agent i, and J is the index set of target points.

[0214] (3) Verification of the reachability of candidate points. After compiling the list of candidate points, it is necessary to verify the reachability of these candidate points to ensure that the agent can actually reach these points.

[0215] C i ″={p∈C i ′|isReachable(p,o i )}

[0216] Among them, C i ″ is the list of candidate points after reachability verification, isReachable(p,o i ) is a function that, if from the current position o of agent i i Returns true if there is a reachable path to the candidate point p.

[0217] (4) Priority sorting of candidate points. In order to optimize the path planning process, candidate points are sorted according to certain priority rules. Priority sorting:

[0218] C i ″′=sort(C i ″,priorityRule)

[0219] Among them, C i ″′ is the sorted list of candidate points, sort is the sorting function, and priorityRule is the rule that defines the priority of candidate points based on distance, task urgency or other criteria.

[0220] (5) Output of candidate point list. Finally, the candidate point list of each agent is output for use in the subsequent path planning steps. The candidate point list is output (C i ″′), where the output function is responsible for outputting the final candidate point list C of agent i i This not only ensures the accuracy of updating and summarizing the candidate point list, but also verifies reachability and prioritizes them.

[0221] Step S6, construct a 0-1 matrix to represent the selection relationship between the agent and the candidate point, and construct the objective function as the sum of the distances from all agents to their selected target points, and use the MILP solver to minimize the objective function and satisfy the constraints. Select the target point that each agent will reach next from the candidate point list, ensuring that each agent only selects one target point. Use a matrix composed of 0 and 1 to mathematically express this constraint; set the sum of the distances from all agents to their target points as the objective function, and then solve it through the MILP solver. Specifically, it includes the following steps:

[0222] (1) Define decision variables. For each agent i and its candidate point list C i For each point p in ″′, define a binary decision variable x i,p . Decision variables:

[0223]

[0224] (2) Construct the objective function. The goal is to minimize the sum of the distances of all agents to their selected target points, which can be expressed by the following objective function:

[0225]

[0226] Where I is the set of agents, o i is the current position of agent i, p is the candidate point, d(o i ,p) is the distance from the current position of agent i to the candidate point p.

[0227] (3) Constraints. Ensure that each agent selects only one target point and satisfies other operation constraints. One-to-one selection constraint:

[0228]

[0229] This ensures that each agent i only selects from its candidate point list C i Select a target point in ″′. Optional point constraints:

[0230]

[0231] Among them, MaxPoints is the maximum number of target points that each agent can choose, usually 1.

[0232] (4) Model solution. Use a mixed integer linear programming solver to solve the above model and find the optimal target point selection solution. Solution process:

[0233] Solve MILP(I,{C i ″′},{d(o i ,p)})

[0234] Where Solve MILP is the function for solving the MILP problem, I is the set of agents, {C i ″′} is the candidate point list set of the agent, {d(o i ,p)} is a distance set.

[0235] (5) Output the selection results. Output the solution results and determine the next target point for each agent. Output selection:

[0236]

[0237] Among them, SelectPoint is a function that determines the i,p The value of selects the target point for agent i. This not only ensures the optimization of target point selection and the accuracy of decision-making, but also provides an efficient solution for the path planning of the agent through the application of the MILP model.

[0238] Step S7: When any agent first reaches the target point of the current plan, if the execution index of the point has been completed and the number of remaining task executions of the agent is not zero, it will directly enter the next step of planning. If the agent still has remaining tasks to execute, it will select a point different from the previous target point and closest to it as the transition target. Specifically, it includes the following steps:

[0239] (1) Determine the completion of the target task. First, it is necessary to determine whether the agent has completed all the task requirements of its current target. Task completion judgment:

[0240]

[0241] Among them, A i,p is an indicator function. If agent i performs the task V at target point p i,p Met or exceeded the mission requirements req,p And agent i has remaining tasks R i >0, then it is 1, otherwise it is 0.

[0242] (2) The next step planning of the agent. If the agent has completed the task of the current target point and there are still tasks left, it needs to immediately proceed to the next step planning. Next step planning conditions

[0243]

[0244] Among them, PlanNext(i) is a Boolean function that is true if agent i satisfies the next planning condition.

[0245] (3) Select a transition target point. If the agent has completed the task of its current target point but still has remaining tasks to perform, it needs to select a transition target point:

[0246]

[0247] Among them, p next It is the intelligent agent i starting from the current position p to the next candidate point set C i The point with the shortest distance.

[0248] (4) Update the agent state. After the agent reaches the transition target point, it needs to update its state, including its position, remaining task times, etc. i ′=p next , where o i ′ is the updated position of agent i. Update the number of remaining tasks:

[0249] R i ′=R i -1

[0250] Among them, R i ′ is the number of remaining tasks after agent i is updated.

[0251] (5) Repeat path planning. If agent i still has remaining tasks, repeat the path planning process until all tasks are completed. Repeat path planning:

[0252]

[0253] This step provides clear guidance for the agent's transition target point selection and state update.

[0254] Step S8: Continuously update and record the target point allocation of each agent until the execution indicators of all target points are met to form a complete path planning. Specifically, the following steps are included:

[0255] (1) Verify the target point execution index. Before forming the final path, it is necessary to verify whether each target point has achieved the predetermined execution index.

[0256]

[0257] Among them, V i,p represents the number of visits of agent i to target point p, T req,p is the required number of task executions for target point p, I is the set of agents, and P is the set of all target points.

[0258] (2) Record the target point allocation. Record the visits of each agent to each target point during the planning process.

[0259]

[0260] Among them, A i,p (t) is an indicator function indicating whether agent i has visited the target point p at time t.

[0261] (3) Form a complete path plan. Record all verification points and transition points in order to form a complete path plan.

[0262] Path i ={o i ,p i,1 ,p i,2 ,…,p i,n ,o final,i}

[0263] Among them, Path i is the complete path of agent i, o i is the starting position, p i,j is the target point visited at time j, o final,iis the final return location.

[0264] (4) Path optimization: After forming a complete path, it may be necessary to optimize the path to reduce the total moving distance or time.

[0265] OptimizedPath i =Optimize(Path i )

[0266] Among them, Optimize(Path i ) is a path optimization function used to reduce the total length or total time of the path.

[0267] (5) Path execution. Finally, the optimized path is sent to the agent to execute the task: Execute(OptimizedPath i ), which is an execution function. Agent i follows the optimized path OptimizedPath i Execute the task. The last step not only ensures that the execution indicators of all target points are met, but also provides an efficient and accurate execution path for the agent by recording and optimizing the path.

[0268] Based on the present invention, the algorithm is tested and analyzed, and the algorithm pseudo code is as follows: Figure 1 As shown, and proceed as follows:

[0269] (1) Collect key performance indicators, such as path length, task completion time, and computation time.

[0270] (2) Analyze data, evaluate the effectiveness and efficiency of the algorithm, and identify optimization space.

[0271] Table 1 shows the input information of 10 target points of 4 agents.

[0272] Table 1

[0273]

[0274] The results of the simulation task of 4 agents planning paths for 10 target points on the computer are as follows: Figure 2 As shown in the figure, the path planning results of the agents with IDs 0 and 1 are as follows Figure 3 The simulation results of the path planning task of 5 agents for 42 target points on the computer are shown in Figure 4 As shown in the figure, the path planning result of the agent with agent ID 0 is as follows Figure 5 The simulation results of each algorithm are shown in Table 2.

[0275] Table 2

[0276]

[0277] Compared with other single traditional algorithms, the method of the present invention significantly improves the collaborative performance of the multi-agent system and the efficiency of task execution, greatly shortens the completion time of multi-agent collaborative tasks, and can also achieve 100% completion rate for multi-target points and multi-task situations.

[0278] Although the present invention is described herein with reference to specific embodiments, it should be understood that these embodiments are merely examples of the principles and applications of the present invention. It should therefore be understood that many modifications may be made to the exemplary embodiments and that other arrangements may be devised without departing from the spirit and scope of the present invention as defined by the appended claims. It should be understood that the various dependent claims and features described herein may be combined in a manner different from that described in the original claims. It should also be understood that features described in conjunction with individual embodiments may be used in other described embodiments.

Claims

1. A multi-agent efficient collaborative path planning method, characterized in that: The following steps are involved: S1. Define the set of intelligent agents and target points, as well as the initial position, speed limit, task execution number limit and task load capacity of the intelligent agents, and set the obstacle area; S2, introducing an additional set of candidate points; S3, use the AStar algorithm to plan the path to each agent's goal point and calculate the time required to travel along these paths; S4, maintain the visit record of each target point, record the time and number of times the agent arrives, and check whether the task execution number indicator is met; S5. For the target points that do not meet the indicators, update the candidate point list of the agent; S6. Construct a 0-1 matrix to represent the selection relationship between the agent and the candidate point, and construct the objective function as the sum of the distances from all agents to their selected target points. Use the MILP solver to minimize the objective function and satisfy the constraints. S7, when any agent first reaches the target point of the current plan, if the execution indicator of the point has been completed and the number of remaining task executions of the agent is not zero, it will directly enter the next step of planning. If the agent still has remaining tasks to execute, it will select a point different from the previous target point and closest to it as the transition target; S8. Continuously update and record the target point allocation of each agent until the execution indicators of all target points are met to form a complete path planning.

2. The multi-agent efficient collaborative path planning method according to claim 1 is characterized in that: Step S1 specifically includes the following steps: S101, set the agent set A = {a1, a2, ..., a n }, target point set T = {t1, t2, …, t m }, obstacle area O; S102, for each intelligent agent a i Set initial position Speed ​​Limit Task execution times limit E ai and mission payload capability 3. The multi-agent efficient collaborative path planning method according to claim 1 is characterized in that: The step S2 specifically includes the following steps: S201. Exclude from all potential target points those points that are inside obstacles or too close to obstacles: Among them, C i ′ is the candidate point set of agent i, is the set of all potential target points, b k represents obstacles, δ is the safety distance; S202. Evaluate the accessibility of each potential target point: C i ″={p∈C i ′∣PathExists(p,o i )} Among them, PathExists(p,o i ) is a Boolean function that returns an agent i if i A feasible path to point p, returns true; S203: Ensure that the points in the candidate point set can meet the agent's task requirements, such as the number of arrivals and execution area: C i,final ={p∈C i ″∣T i,p ≤T req,p } Among them, T i,p is the number of times agent i executes the task to reach the target point p, T req, p is the number of times the task execution is required at the target point p; S204, optimize the initially generated candidate point set, and give priority to candidate points that are closer to the current position of the agent to reduce movement time and energy consumption: C i,dist ={p∈C i,final ∣d(o i ,p)≤D max } Among them, D max is the maximum achievable distance; S205. Sort the candidate points according to the urgency and importance of the tasks, giving priority to the target points of high-priority tasks: C i,priority =SortByPriority(C i,dist ) Among them, SortByPriority(C i,dist ) is a function that sorts candidate points according to task priority; S206. Adjust the candidate point set by predicting potential path conflicts between agents: C i,conflict-free ={p∈C i,priority ∣NoConflict(p,C -i )} Among them, NoConflict(p,C -i ) is a Boolean function if the candidate point p is equal to the candidate point set C of other agents. -i If there is no conflict, return true; S207: When an environmental change is detected, re-evaluate and adjust the candidate point set: C i,env =UpdateForChanges(C i ,conflict-free,E) Among them, UpdateForChanges(C i ,conflict-free,E) is a function that updates the candidate point set according to the environmental change E; S208. As the state of the agent changes, the candidate point set is updated according to the new constraints: C i,status =UpdateForStatus(C i,env ,S i ) Among them, UpdateForStatus(C i,env ,S i ) is based on the state S of agent i i Function to update the candidate point set; S209: After optimization and dynamic adjustment, the final candidate point set is output.

4. The method for efficient multi-agent collaborative path planning according to claim 1, characterized in that: The core of the AStar algorithm is two functions: cost function g(n) and heuristic function h(n). The cost row number is: g(n)=cost(n,parent(n)) Among them, cost(n,parent(n)) represents the cost of moving from the parent node of node n to node n, and the heuristic function is: Among them, (x n ,y n ) and (x g ,y g ) are the coordinates of node n and the target point respectively, and the total cost is estimated as: f(n)=g(n)+h(n) where f(n) is the total estimated generation from the starting point through node n to the target point.

5. The multi-agent efficient collaborative path planning method according to claim 4 is characterized in that: Step S3 specifically includes the following steps: S301, set the starting point o i Add to open list, set g(o i )=0 and h(o i ) is calculated based on the target point; S302, select the node n with the lowest f(n) value from the open list, if n is the target point g i , then the path search is completed, otherwise n is moved from the open list to the closed list, and all neighbor nodes of n are explored; S303, for each neighbor node m, if m is not in the closed list, calculate g(m) and f(m) of m, and add m to the open list; S304, from the target point g i Back to the starting point o i , build the path by tracking the parent node of each node, and finally perform path and time calculation. Once you find the parent node from o i to g i Calculate the total time T of the entire path path,i : Where time(u,v) is the travel time from node u to node v.

6. The multi-agent efficient collaborative path planning method according to claim 1 is characterized in that: Step S4 The specific steps include: S401. Maintain a visit record V for each agent i and each target point j i,j ,This record tracks the number of times the agent reaches each target point, and the number of visits is updated: V i,j (t)=V i,j (t-1)+1 {oi(t)＝pj} Among them, V i,j (t) represents the number of times agent i visits target point j at time t, is an indicator function, which is 1 when agent i reaches the target point j at time t, otherwise it is 0; S402, each target point j has a preset task execution times index T req,j , represents the minimum number of visits required to complete the task, and checks the current task completion status: Among them, C i,j (t) indicates whether the task requirement for target point j is completed at time t; S403, monitor the task execution of each agent i and ensure that they can meet their respective task requirements. Task execution monitoring logic: S i (t)=∧ j∈J C i,j (t) Among them, S i (t) represents the logical expression of whether agent i has completed all its tasks at time t, J is the set of target points, and ∧ represents the logical AND operation; S404. If an agent fails to complete its task, the task is re-planned according to the current state and environment. The task re-planning conditions are: Among them, R i (t) indicates whether the task of agent i needs to be replanned at time t; S405. Record the total time required for each agent to complete the task: T i,finish =min{t∣S i (t)=True} Among them, T i,finish is the earliest time that agent i can complete all its tasks.

7. The method for efficient multi-agent collaborative path planning according to claim 6, characterized in that: Step S5 specifically includes the following steps: S501, screening candidate points, the candidate point screening logic is: C i,j ′={p∈P\{p i,last }∣V i,p <T req,p } Among them, C i,j ′ is the updated candidate point set of agent i for target point j, P is the set of all possible target points, p i,last is the target point visited by agent i, V i,p is the number of times agent i visits the target point p, T req, p is the number of times the task execution is required at the target point p; S502: Summarize the candidate point list of each agent to prepare for the next step of target point allocation: C i ′=∪ j∈J C i,j ′ Among them, C i ′ is the summary candidate point list of agent i, and J is the index set of target points; S503, verify the reachability of the summarized candidate points to ensure that the agent can actually reach these points, reachability verification: C i ″={p∈C i ′∣isReachable(p,o i )} Among them, C i ″ is the list of candidate points after reachability verification, isReachable(p,o i ) is a function that, if from the current position o of agent i i If there is a reachable path to the candidate point p, it returns true; S504: Priority sorting of candidate points: C i ″′=sort(C i ″,priorityRule) Among them, C i ″′ is the sorted list of candidate points, sort is the sorting function, priorityRule is the rule that defines the priority of candidate points, based on distance, task urgency or other criteria; S505, output the candidate point list output (C i ″′).

8. The multi-agent efficient collaborative path planning method according to claim 1 is characterized in that: Step S6 specifically includes the following steps: S601, for each agent i and its candidate point list C i For each point p in ″′, define a binary decision variable x i,p : S602, construct objective function: Where I is the set of agents, o i is the current position of agent i, p is the candidate point, d(o i ,p) is the distance from the current position of agent i to the candidate point p; S603, ensure that each agent selects only one target point and satisfies other operation constraints. One-to-one selection constraint: It ensures that each agent i only selects from its candidate point list C i Select a target point in ″′, and optional point constraints: Among them, MaxPoints is the maximum number of target points that each agent can choose, usually 1; S604. Use MILP solver to solve the model. The solving process is as follows: Solve MILP(I,{C i ″′},{d(o i ,p)}) Where Solve MILP is the function for solving the MILP problem, I is the set of agents, {C i ″′} is the candidate point list set of the agent, {d(o i ,p)} is the distance set; S605: Output the solution results, determine the next target point for each agent, and output the selection: Among them, SelectPoint is a function that determines the i,p The value of selects the target point for agent i.

9. The multi-agent efficient collaborative path planning method according to claim 1, characterized in that: Step S7 specifically includes the following steps: S701, determine whether agent i has completed all task requirements of its current target point: Among them, A i,p is an indicator function. If agent i performs the task V at target point p i,p Met or exceeded the mission requirements req,p And agent i has remaining tasks R i >0, then it is 1, otherwise it is 0; S702: If agent i has completed the task of the current target point and has remaining tasks, proceed to the next step of planning. The next step of planning conditions are: Among them, PlanNext(i) is a Boolean function, which is true if agent i meets the next planning condition; S703: If agent i has completed the task of its current target point but still has remaining tasks to perform, select a transition target point: Among them, p next It is the intelligent agent i starting from the current position p to the next candidate point set C i The point with the shortest distance between them; S704, after agent i reaches the transition target point, it updates its state and position o i ′=p next , where o i ′ is the updated position of agent i, and the number of remaining tasks is updated: R i ′=R i -1, where R i ′ is the number of remaining tasks after agent i is updated; S705: If agent i still has remaining tasks, repeat the path planning process until all tasks are completed.

10. The multi-agent efficient collaborative path planning method according to claim 1, characterized in that: Step S8 specifically includes the following steps: S801. Verify whether each target point has reached the predetermined execution index: Among them, V i,p represents the number of visits of agent i to target point p, T req,p is the number of task execution requirements for target point p, I is the set of agents, and P is the set of all target points; S802, record the visit of each agent to each target point during the planning process: Among them, A i,p (t) is an indicator function indicating whether agent i has visited the target point p at time t; S803. Record all verification points and transition points in order to form a complete path plan: Path i ={o i ,p i,1 ,p i,2 ,…,p i,n ,o final,i } Among them, Path i is the complete path of agent i, o i is the starting position, p i,j is the target point visited at time j, o final,i is the final return position; S804, optimize the path to reduce the total moving distance or time: OptimizedPath i =Optimize(Path i ) Among them, Optimize(Path i ) is a path optimization function; S805: Send the optimized path to agent i to perform the task.

Images