Context-Aware Route Planning for Automated Warehouses

TL;DR

This paper presents a novel context-aware route planning approach for automated warehouses that improves throughput and reduces failure rates, effectively managing dynamic task allocation and collision-free trajectories in real-time.

Contribution

It introduces a new algorithm for collision-free trajectory planning that handles dynamic task assignment and prioritizes throughput over makespan in automated warehouses.

Findings

Lower fail rate compared to previous algorithms

Higher quality trajectory planning results

Maintains real-time computational efficiency

Abstract

In order to ensure efficient flow of goods in an automated warehouse and to guarantee its continuous distribution to/from picking stations in an effective way, decisions about which goods will be delivered to which particular picking station by which robot and by which path and in which time have to be made based on the current state of the warehouse. This task involves solution of two suproblems: (1) task allocation in which an assignment of robots to goods they have to deliver at a particular time is found and (2) planning of collision-free trajectories for particular robots (given their actual and goal positions). The trajectory planning problem is addressed in this paper taking into account specifics of automated warehouses. First, assignments of all robots are not known in advance, they are instead presented to the algorithm gradually one by one. Moreover, we do not optimize a makespan, but a throughput - the sum of individual robot plan costs. We introduce a novel approach to this problem which is based on the context-aware route planning algorithm [1]. The performed experimental results show that the proposed approach has a lower fail rate and produces results of higher quality than the original algorithm. This is redeemed by higher computational complexity which is nevertheless low enough for real-time planning.

Tables

Table 1. TABLE I: Times of addition for 50 t ​ h superscript 50 𝑡 ℎ 50^{th} and 100 t ​ h superscript 100 𝑡 ℎ 100^{th} robot

Algorithm	Time for $k^{th}$ robot [ms]
	${50}^{th}$ robot	${100}^{th}$ robot
Proposed_4	$3.23$	$7.6$
Proposed_5	$10.86$	$19.48$
Proposed_6	$50.58$	$75.81$
Proposed_10	$43.84$	$54.10$
CARP	$0.63$	$1.60$
CARP10	$5.29$	$12.15$
CARP100	$52.08$	$126.57$
LF	$0.85$	$2.59$

Equations

$$d(a_{i},a_{j})=\frac{\sum_{\tau=\tau_{S}}^{\tau_{G}}{\Big{|}t_{i}(\tau),t_{j}(\tau)\Big{|}}}{\tau_{G}-\tau_{S}},$$

Full text

The trajectory planning problem is addressed in this paper taking into account specifics of automated warehouses. First, assignments of all robots are not known in advance, they are instead presented to the algorithm gradually one by one. Moreover, we do not optimize a makespan, but a throughput – the sum of individual robot plan costs.

We introduce a novel approach to this problem which is based on the context-aware route planning algorithm [1]. The performed experimental results show that the proposed approach has a lower fail rate and produces results of higher quality than the original algorithm. This is redeemed by higher computational complexity which is nevertheless low enough for real-time planning.

I Introduction

The European market for e-commerce is growing rapidly, with more than 16% just in the year 2014 [2] and so is the same for the world market. With the growing markets, the need for larger warehouses and distribution centers and their automation increases [3]. In such facilities goods for the end-users or products in the business-to-business sector are stored, commissioned and shipped. To manage the supply chains, many new warehouses have been erected, and more will follow (see Fig. 1 for an example of such automated warehouse). Reliable figures are hard to come by, but for instance, a company such as DHL alone operates more than 2000 warehouses. With the growing markets, the need for larger warehouses and their automation increases. Therefore the robotic and automation companies should be able to provide appropriate solutions, making scalable systems and scalable software mandatory.

One of the fundamental problems related to automated warehouses is trajectory planning and motion coordination for a fleet of robots distributing goods in a warehouse which has been theoretically studied from many perspectives since the 1980s, see [4] for a nice overview. The problem (also formulated as the warehouseman’s problem) has been proven to be PSPACE-complete [5]. The complexity of the problem can be reduced for the case where robots move on a predefined graph, nevertheless, it is still NP-hard [6], which means that optimal solutions cannot generally be found in a reasonable time for non-trivial instances (e.g., for a number of robots in order of tens).

Solutions to the problem consider either coupled or decoupled approaches. Coupled (also called centralized) approaches consider a fleet of robots as a single multi-robot body with the number of degrees of freedom (DoFs) equal to the sum of DoFs of individual robots. Classical single-robot planning approaches can then be applied to plan motion of this multi-robot body in composite configuration space. Because these algorithms are typically based on classical complete and optimal algorithms, their main advantage is that they warrant to find a solution if it exists and report its non-existence if it does not exist [7], [8], [9]. This, however, leads to the main disadvantage of these algorithms which is the exponential computational time in the dimension of the composite configuration space. The appropriate use cases for this type of algorithms are thus problems that consist of a small number of robots.

