A Multi-Agent Efficient Cooperative Path Planning Method

Abstract

This invention relates to the field of multi-agent cooperative planning technology, specifically disclosing an efficient multi-agent cooperative path planning method. The method includes system initialization, candidate point set expansion, AStar algorithm path planning, task execution monitoring, candidate point list updating, MILP target point selection, transition target point selection, and path planning completion. This invention comprehensively considers factors such as the task area, the agent's initial position, speed limits, target position coordinates, obstacle areas, and minimum execution count to plan the optimal path for each agent. Through reasonable task allocation and obstacle avoidance strategies, it ensures that the agents can efficiently and safely complete the predetermined task, outperforming traditional methods in key performance indicators such as path length, task completion time, and computation time.

Description

Technical Field

[0001] This invention relates to the field of multi-agent cooperative planning technology, specifically to a method for efficient multi-agent cooperative path planning. Background Technology

[0002] Multi-agent cooperative path planning is a problem of planning paths for multiple agents. The main constraint is that multiple agents simultaneously moving along a pre-planned path can complete the task efficiently and safely without conflict. Multi-agent cooperative path planning has numerous applications in various fields, such as logistics scheduling, drone collaborative operations, automated management of large warehouses, 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 cooperative path planning is increasing. However, the dynamic changes in the environment and the increasing number of agents pose significant challenges to multi-agent cooperative path planning.

[0003] Despite significant progress in this field in recent years, several challenges remain:

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

[0005] (2) Secondly, when planning a path, an agent needs to consider not only its own action constraints but also the collision avoidance problem with other agents. As the number of agents increases, the number of collision avoidance constraints grows exponentially, leading to a sharp increase in the complexity of solving the problem.

[0006] (3) In addition, in specific application scenarios, such as automated monitoring or emergency response tasks, agents not only need to avoid obstacle areas, but also need to efficiently allocate tasks and cooperate to complete them. How agents can quickly and accurately reach the designated task point and execute the task while keeping the path shortest and the efficiency highest is a major challenge in current collaborative path planning.

[0007] Therefore, in view of this, the present invention proposes a multi-agent efficient cooperative path planning method to make up for and improve the shortcomings of the existing technology. Summary of the Invention

[0008] To address the issues of high computational complexity and low task completion efficiency in multi-agent collaboration, this invention proposes a multi-agent cooperative path planning method that combines Mixed Integer Linear Programming (MILP) with the AStar heuristic algorithm. This method comprehensively considers factors such as the task area, the agents' initial positions, speed constraints, target coordinates, obstacle areas, and the minimum number of executions metric to plan the optimal path for each agent. Through reasonable task allocation and obstacle avoidance strategies, it ensures that the agents can complete the predetermined task efficiently and safely.

[0009] To achieve the above objectives, this invention provides a multi-agent efficient cooperative path planning method, comprising the following steps:

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

[0011] S2. Introduce an additional set of candidate points;

[0012] 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;

[0013] S4. Maintain access records for each target point, record the time and number of times the agent arrives, and check whether the task execution count is met.

[0014] S5. For target points that do not meet the criteria, 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 target of the point has been completed and the remaining number of task executions of the agent is not zero, then directly proceed to the next planning step. If the agent still has remaining tasks to execute, select the nearest point that is different from the previous target point as the transition target.

[0017] S8. Continuously update and record the target point allocation for each agent until the execution indicators of all target points are met, forming a complete path plan.

[0018] Preferably, in the root node initialization of the high-level conflict detection algorithm in step S1, an empty node without spatiotemporal 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. Define a set of intelligent agents A = {a1, a2, ..., a...} n The target point set T = {t1, t2, ..., t} m}, obstacle area O;

[0021] S102, for each agent a i Set initial position P ai Speed ​​limit V ai Task execution count limit E ai and mission payload capacity L aj .

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

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

[0024]

[0025] Among them, C i ′ is the set of candidate points for agent i. It is the set of all potential target points, b k This represents an obstacle, and δ is the safe distance.

