Classic literature reading - PIBT (real-time planning scheme based on visible tree)

0. Introduction

As far as path planning is concerned, there is not only a single robot autonomous path planning. In recent years, with the rise of the robot industry, multi-robot autonomous path planning has also received more and more attention. For multi-agent pathfinding (MAPF). The general operation will give a map, robot clusters, and their initial positions and destinations, and MAPF will finally output a set of paths without collisions, which are used to control the robot clusters to complete the movement. " Iterative Refinement for Real-Time Multi-Robot Path Planning " argues that iterative refinement of MAPF is desirable for three reasons: 1) multi-agent optimization is tricky, 2) suboptimal solutions can be obtained immediately, 3) in online scenarios The time to be considered is limited, so MAPF is required to be planned in real time.

Our scheme uses a suboptimal MAPF solver to quickly obtain an initial solution, and then iterates two processes: 1) selecting a subset of agents, and 2) using an optimal MAPF solver to optimize the paths of the selected agents while keeping other paths constant . Since a single optimal solver will only optimize the paths of selected agent robots, this scheme can quickly generate sufficiently efficient solutions while providing high scalability. The corresponding code is also open source on Github . It can be said that this method is still very meaningful.

1. Article contribution

1. A general framework is proposed in this paper, which can quickly provide anytimeMAPF solutions based on the effective combination of existing solvers. Our framework first uses a suboptimal MAPF solver to quickly obtain an initial feasible solution, and then uses an optimal MAPF solver to find a good neighborhood solution. Precisely, the framework iteratively refines the solution by selecting a set of agents and using an optimal solver to refine their paths while keeping other paths fixed. Although an optimal solver is used during refinement, each refinement is done quickly because it solves a subproblem whose size depends on the number of surrogate robots chosen, and is usually much smaller than the original problem. We also propose plausible candidates for selecting a subset of agents.
2. The paper studies the effectiveness of the method on various benchmarks and empirically finds that the framework converges almost to optimality in a short period of time in small instances, and even for very large instances (i.e. large environments and/or or many proxies) also remain highly responsive. In other words, it brings many practical advantages over previous technologies.
3. From a broader perspective, our study can also be seen as solving a very large-scale neighborhood search [24]. Getting closer to our concept, Balyo et al. [25] study local replanning for domain-independent planning problems to optimize the maximum time. It repeats the following operations: create a subproblem, obtain an optimal subsolution through SAT-based techniques, and replace the original partial solution with a new one.
   

2. Main framework

The framework first obtains an initial solution using a suboptimal MAPF solver, and then iteratively refines selected parts of the solution, i.e., paths for a selected subset of agents, using an optimal MAPF solver. We have given the pseudo code in Algorithm 1.

Let's take a look at it in detail. The input in line 1 is the suboptimal solver to quickly obtain the initial feasible solution. In the second row, we call the used suboptimal MAPF solver the initial solver. If the initial solver fails to arrive at a solution, the framework fails; otherwise, refinement starts, which is what's inside lines 3-6. Refinement repeats the following two processes until interrupted:

1. Create a modification set M ⊆ A using the current solution π [Line 4].
2. Use the optimal MAPF solver [line 5] to refine the current solution π by altering the paths of the agents in M. We call this solver the refinement solver. The refinement solver changes only the paths of the agents in M; the paths outside the agents in M ​​are unchanged. Refinement continues until interrupted, such as a timeout, reaching a predetermined number of iterations, when there are no more improvements, interrupted by the user, etc.
   Eventually, the framework returns the final solution [Line 7].

The initial solver mentioned above can be any suboptimal MAPF solver as long as it provides a feasible solution. As a refinement solver, it is best to use a version adapted from the optimal solver. The adaptation is simple; let it plan paths for agents in M ​​and treat other agents as dynamic obstacles. For example, for the CBS algorithm , the MAPF is only solved for the agents in M, while the low-level search is prohibited from using all space-time pairs except the agents in M. To be precise, refinement solvers are not limited to optimal MAPF solvers (single-robot solvers can be used). The requirement is that the refined solution does not deteriorate from the original solution. Considering that the path costs other than the agents in M ​​are constant, the requirement is that the path costs of the agents in M ​​do not increase before and after refinement.

3. Refinement of solver properties and requirements

Below are some properties that are clearly set by the requirements placed on the refinement solver.

3.1 Theorem 1 (monotonicity):

For each iteration in Algorithm 1, the solution cost is non-increasing.
A key point is that the refinement solver recomputes the paths of agents in a selected subset M (a subset of robots) rather than the set A of all agents (all robots). Compared to solving the original problem directly with the optimal solver, the refined solver solves a significantly smaller problem per iteration, ensuring that the framework is scalable even for a large number of agents. At the same time, there are several ways to effectively reduce the calculation time.