On the other hand, algorithms that use the decoupled approach typically provide solutions much faster than coupled planners for the price of the solutions being sub-optimal. In addition to this, decoupled algorithms generally do not guarantee the completeness and may suffer from deadlocks. These approaches can be typically split into two categories - path coordination and prioritized planning. Path coordination tunes velocities of individual robots along precomputed trajectories to avoid collisions of these robots [10], [11]. Prioritized planning assigns each agent a priority according to which an ordering is made for the agents. The planning algorithm then plans trajectories for individual robots according to this ordering, while considering already planned robots as moving obstacles that have to be avoided. [12], [13], [14].

[1] presents a similar idea, but codes information about trajectories of robots with higher priorities into the planning graph rather than into the planning algorithm itself. It does so by constructing a resource graph, where each resource can be for example a node of the original graph or intersection graph edges. Every such resource holds information about time intervals in which it is not occupied by already planned robots. An adaptation of the A* algorithm is used on this graph to find the shortest path through these intervals (called free time windows) to obtain a path that avoids all already planned robots.

[15] deals with a real-life problem of routing vehicles in Container Terminal Altenwerder in Hamburg harbor. They used a similar approach to keeping a set of free time windows for path arcs in the graph. Their algorithm contains a preprocessing of the graph for the use of specific vehicles followed by computation of paths for individual vehicles on this preprocessed graph.

Another similar approach is presented in [16], where each robot looks for a viable path in a 2D spatial grid map and checks for collisions with moving obstacles using a temporal occupancy table. [17] adopted a similar approach to [1] with enhanced taxiway modeling approach to improve performance on airport graph structures. [18] compares Context-Aware Route Planning (CARP) [1] with a fixed-path scheduling algorithm using $k$ shortest paths [19] and a fixed-path scheduling algorithm using $k$ disjoint paths [20]. The experiments show that the CARP algorithm is superior in all measured qualities.

[21] compares several heuristic approaches of assigning priority to robots and concludes that the heuristics which plans longest paths first perform best when a makespan is to be minimized. A greedy best-first heuristics provides best results regarding joint plan cost. However, its downside is that it calls the planning algorithm for all yet unplanned robots in every round and it is thus very time-consuming.

In this paper, we consider the planning problem from the perspective of usability in automated warehouses (AWs). The key difference in AWs is that the assignments are not known all at once at the time of planning, but they instead come in time sequentially as requests for goods to be delivered are being received. This emphasizes a quick time to compute a plan for newly requested robots while minimizing the sum of time it takes for all robots in the system to complete their plans. We present a novel approach that can calculate paths for newly added robots to the system while maximizing its throughput.

The rest of the paper is organized as follows. The multi-robot path-finding problem for automated warehouses is presented as well as the used terms are defined in Section II. The proposed planning algorithm is described in Section III, while performed experiments, their evaluation, and discussion are presented in Section IV. Finally, Section V is dedicated to concluding remarks and future work.

II The problem

Assume a finite weighted connected graph $G(V,E)$ and a set ${\cal A}=\left(a_{1},a_{2},...,a_{k-1}\right)$ of robots each of which has already planned a trajectory in $G$ without collisions. The aim is to find a non-colliding trajectory for a robot $a_{k}$ from its start position to the given target position while optimizing a global cost function, possibly without replanning all robots.

We employ the CARP algorithm [1] for the planning of individual robots, so we use its assumptions on the graph structure as follows. The infrastructure the robots plan on is modeled as a resource graph $G_{R}=(R,E_{R})$ where resources $R$ can be the original nodes, edges, intersections of edges, etc. The path the robot can follow is restricted to edges $E_{R}$ which limit transitions of robots such that a robot can move from a resource $r_{1}$ to a resource $r_{2}$ only if $r_{2}$ is a neighbour of $r_{1}$ in the graph $G_{R}$, i.e. the edge $(r_{1},r_{2})\in E_{R}$. Each resource also has two main attributes associated with it. These are capacity $c(r)$ which corresponds to the maximum number of robots that can occupy the resource $r$ at the same time and duration $d(r)>0$ that represents the minimal time it takes the robot to traverse the given resource $r$. Plans for every robot then contain not only a sequence of resources on its path but also time intervals during which the robot visits them. The idea is that if the infrastructure is modeled this way, collision avoidance is shifted into deciding which resources at what time the robots can visit, rather than finding paths without collision in space and time, which is PSPACE-complete [5].

III Algorithm