[0026] S202. Evaluate the reachability 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 evaluates to the value at the current position o of agent i if there exists a value at o. i If there is a feasible path to point p, return true;

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

[0030] C i,final ={p∈C i "∣T i,p ≤T req,p}

[0031] Among them, T i,p T is the number of times agent i reaches the target point p. reqp represents the number of times the task needs to be executed at the target point p;

[0032] S204. Optimize the initially generated candidate point set, prioritizing candidate points that are closer to the agent's current position 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 It is the maximum reachable distance;

[0035] S205. Based on the urgency and importance of the tasks, rank the candidate points, 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 that evaluates candidate point p to other candidate point sets C of other agents. -i If there is no conflict, return true;

[0041] S207. When environmental changes are detected, the candidate point set is reassessed and adjusted:

[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 set of candidate points based on environmental changes E;

[0044] S208. As the agent's state changes, update the candidate point set 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 A function to update the set of candidate points;

[0047] S209. After optimization and dynamic adjustment, output the final set of candidate points.

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

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

[0050] Where 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 The coordinates of node n and the target point are respectively, and the total cost is estimated as follows:

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

[0054] Where f(n) is the total estimated number of nodes from the starting point to the target point through node n.

[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 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 If the path search is successful, then the path search is complete; otherwise, move n from the open list to the closed list and explore all of n's neighboring nodes.

[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 target point g i Backtracking to the starting point o i The path is constructed by tracing the parent node of each node, and finally, path and time calculations are performed. Once the path from node o is found... i to g i Calculate the total time T for 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 an access 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 visit count is updated accordingly.

[0064]

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

[0066] S402. Each target point j has a preset task execution count index T. req,j , indicates the minimum number of accesses required to complete the task. Check the current task completion status:

[0067]

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

[0069] S403. Monitor the task execution status 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 for 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, re-plan the task based on the current state and environment. The conditions for task re-planning 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 It is the earliest time when agent i completes all its tasks.

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

[0079] S501. Filter candidate points. The candidate point filtering logic is as follows:

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

[0081] Among them, C i,j Let ' be the updated set of candidate points for agent i in relation to target point j, and P be the set of all possible target points. i,last V is the target point visited by agent i. i,p T is the number of times agent i visits the target point p. req p represents the number of times the task needs to be executed at the target point p;

[0082] S502. Summarize the candidate point list for 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 the target point;

[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 a list of candidate points after reachability verification, isReachable(p,o i ) is a function that calculates the value of an agent i from its current position o. i If a reachable path exists to candidate point p, return true;

[0088] S504. Priority ranking 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, and 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 for each agent: 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 the objective function:

[0096]

[0097] Where I is the set of agents, o i d(o) is the current position of agent i, p is a candidate point, and d(o) is the current position of agent i. 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 operational constraints. One-to-one selection constraint:

[0099]

[0100] This ensures that each agent i selects only from its candidate point list C. i Select a target point from the "′" field. Optional point constraints:

[0101]

[0102] MaxPoints is the maximum number of target points that each agent can choose, which is usually 1.

[0103] S604. Solve the model using the MILP solver. Solution process:

[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, and {C} i "′" is the set of candidate points for 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 select the output option:

[0107]

[0108] Here, SelectPoint is a function that, based on the decision variable x i,p The value is the target point selected by agent i.

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

[0110] S701. Determine whether agent i has completed all task requirements for its current target point:

[0111]

[0112] Among them, A i,p It is an indicator function, representing the number of times agent i performs its task at target point p, V. i,p The task requirement T has been met or exceeded. req,p Furthermore, agent i still has remaining tasks R. i If the value is greater than 0, then it is 1; otherwise, it is 0.

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

[0114]

[0115] PlanNext(i) is a Boolean function that is true if agent i satisfies the conditions for the next planning step.

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

[0117]

[0118] Where, p next It refers to the process by which agent i starts from its current position p and moves to the next set of candidate points C. i "The point with the shortest distance;"

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

[0120] S705. If agent i still has tasks remaining, 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 achieved the predetermined performance indicators:

[0123]

[0124] Among them, V i,p T represents the number of times agent i visits the target point p. req,p I is the number of times the task needs to be executed at target point p, I is the set of agents, and P is the set of all target points.

[0125] S802. Record the access status of each agent to each target point during the planning process:

[0126]

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

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

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

[0130] Where, Path i It is the complete path of agent i, o i It is the starting position, p i,j The target point visited at time j, o final,i This is the final return location;

[0131] S804. Optimize the route to reduce the total travel 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 execute the task.

[0135] Compared with the prior art, the beneficial effects of the present invention are:

[0136] 1. This invention combines Mixed Integer Linear Programming (MILP) with the heuristic algorithm AStar. MILP excels in global optimization, while heuristic algorithms are superior in local search efficiency. This combination not only improves the efficiency of path planning but also enhances the algorithm's adaptability in dynamic environments. Compared to traditional single algorithms (such as Hybrid AStar and Dijkstra's algorithm), the hybrid algorithm of this invention can converge to the optimal solution faster while maintaining high solution quality when dealing with large-scale multi-agent systems. Simulation experiments show that the method of this invention outperforms traditional methods in key performance indicators such as path length, task completion time, and computation time.

[0137] 2. This invention employs a dynamic task allocation strategy. After the agent completes its current task, the system reassigns the next task based on real-time conditions. This strategy enables the agent to flexibly respond to environmental changes, improving the flexibility and efficiency of task execution. Simulation experiments in different scenarios have verified the significant advantages of the dynamic task allocation strategy in improving task completion rate and reducing path conflicts. Attached Figure Description

[0138] Figure 1 This is the pseudocode of the multi-agent path planning algorithm in this invention.

[0139] Figure 2 This is a diagram showing the overall simulation results of 4 intelligent agents and 10 target points in this invention.

[0140] Figure 3 This is a path planning result diagram of 10 target points for the four intelligent agents with ID numbers 0 and 1 in this invention.

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

[0142] Figure 5 This is a path planning result diagram of 42 target points for 5 intelligent agents with ID 0 in this invention. Detailed Implementation

[0143] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0144] Cooperative path planning for intelligent agents is essentially a highly complex combinatorial optimization problem, its difficulty lying in its dynamic and uncertain nature. At every moment, a large amount of new information is input into the system, which can fundamentally impact existing task allocation. Mixed-integer linear programming, as an effective task allocation solution, has been widely applied in intelligent agent task allocation algorithms.

[0145] This invention aims to minimize the total task completion time. Considering the known speeds of all agents, the sum of their travel times is used as the optimization metric. A step-by-step target point allocation strategy is employed: an agent plans its next target point only after reaching the currently planned target point, while simultaneously satisfying all constraints. Since each agent is constrained by task time and distance, and each task point no longer needs to be visited after meeting the required number of visits, the allocation process only considers target points that meet the constraints but whose task targets have not yet been met. A cost function is constructed, using the sum of path distances between the target point and the agent as the optimization objective. Each agent is constrained to select one target point from the considered points; points not considered are not considered as target points. The next target point for each agent is determined using a MILP solver.

[0146] This invention provides a multi-agent efficient cooperative path planning method based on Mixed Integer Linear Programming (MILP) and heuristic algorithms. The method includes system initialization, candidate point set expansion, AStar algorithm path planning, task execution monitoring, candidate point list updating, MILP target point selection, transition target point selection, and path planning completion. It can efficiently plan the optimal cooperative path for each agent based on given initial agent positions, target points, obstacle areas, and task requirements. After setting the agent set and target point set, the method primarily uses a MILP optimization module and an AStar search module to plan and optimize the agents' paths to obtain the final cooperative path planning scheme.

[0147] This invention proposes a multi-agent efficient cooperative 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 positions, speed limits, task execution limit, and task payload capacity of the agents, and simultaneously define the obstacle area. This step aims to perform environmental modeling and agent configuration. The environmental modeling process is described in detail, including the geometry, size, location, and possible dynamic changes of obstacles. Furthermore, the topology of the environment, such as road networks and indoor layouts, is considered. Detailed initial parameters are set for each agent, such as initial position, speed limit, sensor range, communication range, and task payload capacity. Simultaneously, the dynamic model of the agent is defined. in v represents the position of agent i. i It is its speed, u i It is a direction vector. The specific steps include:

[0149] (1) Define the set of intelligent agents A = {a1, a2, ..., a3} n The 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 limit and mission payload capacity

[0151] Step S2: Introduce an additional candidate point set. First, the system needs to perform 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. Simultaneously, it analyzes the task requirements of each agent, including the coordinates of the target point, the minimum number of task executions, and the radius of the execution area. Specifically, this includes the following steps:

[0152] (1) Candidate Point Generation. Based on the results of environment and task analysis, the system generates a set of candidate points for each agent. Candidate points are those points that are theoretically reachable and meet the task requirements. The generation process is as follows:

[0153] I. Obstacle Removal: Eliminate points from all potential target points that are located inside or too close to obstacles.

[0154]

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

[0156] II. Reachability Assessment: 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 evaluates to the value at the current position o of agent i if there exists a value at o. i If a feasible path to point p is found, return true.

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

[0160] C i,final ={p∈C i "∣T i,p ≤T req,p}

[0161] Among them, T i,p T is the number of times agent i reaches the target point p. req p represents the number of times the task needs to be executed at the target point p.

[0162] (2) Candidate point optimization. After generating an initial set of candidate points, the system will optimize the process to reduce the computational burden on the agent and improve the efficiency of path planning:

[0163] I. Distance Priority: Prioritize candidate points that are closer to the agent's current location to reduce travel time and energy consumption.

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

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

[0166] II. Task Priority: Candidate points are ranked according to the urgency and importance of the tasks, with priority given 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 set of candidate points is adjusted to reduce the likelihood 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 that evaluates candidate point p to other candidate point sets C of other agents. -i If there is no conflict, return true.

[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 the movement of obstacles or the emergence of 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 set of candidate points based on environmental changes E.

[0175] II. Agent State Update: As the agent's 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 to update the set of candidate points.

[0178] (4) Candidate point set output. 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 under the current environment, laying the foundation for efficient collaborative path planning.

[0179] Step S3: Use the AStar algorithm to plan paths 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 plan the path from its current position o. i Planning to its target point g i The core of the algorithm consists of 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] Where 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 Let be the coordinates of node n and the target point, respectively. The total cost is estimated as follows:

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

[0185] Where f(n) is the estimated total cost from the starting point through node n to the target point. The following describes the path search process. The AStar algorithm uses an open list to store nodes to be explored and a closed list to store already explored nodes. 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 (2) Iterative process: Select the node n with the lowest f(n) value from the open list. If n is the target point g i If the pathfinding is successful, the pathfinding is complete. Otherwise, move n from the open list to the closed list and explore all of n's neighboring nodes.

[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 Backtracking to the starting point o i The path is constructed by tracing the parent node of each node. Finally, path and time calculations are performed. Once the path from node o is found... i to g i Calculate the total time T for the entire path. path,i :

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

[0190] Here, time(u,v) is the travel time from node u to node v, which depends on the agent's speed 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 computational steps. The implementation of this method significantly improves the collaborative performance and task execution efficiency of multi-agent systems.

[0191] Step S4: Maintain access records for each target point, recording the time and number of times the agent arrives, and check whether the task execution count meets the target point requirement. This step is crucial to ensuring that the agent executes the task according to the predetermined plan and meets the task requirements. It involves monitoring the agent's access to target points and ensuring that each target point is accessed a sufficient number of times to complete the task requirements. Specifically, it includes the following steps:

[0192] (1) Target point access record. An access record V is maintained for each agent i and each target point j. i,j This record tracks 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. It is an indicator function, with a value of 1 when agent i reaches target point j at time t, and 0 otherwise.

[0195] (2) View the task execution count metric. Each target point j has a preset task execution count metric T. req,j This indicates the minimum number of accesses 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 has been completed at time t.

[0198] (3) Agent Task Execution Monitoring. Monitor the task execution status of each agent and ensure that they 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) represents the logical expression for whether agent i has completed all its tasks at time t, J is the set of target points, and ∧ represents the logical AND operation.

[0201] (4) Task rescheduling. If an agent fails to complete its task, the system will rescheduling the task based on the current state and environment. Conditions for task rescheduling:

[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 Recording. 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 This is the earliest time when agent i completes all its tasks. This step not only ensures the accuracy of task execution monitoring and recording, but also provides clear guidance for the agent's task execution through explicit logic and conditions.

[0207] Step S5: For target points that do not meet the criteria, update the candidate point list for the agents. Among the unexecuted points with unmet criteria, calculate the candidate points for each agent that meet the execution limit and are different from the previous target point. Summarize the numbers of these points into a list as candidate points for the next target allocation step. This includes the following steps.

[0208] (1) Candidate point selection criteria. In this step, each agent needs to update its candidate point list to ensure that the agent can efficiently plan its next path. The candidate point selection logic is as follows:

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

[0210] Among them, C i,j Let ' be the updated set of candidate points for agent i in relation to target point j, and P be the set of all possible target points. i,last V is the target point visited by agent i. i,p T is the number of times agent i visits the target point p. req p represents the number of times the task needs to be executed at the target point p.

[0211] (2) Candidate point list summary. Summarize the candidate point list for 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 list of candidate points for agent i, and J is the set of indices of the target point.

[0214] (3) Reachability verification 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. Reachability verification:

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

[0216] Among them, C i " is a list of candidate points after reachability verification, isReachable(p,o i ) is a function that calculates the value of an agent i from its current position o. i If a reachable path exists to candidate point p, return true.

[0217] (4) Priority ranking of candidate points. To optimize the path planning process, candidate points are ranked according to certain priority rules. Priority ranking:

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

[0219] Among them, C i "′" represents 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) Candidate Point List Output. The final output is a candidate point list for each agent, used in subsequent path planning steps. The candidate point list is output as 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 accessibility and prioritizes the data.

[0221] Step S6: Construct a 0-1 matrix to represent the selection relationship between the agent and candidate points, and construct the objective function as the sum of distances from all agents to their chosen target points. Minimize the objective function and satisfy the constraints using the MILP solver. For each agent, select the target point to reach next from the candidate point list, ensuring that each agent selects only one target point. This constraint is mathematically expressed using a matrix of 0s and 1s; the sum of distances from all agents to their target points is set as the objective function, which is then solved using the MILP solver. Specifically, this 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 objective is to minimize the sum of distances from all agents to their chosen target point, which can be expressed by the following objective function:

[0225]

[0226] Where I is the set of agents, o i d(o) is the current position of agent i, p is a candidate point, and d(o) is the current position of agent i. 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 operational constraints. One-to-one selection constraint:

[0228]

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

[0230]

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

[0232] (4) Model Solving. A mixed-integer linear programming solver is used to solve the above model to find the optimal target point selection scheme. 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, and {C} i "′" is the set of candidate points for the agent, {d(o i ,p)} is the distance set.

[0235] (5) Output Selection Results. Output the solution results to determine the next target point for each agent. Output Selection:

[0236]

[0237] Here, SelectPoint is a function that, based on the decision variable x i,p The value of is the target point selected by 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 path planning of the agent through the application of the MILP model.

[0238] Step S7: When any agent first reaches the currently planned target point, if the execution target of that point has been completed and the agent's remaining task execution count is not zero, then proceed directly to the next planning step. If the agent still has remaining tasks to execute, select the nearest point that is different from the previous target point as the transition target. Specifically, this includes the following steps:

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

[0240]

[0241] Among them, A i,p It is an indicator function, representing the number of times agent i performs its task at target point p, V. i,p The task requirement T has been met or exceeded. req,p Furthermore, agent i still has remaining tasks R. i If the value is greater than 0, then it is 1; otherwise, it is 0.

[0242] (2) Next step planning for the agent. If the agent has completed the task at the current objective point and has remaining tasks, it needs to proceed with the next step planning immediately. Conditions for next step planning.

[0243]

[0244] PlanNext(i) is a Boolean function that is true if agent i satisfies the conditions for the next planning step.

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

[0246]

[0247] Where, p next It refers to the process by which agent i starts from its current position p and moves to the next set of candidate points C. i "The point with the shortest distance in the middle."

[0248] (4) Update agent state. After the agent reaches the transition target point, its state needs to be updated, including position, remaining task count, etc. Update position o i ′=p next , where o i ' represents the updated position of agent i. Update remaining task count:

[0249] R i ′=R i -1

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

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

[0252]

[0253] This step provides clear guidance for the agent's selection of transitional target points and state updates.

[0254] Step S8: Continuously update and record the target point allocation for each agent until the execution metrics for all target points are met, forming a complete path plan. This specifically includes the following steps:

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

[0256]

[0257] Among them, V i,p T represents the number of times agent i visits the target point p. req,p I is the number of times the task needs to be executed at target point p, I is the set of agents, and P is the set of all target points.

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

[0259]

[0260] Among them, A i,p (t) is an indicator function that indicates 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 sequence to form a complete path plan.

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

[0263] Where, Path i It is the complete path of agent i, o i It is the starting position, p i,j The target point visited at time j, o final,iThat is the final return location.

[0264] (4) Path optimization. After a complete path is formed, it may be necessary to optimize the path to reduce the total travel 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 a path.

[0267] (5) Path execution. Finally, the optimized path is sent to the agent to execute the task: Execute(OptimizedPath) i This is an execution function; agent i executes the code based on the optimized path (OptimizedPath). i Execute the task. This final step not only ensures that the execution metrics of all target points are met, but also provides the agent with an efficient and accurate execution path by recording and optimizing the path.

[0268] Based on this invention, algorithm experiments and analyses were conducted, and the algorithm pseudocode is as follows: Figure 1 As shown, proceed with the following steps:

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

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

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

[0272] Table 1

[0273]

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

[0275] Table 2

[0276]

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

[0278] While the invention has been described herein with reference to specific embodiments, it should be understood that these embodiments are merely examples of the principles and applications of the invention. Therefore, it should be understood that many modifications can be made to the exemplary embodiments, and other arrangements can be designed without departing from the spirit and scope of the invention as defined by the appended claims. It should be understood that different dependent claims and features described herein can be combined in ways different from those described in the original claims. It is also understood that features described in conjunction with individual embodiments can be used in other described embodiments.

Claims

1. A multi-agent efficient cooperative path planning method, characterized in that, Includes the following steps: S1. Define the set of agents and the set of target points, as well as the initial position, speed limit, task execution count limit and task payload capacity of the agents, and set the obstacle area. S2. Introduce an additional set of candidate points; 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; S4. Maintain access records for each target point, record the time and number of times the agent arrives, and check whether the task execution count is met. S5. For target points that do not meet the criteria, 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 target of the point has been completed and the remaining number of task executions of the agent is not zero, then directly proceed to the next planning step. If the agent still has remaining tasks to execute, select the nearest point that is different from the previous target point as the transition target. S8. Continuously update and record the target point allocation for each agent until the execution indicators of all target points are met, forming a complete path plan; Step S1 specifically includes the following steps: S101, Setting the set of intelligent agents The set of all possible target points Obstacle area O; S102, for each intelligent agent Set initial position and speed limit Task execution limit and mission payload capacity ; Step S2 specifically includes the following steps: S201. Eliminate points that are located inside or too close to obstacles from all possible target points: ； in, It is an intelligent agent The set of candidate points It is the set of all potential target points. Indicates an obstacle. It is a safe distance; S202. Evaluate the reachability of each potential target point: PathExists ; Among them, PathExists It is a Boolean function that evaluates to the value of an agent if it exists. Current location Time If a feasible path is found, return true; S203. Ensure that the points in the candidate point set can meet the agent's task requirements, such as the number of visits and the execution area: ； in, It is an intelligent agent Reach the target point The number of times the task is executed. The target point The number of times the task needs to be executed; S204. Optimize the initially generated candidate point set, prioritizing candidate points that are closer to the agent's current position to reduce movement time and energy consumption: ； in, It is the maximum reachable distance; S205. Based on the urgency and importance of the tasks, rank the candidate points, giving priority to the target points of high-priority tasks: ； in, It is a function that sorts candidate points according to task priority; S206. Adjust the candidate point set by predicting potential path conflicts between agents: NoConflict ; Among them, NoConflict It is a Boolean function, if the candidate point Candidate point sets with other agents If there is no conflict, return true; S207. When environmental changes are detected, the candidate point set is reassessed and adjusted: UpdateForChanges ,conflict- free ; Among them, UpdateForChanges ,conflict-free It is based on environmental changes A function to update the set of candidate points; S208. As the agent's state changes, update the candidate point set according to the new constraints: ； Among them, UpdateForStatus It is based on the intelligent agent status A function to update the set of candidate points; S209. After optimization and dynamic adjustment, output the final set of candidate points.

2. The multi-agent efficient cooperative path planning method according to claim 1, characterized in that, The core of the AStar algorithm consists of two functions: the cost function. and heuristic functions The cost function is: ； in, Indicates from node parent node to node The movement cost, heuristically defined, is: ； in, and These are nodes Given the coordinates of the target point, the total cost is estimated as follows: ； in From the starting point through the node Total cost estimate to reach the target point.

3. The multi-agent efficient cooperative path planning method according to claim 2, characterized in that, Step S3 specifically includes the following steps: S301, Set the starting point Add to open list, settings Calculate based on target point ; S302, Select from the open list the one with the lowest value node ,if If it is the target point, the path search is complete; otherwise, Move from the open list to the closed list and explore. All neighboring nodes; S303, For each neighbor node ,if Not in the closed list, calculate of and and will Add to the open list; S304, Backtracking from the target point to the starting point The path is constructed by tracing the parent node of each node, and finally, path and time calculations are performed. Once the path is found... Calculate the total time for the entire path to the target point. : ； in, From node To the node Travel time.

4. The multi-agent efficient cooperative path planning method according to claim 1, characterized in that, Step S4 specifically includes the following steps: S401, for each intelligent agent Maintain an access record for each target point. This record tracks the number of times the agent reaches each target point, and the visit count is updated accordingly. ； in, Indicates time intelligent agent Number of times the target point is visited It is an indicator function, when the agent... In time The value is 1 when the target point is reached, and 0 otherwise. S402. Each target point has a preset task execution count indicator. , indicates the minimum number of accesses required to complete the task. Check the current task completion status: ； in, Indicates time Have the task requirements for the target point been fulfilled? S403, Monitor each intelligent agent The task execution status is monitored, and it is ensured that the tasks meet their respective requirements. Task execution monitoring logic: ； in, Indicates time intelligent agent The logical expression indicating whether all its tasks have been completed. This represents the logical AND operation; S404. If an agent fails to complete its task, re-plan the task based on the current state and environment. The conditions for task re-planning are: ； in, Indicates time Is it necessary to modify the intelligent agent? The tasks need to be re-planned; S405. Record the total time required for each agent to complete the task: True ; in, It is an intelligent agent The earliest time to complete all its tasks.

5. The multi-agent efficient cooperative path planning method according to claim 4, characterized in that, Step S5 specifically includes the following steps: S501. Filter candidate points. The candidate point filtering logic is as follows: ； in, It is an intelligent agent Target point The updated set of candidate points, It is the set of all possible target points. It is an intelligent agent The target point of the previous visit, It is an intelligent agent Visit the target point Number of times, The target point The number of times the task needs to be executed; S502. Summarize the candidate point list for each agent to prepare for the next step of target point allocation: ； in, It is an intelligent agent A summary list of candidate points; S503. Verify the reachability of the summarized candidate points to ensure that the agent can actually reach these candidate points. Reachability verification: isReachable ; in, It is a list of candidate points after reachability verification, isReachable It is a function, if from the agent Current location to candidate point If a reachable path exists, return true; S504. Priority ranking of candidate points: sort ,priorityRule) in, It is a sorted list of candidate points, where sort is the sorting function and priorityRule is the rule that defines the priority of candidate points, based on distance and task urgency. S505, Output the candidate point list for each agent. .

6. The multi-agent efficient cooperative path planning method according to claim 1, characterized in that, Step S6 specifically includes the following steps: S601, For each agent and its candidate point list Each point in Define a binary decision variable. : ； S602. Construct the objective function: ； in, It is a collection of intelligent agents. It is an intelligent agent Current location From intelligent agents Current position to candidate point The distance; S603. Ensure that each agent selects only one target point and satisfies other operational constraints, one-to-one selection constraints: ； Ensure that each intelligent agent From its candidate point list only Select a target point; optional point constraints: MaxPoints, ; MaxPoints is the maximum number of target points that each agent can choose, which is usually 1. S604. Solve the model using the MILP solver. Solution process: Solve MILP ; Solve MILP is the function for solving MILP problems. It is a collection of intelligent agents. It is a set of candidate points for the agent. It is a distance set; S605. Output the solution results, determine the next target point for each agent, and select the output option: SelectPoint , ; Here, SelectPoint is a function that is based on the decision variables. The value is the agent Select the target point.

7. The multi-agent efficient cooperative path planning method according to claim 1, characterized in that, Step S7 specifically includes the following steps: S701, Determine the intelligent agent Have all task requirements for its current target point been completed? ； in, It is an indicator function, if the agent At the target point Number of task executions Reached or exceeded And intelligent agents There are still tasks remaining. If the value is 1, then the value is 1; otherwise, the value is 0. S702, If the intelligent agent Having completed the tasks at the current objective point and with remaining tasks, proceed to the next planning step. Conditions for the next planning step: ； Among them, PlanNext It is a Boolean function, if the agent If the conditions for the next planning step are met, then it is true; S703, if the intelligent agent Having completed its current target point task, but with remaining tasks to execute, select a transitional target point: ； in, It is an intelligent agent From current location Let's go, to the next one The point with the shortest median distance; S704, Intelligent Agent Upon reaching the transition target point, update its status and position. ,in, It is an intelligent agent Updated location, updated remaining task count: ,in, It is an intelligent agent The number of remaining tasks after the update; S705, If the intelligent agent There are still tasks remaining. Repeat the path planning process until all tasks are completed.

8. The multi-agent efficient cooperative path planning method according to claim 1, characterized in that, Step S8 specifically includes the following steps: S801. Verify whether each target point has achieved the predetermined performance indicators: , ； in, Represents intelligent agents For target point Number of visits, The target point The number of times the task needs to be executed. It is a collection of intelligent agents. It is the set of all possible target points; S802. Record the access status of each agent to each target point during the planning process: ； in, It is an indicator function that indicates at time intelligent agent Did the target point visit? ; S803. Record all verification points and transition points in sequence to form a complete path plan: ； in, It is an intelligent agent The full path, It is the starting position. The target point is visited at time t. This is the final return location; S804. Optimize the route to reduce the total travel distance or time: Optimize ; Among them, Optimize It is a path optimization function; S805, Send the optimized path to the agent. Perform the task.

Images