A. Early termination (early stop)
Even if the sub-problem solved by the refinement solver is already less computationally intensive than the original problem, if its own $|M|$ is still too large, and refinement may still take a long time. In this case, it is better to abort the current refinement by returning to the current solution, and then use the new set$M$ starts a new iteration. Criteria can be timeouts or thresholds for the size of the search tree in the use refinement solver.

B. Limitations
As a limitation, the framework may have local minima and no suboptimality bounds from optimal solutions.
Proposition 1 (no suboptimal bound) : Consider the optimal cost $c^{\ast }$ . In Algorithm 1, always$c\le w{c}^{\ast }$ , unless$A$ itself is selected as the modification set$M$ , where$c$ is the solution cost in each iteration.
Proof: Consider an example in Figure 1. Suppose the initial solution will be$a_1$assigned to a clockwise path (cost: $k$ ) Sum$a_2$Assigned to the counterclockwise path (cost: 1). When k≥6, this is not the optimal model, because $a_1$Can take a counterclockwise path and go through $a_2$to move to the target (total cost: 6). unless $M\ne A$ , otherwise the refined solution remains unchanged. Suppose$w\ge 1$ , such that$c\le w{c}^{\ast }$ . We can take any$k$ , given$The\; existence\; of\; w$ is contradictory.

3.2 Theorem 2 (local minimum exists)

Depending on the initial solution, the optimal solution may not be reached unless A itself is chosen as M.

Note that when $M=A$ , the refinement solver must be able to solve the original MAPF problem.

4. Modification set selection

We can see from the above that during optimization, the selection of the modification set will affect the performance of the entire system, and how to effectively select the modification set is very important. Modification sets are an important part of the framework, and their design affects properties such as computation time and solution quality. This section defines several selection rules to provide a reasonable set of candidate modifications.

4.1 Random

A naive approach is to randomly pick a subset of agents. Then, modify the set size $M$ is a user-specified parameter. It should be noted that the large$M$ modification has the opportunity to greatly reduce the cost in one iteration, but takes time to refine as the subproblems become challenging.

4.2 Single agent

This rule always selects a single agent because $M$ can be seen as a special case of the previous rule (random). Even with only one agent, costs can be reduced by thinning. In this case, refinement is just a single-agent pathfinding problem, which can be performed without$The\; MAPF$ solver case is efficiently computed, for example, by$A^{\ast }$ can be calculated, which can be simplified as the optimal path planned by a robot among other obstacles (robots).

4.3 Focus on goals

Consider an example in Figure 2. Suppose the current solution is $p1=(v2,v3,v6,v3,v3)$和$p2=(v.1,v2,\_v3,v4,v5)$ .$\_$Agent$a_1$A shorter path cannot be achieved because agent $a_2$At the 2nd time step (3rd value) $a_1$target (i.e. v3). In general, for $a_i$For the ideal cost $dist(p_i[0],g_i)$ and actual cost$(a_i,\pi )$ may be another agent$a_j$At time step $t\ge dist\left(p_i\right[0],g_i)$ used$a_i$The target (ie $g_i$). at least at ttBefore$t$$a_i$Can't reach $g_i$and stay there. In this case, joint refinement $a_i$和$a_j$path of. This observation motivates us to create a simple rule that divides the current solution $\pi$ and an agent$a_i$as input.

4.4 Local repair around the target

This is a special case of the previous rule (focus on the target). Assume again the example of Figure 2; $p1=(v2,v3,v6,v3,v3)$，$p2=(v.1,v2,\_v3,v4,v5)$ .$\_$In focus-at-goals,$a_1$MM $M$ is{ a 1 , a 2 } \{a_1, a_2\}{ a1​,a2​} , therefore, the refinement solver has to solve a subproblem with two agents; however, this effort can be reduced. Consider$a_1$To get a better path, ignore ${Pi}_2$. In this example, a new path is obtained by local repair around the target, no search is required; $(v2,v3,v3,v3,v3)$ .$\_$Next, for$a_2$Compute a path while avoiding collisions with this new path and paths of other agents. If the sum of the costs of the two new paths is less than the original path, replace ${Pi}_1$和${Pi}_2$. Refinement work is expected to be completed more quickly due to the reduced search effort. In general, when ${Pi}_i=（...，g_i,v,g_i，...，g_i)$ , where$v\ne g_i$, while another agent $a_j$Use gi g_i at that time step$g_i$, this rule can be applied.

4.5 Using MDDs

Given a single path cost $c$，从${Pi}_i\left[0\right]$ to$g_i$A set of paths for can be compactly represented as a multivalued decision graph (MMDD) [35]; a directed acyclic graph in which a vertex is a pair of positions v ∈ V v ∈ $v\in V$ and a time step$t\in N$。

1. reachable locations from the origin during the time period;
2. The reachable position to the target from that time period.
   Let MDDc i be a cost of $ai$ a_i_$a_i$Figure 3 shows two examples of the MDD. $MD{D}_1^2$和$MD{D}_1^3$. MDD is frequently used in MAPF solvers [28], [36].

…For details, please refer to Gu Yueju