As mentioned, the proposed algorithm employs CARP [1]. It was chosen because of its ability to plan sequentially one robot at a time while keeping the information about movement of other robots in a compact and easy to update manner. More specifically, CARP uses the infrastructure described above to find paths in a resource graph, where each node of the infrastructure keeps information about its capacity and occupancy in given time windows. This allows it to use a modified A* algorithm that finds a free time window in the start resource corresponding to a start node and attempts to find a path through these time windows to a free time window in the resource that corresponds to the goal node.

The proposed algorithm aims to generate a trajectory for an robot $a_{k}$ assuming that trajectories for $k-1$ robots are already planned which can possibly lead to modification of those planned trajectories. The main idea is to iteratively build a set of robots whose trajectories mostly influence an optimal trajectory of $a_{k}$, see Algorithm 1. The algorithm maintains two structures:

• •

${\cal N}$ – a set of robots in the neighborhood of $a_{k}$ which is initially set to contain $a_{k}$ (line 1), and

• •

${\cal A}$ – a sequence of robots not in ${\cal N}$. This sequence initially stores the order in which trajectories of the robots $a_{1}\dots a_{k-1}$ were generated (line 1).

Moreover, cost of the best solution that has been found so far is set to a high number.

New robots are iteratively added to the neighborhood in the loop starting at line 1. The robot $a_{b}\in{\cal A}$ which minimizes the distance to the neighborhood is found at each iteration first, where the distance of a robot to a set is defined as the distance of the robot to the closest robot in the set. The distance between two robots is then determined as the average Euclidean distance of robots’ positions at discrete time steps:

[TABLE]

where $t_{i}(\tau)$ is a position of $a_{i}$ at time $\tau$ if it follows the trajectory $t_{i}$, $t_{j}(\tau)$ is a position of $a_{j}$ at time $\tau$ if it follows the trajectory $t_{j}$, and $\left<\tau_{S},\tau_{G}\right>$ is a time interval when $a_{i}$ or $a_{j}$ moves. Note that trajectories of robots in ${\cal A}$ are initially taken from the input set $\cal T$ while an initial trajectory of $a_{k}$ is determined as the shortest path between its start and goal positions on $G$ making use of the A* algorithm (line 1). These initial trajectories are updated as soon as new plans are found at the next steps of the algorithm.

The found closest robot $a_{b}$ is then removed from the sequence ${\cal A}$ (line 1), added to a set of neighbors ${\cal N}$ (line 1) and new trajectories for ${\cal A}$ are computed by the CARP algorithm from the scratch (line 1) as demonstrated in Fig. 2.

All possible permutations of robots in ${\cal N}$ are considered next (line 1). A set of trajectories $\cal P$ is determined by the CARP algorithm taking into account trajectories $\cal C$ for each such permutation (line 1). This is realized by running CARP for ${\cal N}$ on a resource graph with free windows generated by CARP when computing $\cal C$ at line  1. The set $\cal P$ is then added to $\cal C$, and the cost of this solution is computed (line 1) and compared with the best solution found till now (line 1). If the new solution is better than the currently best, it is stored together with its cost (lines 1 and 1). The best-found solution is finally reported at line 1.

Calculation of computational complexity of the proposed algorithm is based on the fact that CARP for $n$ robots comprises $n$ calls of A*. We call CARP $M-1$ times at line 1 gradually for $k-2,k-3,\dots k-M-1$ robots which leads to $\frac{M}{2}(2k-M-3)$ calls of A*. Similarly, CARP at line 1 is called $\sum_{N=2}^{M}N!$ times which leads to $\sum_{N=2}^{M}NN!$ calls of A*.

The total number of A* calls can be significantly reduced in two ways. Firstly, when calling CARP at line 1 after removal of $a_{b}$ not all trajectories have to be recomputed. We can instead preserve trajectories of robots which were in ${\cal A}$ before $a_{b}$ as they are not influenced by $a_{b}$. Only trajectories of robots behind $a_{b}$ in ${\cal A}$ have to be recomputed which leads to a reduction of A* calls by 50% in average.

The second reduction is similar. If the permutations are generated in a lexicographic order at line 1 then two consecutive permutations have typically a big joint head as depicted in Fig. 3. Plans of robots in that head can be preserved while recomputation has to be done only for the rest. Assuming neighborhood size $|{\cal N}|=4$, instead of calling A* $4\times 4!=96$ times, only 64 calls is performed which is $67\%$. The reduction is even greater for $|{\cal N}|=5$: 325 calls instead of 600 which is $54\%$, while only $45\%$ (1956 instead of 4320) A* calls are needed for $|{\cal N}|=5$.

IV Experiments

The experiments were performed on a computer equipped with Intel Xeon E5-2690. The maps the experiments were performed on were created to show how the proposed algorithm performs depending on the density of the given graph, specifically the number of edges. The set of 21 maps was generated by creating a minimum spanning tree of a $20\times 20$ grid map and then iteratively adding a given number of original edges to it until the original grid was recreated. Furthermore, 500 different random assignments were generated for a fleet of 100 robots by randomly sampling start and goal nodes for each robot. Each of these assignments was tested on all 21 maps.

The goal of the experiments was to test how the proposed algorithm scales with the number of edges in the graph as robots are sequentially added to the system. For comparison we ran the original CARP algorithm with no change to priorities of the robots, i.e., priorities were set randomly. Because this approach proved to have a high failure rate, we introduced two variants that after each planning attempt randomly shuffled the robot order 10 and 100 times (CARP10, CARP100 respectively) and tried planning again from scratch. The best plan regarding the sum of the number actions of individual robots was considered as the result. We also added CARP with the longest first heuristic to determine robot priorities as introduced in [21] to the comparison as LF. The proposed algorithm was run in several variants that differ in the parameter $\cal M$ specifying the size of the neighborhood. For the parameters 4,5,6 (Proposed_4, Proposed_5, Proposed_6 respectively) all the permutations of the neighborhood were considered. For the parameter 10 (Proposed_10) a 150 different neighborhood permutations were chosen randomly to decrease computational complexity.

Orders for all 100 robots were presented sequentially to all algorithms on all maps and assignments in the first experiment. Failure rate (Fig. 4) and the number of actions of all robots were observed (Fig. 6). In the second experiment, the algorithms were sequentially given one robot at a time at each iteration for all 500 assignments on a map shown in Fig. 5 with the goal of showing how much time it takes to generate a plan for each algorithm after adding robot into the system.

The results for the failure rate of the algorithms can be seen in Figure 4. It can be seen that the proposed algorithm has a fail rate in between the fail rates of CARP and CARP10.

The Figure 6 shows the average overall quality of the plan from the first experiment measured as the total number of actions of all robots. The graph shows that all versions of the proposed algorithm perform similarly to each other with Proposed_10 having the best results. Compared to the basic CARP algorithm the proposed algorithm has up to 65 less number of total actions performed across all robots in Proposed_6 variant (on the 10th map) and up to 35 fewer actions for Proposed_6 and Proposed_10 on the original grid map. Moreover, all variants of the proposed algorithm outperform CARP10 and are at least comparable to CARP100 which is much more time-consuming. It can also be noticed that LF generates worst results. It is not much surprising as it was designed to optimize a makespan.

The results of the second experiment are presented in Fig. 7 which shows the required time to find a trajectory for $k$-th robot considering trajectories of robots $1\dots k-1$ are already planned. It is evident that CARP100 is the slowest of all tested algorithms with Proposed_6 as the second slowest. It is worth noticing that for Proposed_6 the time of testing all permutations of the neighborhood took longer than replanning of the rest of the robots. The table I shows the actual times to plan 50th and 100th robot in this experiment.

From the results as a whole we can see that Proposed_4 and Proposed_5 show the best ratio between the quality of the found plan and the time required to compute it. Additionally, if the time requirements for planning are not as tight, it is possible to run a more demanding version of the algorithm to increase the quality of the solution. To increase the overall success rate of the algorithm, it is possible to combine the proposed algorithm with a version that has a higher success rate, such as CARP100 or even higher in case the proposed algorithm does not find a solution.

V Conclusion

In this paper, we present a novel algorithm for planning in automated warehouses that consider specific requirements in these environments for sequential addition of robots into the system while optimizing the total number of actions all robots must perform. The proposed algorithm employs the standard CARP algorithm for the planning of individual robots, which is one of the best practical algorithms nowadays. The experimental results show that the proposed approach finds better solutions than the original CARP algorithm after several random shuffles of the robots’ priorities while requiring significantly less computational time for adding individual robots into the system. Moreover, it is much faster than CARP100 which produces similar results.

The only drawback of the algorithm is the success rate of finding the solution, and thus the future work should focus on its improvement. One approach could be the use of deep learning to better determine either robot priorities or the set of robots mostly influencing the planned robots which need to be replanned. Another route of improvement would be to adapt the system for the use of heterogeneous robots and more importantly humans, who need to have the highest priority to have their trajectories planned to minimize the time humans spend in the warehouse to eliminate the risk of injury.

Acknowledgement

This work has been supported by the European Union’s Horizon 2020 research and innovation programme under grant agreement No 688117, by the Technology Agency of the Czech Republic under the project no. TE01020197 “Centre for Applied Cybernetics”, and by the European Regional Development Fund under the project Robotics for Industry 4.0 (reg. no. CZ.02.1.01/0.0/0.0/15 003/0000470). The work of Jakub Hvězda was also supported by the Grant Agency of the Czech Technical University in Prague, grant No. SGS18/206/OHK3/3T/37.