Distributed Assignment with Limited Communication for Multi-Robot Multi-Target Tracking This material is based upon work supported by the National Science Foundation under Grant No. 1637915.

Distributed Assignment with Limited Communication for Multi-Robot Multi-Target Tracking thanks: This material is based upon work supported by the National Science Foundation under Grant No. 1637915.

Yoonchang Sung Y. Sung 22email: yooncs8@vt.eduA. K. Budhiraja 44email: ashishkb@vt.eduR. K. Williams 66email: rywilli1@vt.eduP. Tokekar 88email: tokekar@vt.eduDepartment of Electrical & Computer Engineering, Virginia Tech, 1185 Perry Street, Blacksburg, VA 24061, USA    Ashish Kumar Budhiraja Y. Sung 22email: yooncs8@vt.eduA. K. Budhiraja 44email: ashishkb@vt.eduR. K. Williams 66email: rywilli1@vt.eduP. Tokekar 88email: tokekar@vt.eduDepartment of Electrical & Computer Engineering, Virginia Tech, 1185 Perry Street, Blacksburg, VA 24061, USA    Ryan K. Williams Y. Sung 22email: yooncs8@vt.eduA. K. Budhiraja 44email: ashishkb@vt.eduR. K. Williams 66email: rywilli1@vt.eduP. Tokekar 88email: tokekar@vt.eduDepartment of Electrical & Computer Engineering, Virginia Tech, 1185 Perry Street, Blacksburg, VA 24061, USA    Pratap Tokekar Y. Sung 22email: yooncs8@vt.eduA. K. Budhiraja 44email: ashishkb@vt.eduR. K. Williams 66email: rywilli1@vt.eduP. Tokekar 88email: tokekar@vt.eduDepartment of Electrical & Computer Engineering, Virginia Tech, 1185 Perry Street, Blacksburg, VA 24061, USA
Received: date / Accepted: date
Abstract

We study the problem of tracking multiple moving targets using a team of mobile robots. Each robot has a set of motion primitives to choose from in order to collectively maximize the number of targets tracked or the total quality of tracking. Our focus is on scenarios where communication is limited and the robots have limited time to share information with their neighbors. As a result, we seek distributed algorithms that can find solutions in a bounded amount of time. We present two algorithms: (1) a greedy algorithm that is guaranteed to find a –approximation to the optimal (centralized) solution but requiring communication rounds in the worst case, where denotes the number of robots; and (2) a local algorithm that finds a –approximation algorithm in communication rounds. Here, and are parameters that allow the user to trade-off the solution quality with communication time. In addition to theoretical results, we present empirical evaluation including comparisons with centralized optimal solutions.

1 Introduction

We study the problem of assigning robots with limited Field-Of-View (FOV) sensors to track multiple moving targets. Multi-robot multi-target tracking is a well-studied topic in robotics parker1997cooperative (); parker2002distributed (); touzet2000robot (); kolling2007cooperative (); honig2016dynamic (). We focus on scenarios where the number of robots is large and solving the problem locally rather than centrally is desirable. The robots may have limited communication range and limited bandwidth. As such, we seek assignment algorithms that rely on local information and only require a limited amount of communication with neighboring robots.

Constraints on communication impose challenges for robot coordination as global information may not always be available to all the robots within the network. As a result, it may not be always possible to design algorithms that operate on local information while still ensuring global optimality. Recently, Gharesifard and Smith gharesifard2017distributed () studied how limited information due to the communication graph topology affects the global performance. Their analysis applies for the case when the robots are allowed only one round of communication with their neighbors. If the robots are allowed multiple rounds of communication, they can propagate the information across the network. Given sufficient rounds of communication, all robots will have access to global information, and therefore can essentially solve the centralized version of the problem. In this paper, we investigate the relationship between the number of communication rounds allowed for the robots and the performance guarantees. We focus on the problem of distributed multi-robot, multi-target assignment for our investigation (Figure 1).

Figure 1: Description of multi-robot task allocation for multi-target tracking. In this example, three robots () are tracking two moving targets (). Each robot has five motion primitives () to choose from at each time step. represents the cost of observing a target from a motion primitive.

We assume that each robot has a number of motion primitives to choose from. A motion primitive is a local trajectory obtained by applying a sequence of actions howard2014model (). A motion primitive can track a target if the target is in the FOV of the robot. The set of targets tracked by different motion primitives may be different. The assignment of targets to robots is therefore coupled with the selection of motion primitives for each robot. Our goal is to assign motion primitives to the robots so as to track the most number of targets or maximize the quality of tracking. We term this as the distributed Simultaneous Action and Target Assignment (SATA) problem.

This problem can be viewed as the dual of the set cover problem, known as the maximum (weighted) cover suomela2013survey (). Every motion primitive covers some subset of the targets. Therefore, we would like to pick motion primitives that maximize the number (or weight) of covered targets. However, we have the additional constraint that only one motion primitive per robot can be chosen at each step. This implies that the relationship between a robot and the corresponding motion primitives turns out to be a packing problem suomela2013survey () where only one motion primitive can be “packed” per robot. The combination of the two aforementioned problems is called a Mixed Packing and Covering Problem (MPCP) young2001sequential ().

We study two versions of the problem. The first version can be formulated as a (sub)modular maximization problem subject to a partition matroid constraint nemhauser1978analysis (). A sequential greedy algorithm, where the robots take turns to greedily choose motion primitives, is known to yield a –approximation for this problem tokekar2014multi (). We evaluate the empirical performance of this algorithm by comparing it with a centralized (globally optimal) solution. The drawback of the sequential greedy algorithm is that it requires at least as many communication rounds as the number of robots. This may be too slow in practice. Consequently, we study a second version of the problem for which we present a local algorithm whose performance degrades gracefully (and provably) as a function of the number of communication rounds.

Figure 2: Communication graph. The blue shaded region indicates a radius–2 neighborhood of the red solid node. The red solid node may be unaware of the entire communication graph topology. A local algorithm that works for the red solid node only requires local information of nodes in the blue shaded region. The same local algorithm runs on all the nodes and ensures bounded approximation guarantees on the global optimality.

A local algorithm suomela2013survey () is a constant-time distributed algorithm that is independent of the size of a network. This enables a robot only to depend on local inputs in a fixed-radius neighborhood of robots (Figure 2). The robot does not need to know information beyond its local neighborhood, thereby achieving better scalability.

Floréen et al. floreen2011local () proposed a local algorithm to solve MPCP using max-min/min-max Linear Programming (LP) in a distributed manner. We show how to leverage this algorithm to solve SATA. This algorithm has a bounded communication complexity unlike typical distributed algorithms. Specifically, the algorithm yields a approximation to the globally optimal solution in synchronous communication rounds where and are input parameters.111An algorithm is called a approximation to a maximization problem if it guarantees a solution whose value is at least of the optimal value, where is some constant. We verify the theoretical results through empirical evaluation.

The contributions of this paper are as follows:

  1. We present two versions of the SATA problem.

  2. We show how to use the greedy algorithm and adapt the local algorithm for solving the two versions of the SATA problem.

  3. We perform empirical comparisons of the proposed algorithm with baseline centralized solutions.

  4. We demonstrate the applicability of the proposed algorithm through Gazebo simulations.

A preliminary version of this paper was presented at ICRA 2018 sung2018distributed (). This expanded paper extends the preliminary version with a more thorough literature survey, additional theoretical analysis, and significantly expanded empirical analysis including a description of how to implement the greedy algorithm in practice.

The rest of the paper is organized as follows. We begin by introducing the related work in Section 2. We describe the problem setup in Section 3. Our proposed distributed algorithms are presented in Section 4. We present results from representative simulations in Section 5 before concluding with a discussion of future work in Section 6.

2 Related Work

A number of algorithms have been designed to improve multi-robot coordination under limited bandwidth yan2013survey (); li2017high (); otte2013any (); otte2018dynamic (); kassir2016communication () and under communication range constraints williams2013constrained (); vander2015algorithms (); kantaros2015distributed (). This includes algorithms that enforce connectivity constraints kantaros2017distributed (); williams2015global (), explicitly trigger when to communicate dimarogonas2012distributed (); zhou2018active (); ge2017distributed1 () and operate when connectivity is intermittent best2018planning (); guo2018multirobot (). In this section, we focus on work that is most closely related to the SATA problem and local algorithms.

2.1 Multi-Robot Target Tracking

There have been many studies on cooperative target tracking in both control and robotics communities. We highlight some of the recent related work in this section. For a more comprehensive overview of multi-robot multi-target tracking, see the recent surveys khan2016cooperative (); robin2016multi ().

Charrow et al. charrow2014approximate () proposed approximate representations of the belief to design a control policy for multiple robots to track one mobile target. The proposed scheme, however, requires a centralized approach. Yu et al. yu2015cooperative () worked on an auction-based decentralized algorithm for cooperative path planning to track a moving target. Ahmad et al. ahmad2017online () presented a unified method of localizing robots and tracking a target that is scalable with respect to the number of robots. Zhou and Roumeliotis zhou2011multirobot () developed an algorithm that finds an optimal trajectory of multiple robots for the active target tracking problem. Capitan et al. capitan2013decentralized () proposed a decentralized cooperative multi-robot algorithm using auctioned partially observable Markov decision processes. The performance of decentralized data fusion under limited communication was successfully shown but theoretical bounds on communication rounds were not covered. Moreover, theoretical properties presented in the above references considered single target tracking, which may not necessarily hold in the case of tracking multiple targets in a distributed fashion.

Pimenta et al. pimenta2009simultaneous () adopted Voronoi partitioning to develop a distributed multi-target tracking algorithm. However, their objective was to cover an environment coupled with multi-target tracking. Banfi et al. banfi2018integer () addressed the fairness issue for cooperative multi-robot multi-target tracking, which is achieving balanced coverage among different targets. One of the problems that we define in Section 3 (i.e., Problem 1) has a similar motivation. However, unlike the algorithm in Banfi et al. banfi2018integer (), we are able to give a global performance guarantee. Xu et al. xu2013decentralized () presented a decentralized algorithm that jointly solves the problem of assigning robots to targets and positioning robots using mixed-integer nonlinear programming. While they proved the complexity in terms of computational time and communication (i.e., the amount of data needed to be communicated), the solution quality was only evaluated empirically. Instead, we bound the solution quality as a function of the communication rounds. Furthermore, our formulation takes as input a set of discrete actions (i.e., motion primitives) that the robot must choose from, unlike the previous work.

We study a problem similar to the one termed as Cooperative Multi-robot Observation of Multiple Moving Targets (CMOMMT) proposed by Parker and Emmons parker1997cooperative (). The objective in CMOMMT is to maximize the collective time of observing targets. Parker parker2002distributed () developed a distributed algorithm for CMOMMT that computes a local force vector to find a direction vector for each robot. We empirically compare this algorithm with our proposed one and report the results in Section 5. Kolling and Carpin kolling2007cooperative () studied the behavioral CMOMMT that added a new mode (i.e., help) to the conventional track and search modes of CMOMMT. The help mode asks other robots to track a target if the target escapes from the FOV of some robot. Although our work does not allow mode changes, previous works regarding CMOMMT did not provide theoretical optimality guarantees and did not explicitly consider scenarios where the communication bandwidth is limited. Refer to Section IV(C) of Reference khan2016cooperative () for a more detailed summary of CMOMMT.

In our prior work tokekar2014multi (), we addressed the problem of selecting trajectories for robots that can track the maximum number of targets using a team of robots. However, no bound on the number of communication rounds was presented, possibly resulting in all-to-all communication in the worst case. Instead, in this work, we introduce a new version of the problem and also explicitly bound the amount of communication required for target assignment.

2.2 Multi-Robot Task Assignment

Multi-robot task assignment can be formulated as a discrete combinatorial optimization problem. The work by Gerkey and Matarić gerkey2004formal () and the more recent work by Korsah et al. korsah2013comprehensive () contain detailed survey of this problem. There exists distributed algorithms with provable guarantees for different versions of this problem choi2009consensus (); luo2015distributed (); liu2011assessing (). There also exists various multi-robot deployment strategies for task assignment under communication constraints. These constraints include limited available information kanakia2016modeling (), limited communication flows le2012adaptive (), and connectivity requirement kantaros2016global (). See the survey papers zavlanos2011graph (); ge2017distributed2 () on these results. Ny et al. le2012adaptive () studied a formulation with a similar communication constraint as ours. However, their formulation assumed that the robots know which targets to track. In this paper, we tackle the challenge of simultaneously assigning robots to targets by choosing motion primitives with limited communication bandwidth which might degrade task performance when there are unreliable communication links and communication delays.

Turpin et al. turpin2014capt () proposed a distributed algorithm that assigns robots to goal locations while generating collision-free trajectories. Morgan et al. morgan2016swarm () solved the assignment problem by using distributed auctions and generating collision-free trajectories by using sequential convex programming. Bandyopadhyay et al. bandyopadhyay2017probabilistic () adopted the Eulerian framework for both swarm formation control and assignment. However, these works may not be suitable for target tracking applications as the targets were assumed to be static. For more survey results about SATA, see the work by Chung et al. chung2018survey (). Recently, Otte et al. otte2017multi () investigated the effect of communication quality on auction-based multi-robot task assignment. None of the above works, however, analyzed the effect of communication rounds on the solution quality, as is the focus of our work.

2.3 Local Algorithms

A local algorithm angluin1980local (); linial1992locality (); naor1995can () is a distributed algorithm that is guaranteed to achieve desired objective in a finite (typically, fixed) amount of time. The typical approach is to find approximate solutions with provable (and global) performance guarantees while ensuring a bound on the communication complexity that is independent of the number of vertices in the graph. Local algorithms have been proposed for a number of graph-theoretic problems. These include, graph matching hanckowiak2001distributed (), vertex cover aastrand2009local (); aastrand2010fast (), dominating set lenzen2010minimum (), and set cover kuhn2006price (). Suomela suomela2013survey () gives a broad survey of local algorithms. We build on this work and adapt a local algorithm for solving SATA.

3 Problem Description

Consider a scenario where multiple robots are tracking multiple mobile targets. Robots can observe targets within their FOV and predict the future states of targets. Based on predicted target states, robots decide where to move (i.e., by selecting a motion primitive) in order to keep track of targets. By discretizing time, the problem becomes one of combinatorial optimizations — choose the next position of robots based on the predicted position of the targets. Thus, we solve the SATA problem at each time step.

We define sets, and , to denote the collection of robot and target labels respectively: for robot labels and for target labels. Let and denote the set of robot states and predicted target states, respectively. In this paper, states are given by the positions of the robots and the targets in 2- or 3-dimensional space. However, the algorithms presented in this paper can be used for more complex states (e.g., 6 degree-of-freedom pose). Here, denotes the state of the robots at time . denotes the state of the targets at the next time step (i.e., at time ) predicted at time . We assume that the targets can be uniquely detected and multiple robots know if they are observing the same target. Therefore, no data association is required. Each robot independently obtains the predicted states, , by fusing its own noisy sensor measurements using, for example, a Kalman filter.

We define the labels of available motion primitives for the -th robot as These labels correspond to a set of motion primitive states of the -th robot at time given by: . Note that the term motion primitives in this paper represents the future state of a robot at the next time step (i.e., at time ) computed at time . We compute a set of the motion primitives a priori by discretizing the continuous control input space. This can be done by various methods such as uniform random sampling or biased sampling based on predicted target states. However, once a set of the motion primitives is obtained, the rest of the proposed algorithms (in Section 4) remain the same.

We define to be the set of targets that can be observed by the -th motion primitive of -th robot at time . Specifically, the -th target is said to be observable by the -th motion primitive of a robot , iff . It should be noted that only targets that were observed by robot at time are candidates to be considered for time because unobserved targets at time cannot be predicted by the robot . Note also that since is a set function, we can model complex FOV and sensing range constraints that are not necessarily restricted to 2D.

We make the following assumptions.222After these assumptions, we omit the time index (i.e., ) for notational convenience.

Assumption 1.

(Communication Range). If two robots have a motion primitive that can observe the same target, then these robots can communicate with each other. This implies if there exists a target such that and , then -th and -th robots can communicate with each other.

Assumption 2.

(Synchronous Communication). All the robots have synchronous clocks leading to synchronous rounds of communication.

From Assumption 1, neighboring robots can share their local information with each other when they observe the same targets. For example, robots can use techniques such as covariance intersection niehsen2002information () to merge their individual predictions of the target’s state into a joint prediction . This can be achieved in one round of communication when each robot simply broadcasts its own estimate of all the targets within its FOV. Note that a robot does not need to know the prediction for all the targets but only the ones that are within the FOV of one of its motion primitives. In this sense, a communication graph can be created from a sensing graph at each time, where and denote edges among robots and edges between targets and motion primitives, respectively.

As shown in Figure 1, each robot is able to compute feasible motion primitives of its own and detect multiple unique targets within the FOV. Then, the objective of the proposed problem is to choose one of the motion primitives for each robot, yielding either the best quality of tracking or the maximum number of targets tracked by the robots, depending on the application. One possible quality of tracking can be measured by the summation of all distances between selected primitives and the observed targets.

Let be the binary variable which represents the -th robot selecting the -th motion primitive. That is, if a motion primitive is selected by a robot and otherwise.333If all for a robot , then it can choose any motion primitives since the objective value will remain the same. Since each robot can choose only one motion primitive, we have:

(1)

Our objective is to find . We propose two following problems.

Problem 1 (Bottleneck).

The objective is to select primitives such that we maximize the minimum tracking quality:

(2)

subject to the constraints in Equation (1). Here, denotes weights on sensing edges between -th motion primitive of -th robot and -th target.

Here, can represent the tracking quality given by, for example, the inverse of the distance between -th motion primitive of -th robot and -th target. Alternatively, can be binary (1 when the -th motion primitive of robot sees target and otherwise) making the objective function equal to maximizing the minimum number of targets tracked.

We term this as the Bottleneck version of SATA. In the Bottleneck version, multiple robots may be assigned to the same target. We also define a Winner- TakesAll variant of SATA where only one robot is assigned to a target.

We define additional binary decision variable, . represents the -th robot assigned to track the -th target. We have, if -th robot is assigned to -th target and otherwise.

Since we restrict only one robot to be assigned to the target (unlike Bottleneck), we have:

(3)
Problem 2 (WinnerTakesAll).

The objective is to maximize the total quality of tracking given by,

(4)

subject to the constraints in Equations (1) and (3).

Both versions of the SATA problem are NP-Hard vazirani2001approximation (). The WinnerTakesAll version can be optimally solved using a Quadratic Mixed Integer Linear Programming (QMILP) in the centralized setting.444Note that Problem 2 can also be converted into a simpler Mixed Integer Linear Programming (MILP) by linearizing the product of the binary variables in Equation (4), which is not covered in this paper. Our main contributions are to show how to solve both problems in a distributed manner: an LP-relaxation of the Bottleneck variant using a local algorithm; and the WinnerTakesAll variant using a greedy algorithm. The following theorems summarize the main contributions of our work.

Theorem 3.1.

Let be the maximum number of motion primitives per robot and be the maximum number of motion primitives that can see a target. There exists a local algorithm that finds an approximation in synchronous communication rounds for the LP-relaxation of the Bottleneck version of SATA problem, where and are parameters.

The proof follows directly from the existence of the local algorithm described in the next section. We show how the local algorithm for MPCP can be modified to solve SATA by means of a linear relaxation.

Theorem 3.2.

There exists a –approximation greedy algorithm for the WinnerTakesAll version of the SATA problem for any in polynomial time.

This directly follows from the fact that the problem is a modular maximization problem subject to a partition matroid constraint nemhauser1978analysis (). The algorithms are described in the next section.

4 Distributed Algorithms

We begin by describing the local algorithm that solves the Bottleneck version of SATA.

4.1 Local Algorithm

In this section, we show how to solve the Bottleneck version of the SATA problem using a local algorithm. We adapt the local algorithm for solving max-min LPs given by Floréen et al. floreen2011local () to solve the SATA problem in a distributed manner.

Consider the tripartite, weighted, and undirected graph, shown in Figure 3. Each edge is either with weight 1 or with weight . The maximum degree among robot nodes is denoted by and among target nodes is . Each motion primitive is associated with a variable . The upper two layers of in Figure 3 are related with a packing problem (Equation (4)). The lower two layers are related with the covering problem.

Lemma 1.

The Bottleneck version (Equation (2)) can be rewritten as a linear relaxation of ILP:

(5)

The proof is given in Appendix A.

Figure 3: One instance of a graph for MPCP when there are three robot nodes, six motion primitive nodes and three target nodes.

Floréen et al. floreen2011local () presented a local algorithm to solve MPCP in Equation (5) in a distributed fashion. They presented both positive and negative results for MPCP. We show how to adopt this algorithm for solving the Bottleneck version of SATA.

Figure 4: Flowchart of the proposed local algorithm.

An overview of our algorithm is given in Figure 4. We describe the main steps in the following.

4.1.1 Local Algorithm from Reference floreen2011local ()

The local algorithm in Reference floreen2011local () requires . However, they also present a simple local technique to split nodes in the original graph with into multiple nodes making . Then, a layered max-min LP is constructed with layers, as shown in Figure 5. is a user-defined parameter that allows to trade-off computational time with optimality. If the number of layers is set to , then it means that a robot can communicate with another robot that is no more than communication edges (i.e., hops) away. The layered graph breaks the symmetry that inherently exists in the original graph. This layered mechanism is specifically designed for solving MPCP and is covered in depth in Section 4 of Reference floreen2011local (). We omit the details in this paper due to limited space and redirect the readers to Section 4 of Reference floreen2011local () for the construction of the layered graph.

Figure 5: Graph of the layered max-min LP with that is obtained from the original graph of Figure 3 after applying the local algorithm. The details for constructing a layered graph are given in Section 4 of Reference floreen2011local (). Each motion primitive is colored either red or blue to break the symmetry of the original graph. Squares, circles, and triangles represent robot nodes, motion primitive nodes, and target nodes, respectively, corresponding to Figure 3.

They proposed a recursive algorithm to compute a solution of the layered max-min LP. The solution for the original max-min LP can be obtained by mapping from the solution of the layered one. The obtained solution corresponds to values of . They proved that the resulting algorithm gives a constant-factor approximation ratio.

Theorem 4.1.

There exists local approximation algorithms for max-min and min-max LPs with the approximation ratio for any , , and , where denotes the number of layers.

Proof.

Please refer to Corollary 4.7 from Reference floreen2011local () for a proof. ∎

Note that each node in the layered graph carries out its local computation (details of the local computation for solving SATA are included in Reference floreen2011local ()). Each node also receives and sends information from and to neighbors at each synchronous communication round. Constructing the layered graph is done in a local fashion without requiring any single robot to know the entire graph.

4.1.2 Realization of Local Algorithm for SATA

To apply the local algorithm of Section 4.1.1 to a distributed SATA problem, each node and edge in a layered graph must be realized at each time step (i.e., generating a graph shown in Figure 5 which becomes the input to the local algorithm floreen2011local ()). In our case, the only computational units are the robots. Nodes that correspond to motion primitives, , can be realized by the corresponding robot . Moreover, nodes corresponding to the targets must also be realized by robots. A target is realized by a robot satisfying . If there are multiple robots whose motion primitives can sense the target (by Assumption 1), they can arbitrarily decide which amongst them realizes the target nodes in a constant number of communication rounds.

After applying the local algorithm of Section 4.1.1 to robots, each robot obtains on corresponding at each time. However, due to the LP relaxation, will not necessarily be binary, as in Equation (1). For each robot we set the highest equal to one and all others as zero. We shortly show that the resulting solution after rounding is still close to optimal in practice. Furthermore, increasing the parameter finds solutions that are close to binary.

The following pseudo-code explains the overall scheme of each robot for a distributed SATA. We solve the SATA problem at each time step.

1 for  do
2       ComputeMotionPrimitives(). Find targets that can be sensed by -th motion primitive of -th robot (). Construct a -hop communication graph. Apply local algorithm floreen2011local (). Rounding(). Motion primitive with . ApplyAction(). .
3 end for
Algorithm 1 Local algorithm

4.1.3 Advantages of the Local Algorithm

It is possible that there are some robots that are isolated from the others. That is, the communication graph or the layered graph may be disconnected. However, each component of the graph can run the local algorithm independently without affecting the solution quality. Furthermore, if a robot is disconnected from the rest, then it can take a greedy approach as described in Reference tokekar2014multi () before they reach any other robots to communicate.

The algorithm also allows for the number of robots and targets to change over time. Since each robot determines its neighbors at each time step, any new robots or targets will be identified and become part of the time-varying local layered graphs. The robots can also be anonymous (as long as they can break the symmetry to determine which robot, amongst a set, will realize the target node, when multiple robots can observe the same target).

The number of layers, , directly affects the solution quality and can be set by the user. Increasing results in better solutions at the expense of more communication. is equivalent to the greedy approach where no robots communicate with each other.

0.5000 0.5000 0.5000

0.5000 0.5000 0.5000
0.6667 0.7591 0.7855

0.3333 0.2409 0.2145
0.3333 0.2409 0.2145

0.6667 0.7591 0.7855
Table 1: Solution returned by the local algorithm for the example shown in Figure 3, with all edges’ weights set to , as a function of .

The above table shows the result of applying the local algorithm to the graph in Figure 3 when all edge weights were set to . Three different values for were tested: , , and . In all cases, and have larger values of than other nodes. Thus, the robot 2 () and the robot 3 () will select the motion primitive () and the motion primitive (), respectively, after employing a rounding technique to ’s.

As the number of layers increases, the more distinct the values returned by the algorithm. Another interesting observation is that robot has the same equal value on both motion primitives of its own no matter how many number of layers are used. This is because all the targets are already observed by robots and with higher values.

4.2 Greedy Algorithm

The greedy algorithm requires a specific ordering of the robots given in advance. The first robot greedily chooses a motion primitive that can maximize the number of targets being observed. Those observed targets are removed from the consideration. Then, the second robot makes its choice; this repeats for the rest of robots. If the communication graph is disconnected and forms more than one connected component, the greedy algorithm can independently be applied to each connected component without modifying the algorithm. Note again that the greedy algorithm is for the WinnerTakesAll version of SATA.

Input : Order of robots .
1 Initialize . for  do
2       for  do
3             Compute . .
4       end for
5      Determine . Update .
6 end for
7. for  do
8       . .
9 end for
Algorithm 2 Greedy algorithm

As shown in Algorithm 2, the greedy algorithm runs in communication rounds at each time step. We define two additional functions: gives a quality of tracking for -th target; and gives the sum of quality of tracking over all feasible targets using -th motion primitive of -th robot. If, for example, is used as a distance metric, the ensures that the quality of tracking for -th target is only given by the distance of the nearest robot/primitive. That is, even if multiple primitives can track the same target , when counting the quality we only care about the closest one. The total quality will then be the sum of qualities for each target.

The objective in Line 5 in Algorithm 2 appears, at first sight, to be different than that given in Equation (4). The following lemma, however, proves that the two objectives are equivalent.

Lemma 2.

Greedy algorithm of Algorithm 2 gives a feasible solution for the WinnerTakesAll version of SA- TA.

The proof is given in Appendix B. Since the objective in Line 5 in Algorithm 2 is submodular, the resulting algorithm yields a –approximation to WinnerTakes- All nemhauser1978analysis ().

The greedy algorithm can perform arbitrarily worse than the optimal solution if it is applied to the Bottlene- ck version of the problem. In Appendix C, we show an example where the greedy yields an arbitrarily bad solution for the Bottleneck version.

A centralized-equivalent approach is one where the robots all broadcast their local information until some robot has received information from all others. This robot can obtain a centralized solution to the problem. A centralized-equivalent approach for a complete runs in 2 communication rounds for receiving and sending data to neighbors. However, the greedy algorithm and local algorithm have and communication rounds, respectively, for a complete . Note that for most practical cases.

5 Simulations

We carried out four types of simulations to verify the efficacy of the proposed algorithms under the condition that the amount of time required for communication is limited. First, we compare the performance of the greedy and local algorithms with centralized, optimal solutions. Second, we study the effect of varying the parameters (i.e., the number of layers) for the local algorithm. Third, we describe how to implement the algorithms for sequential planning over multiple horizons and evaluate their performance over time. Last, we compare the greedy algorithm with a state-of-the-art distributed tracking algorithm.

5.1 Comparisons with Centralized Solutions

We performed comparison studies to verify the performance of the proposed algorithms. We compared the greedy solution with the optimal, centralized QMILP solution as well as a random algorithm as a baseline for the WinnerTakesAll version. We compared the local algorithm’s solution with the optimal ILP solution as well as the LP with rounding for Bottleneck. For these comparisons, we assumed that there are only two primitives to choose from (making the random algorithm a powerful baseline). We later analyzed the algorithms with more primitives. We used TOMLAB QMILP () to solve the QMILP and ILP problems. The toolbox works with MATLAB and uses IBM’s CPLEX optimizer in the background. On a laptop with processor configuration of Intel® Core™ i7-5500U CPU @ 2.40GHz x 4 and 16 GB of memory the maximum time to solve was around seconds on a case with 150 targets. Most of our cases were solved in less than seconds.

We randomly generated graphs similar to Figure 3 for the comparison. To control the topology of the randomly generated graphs, we defined to be the percentage of targets that are detected by a motion primitive. We denote the average degree of edges by . Therefore:

(6)

We started with the upper half of the graph, connecting each robot to its two motion primitives. Then, we iterated through each of motion primitive and randomly chose a target node to create an edge. Next, we iterated through target nodes and randomly chose a motion primitive to create an edge. We also added random edges to connect disconnected components (to keep the implementation simpler). We repeated this in order to get the required graph. If we needed to increase the degree of target nodes in the graph, we created new edges to random primitives till we achieved the desired . We generated cases by varying , number of targets, and number of robots using the method described above. Here, the tracking quality was defined as the number of targets, i.e., for all cases.

Figure 6: Showing the comparative results of QMILP, greedy algorithm, and randomly choosing a motion primitive for WinnerTakesAll. To generate the graphs, we varied number of robots, total number of targets, and . We ran 100 trials for each case.

The comparative simulation results for WinnerTakes- All are presented in Figure 6. The plots show minimum, maximum, and average of the targets covered by the greedy algorithm and QMILP running 100 random instances for every setting of the parameters. We also show the number of targets covered when choosing motion primitives randomly as a baseline. We observe that the greedy algorithm performs comparatively to the optimal algorithm, and is always better than the baseline. In all the figures, , making random a relatively powerful baseline. The difference between the greedy algorithm and the baseline becomes smaller as increases. This could be because of the fact that the baseline saturates at the maximum objective value with fewer robots as increases. As , number of targets, and number of robots increase, the performance of the greedy algorithm also improves.

Figure 7: Comparison simulation for the Bottleneck version of the ILP, LP with rounding, local algorithm and randomly choosing a motion primitive. We set to 2 in the local algorithm, for all cases. Each case was obtained from 100 trials.

Figure 7 shows the comparison results for Bottlene- ck where the objective values were computed from the term of Equation (5). As the proposed local algorithm is a linear relaxation of the ILP formulation, we compared the local solution with the optimal ILP solution. Note that both the ILP and LP with rounding are centralized methods. If the solution value is , this means that at least one target is not covered by any selected motion primitives. The specific configuration of input motion primitives and target states is such that no matter what motion primitives are chosen, at least one target will be left uncovered. This means that the bottleneck objective (i.e., the optimal value of ILP) is . If the mean value is larger than , this implies that all targets are covered by at least one motion primitive on average. The ILP and LP with rounding outperform the local algorithm in all cases. Nevertheless, we find that the local algorithm performs comparably to the centralized methods (and far better than the theoretical bound).

5.2 Effect of for the Local Algorithm

(a) LP with rounding.
(b) LP without rounding.
Figure 8: Analysis of varying the number of layers () for the local algorithm. The number of targets used is and . We ran 100 trials for each case.

We analyzed the performance of the local algorithm for different number of layers (i.e., ), as shown in Figure 8. The LP value (without rounding) is the upper bound on the optimal solution. We observed how much the rounding sacrifices by comparing the LP with and without the rounding. In the case where was set to and for both with and without the rounding, there is no evident difference between them. This implies that should not necessarily be large as it does not contribute to the solution quality much (as also seen in Theorem 3.1). In other words, the local algorithm does not require a large number of communication hops among robots, which is a powerful feature of the local algorithm.

5.3 Multi-robot Multi-target Tracking over Time

The greedy and local algorithms find the motion primitives to be applied over a single horizon. In order to track over time, the SATA problem will need to be solved repeatedly at each time step. In this section, we describe how to address this and other challenges associated with a practical implementation. We demonstrate a realistic scenario of cooperative multi-target tracking in the Gazebo simulator using ROS (Figure 9). A bounded environment consists of dynamic targets that move in a straight line and change their heading direction randomly after a certain period. The motion model is not known to the robots.

Figure 9: Gazebo simulator showing ten robots tracking thirty randomly moving targets. We set the sensing and communication ranges to and , respectively.
Greedy Algorithm.

We implemented the greedy algorithm to solve the WinnerTakesAll variant in a fully distributed fashion. There was no centralized algorithm and each robot was a separate ROS node that only had access to the local information. Each robot had its local estimator that estimated the state of targets within its FOV. We simulated proximity-limited communication range such that only robots that can see the same target can exchange messages with each other.

A sketch for the implementation of the greedy algorithm is as follows. Each robot has a local timer which is synchronized with the others. Each robot also knows its own ID which is also the order in which the sequential decisions are made. We partition the planning horizon into two periods. In the first selection period, the robots choose their own primitives sequentially using the greedy algorithm. In the second execution period, the robots apply their motion primitives and obtain measurements of the target.

In the selection period, a robot waits for the predecessor robots (of lower IDs) to make their selections. Every robot knows when it is its turn to select a motion primitive (since the order is fixed). Before its turn, a robot simply keeps track of the most recent vector received from a predecessor robot within communication range. During its turn, the robot chooses its motion primitive using the greedy algorithm, and updates the vector based on its choice. It then broadcasts this updated vector to the neighbors, and waits for the selection period to end. Then, each robot applies its selected motion primitive till the end of the horizon. The process repeats after each planning horizon. The selection period can be preceded by a sensor fusion period, where the robots can execute, for example, the covariance intersection algorithm niehsen2002information ().

For simulations we set the selection and execution periods times to and , respectively, where is the number of robots. Each robot made its choice after within the selection period. Each robot had a precomputed library of 21 motion primitives including staying in place. It should be noted that our algorithms do not require a motion primitive of stay in place. Each robot had a disk-shaped FOV. The sensing and communication ranges were set to and , respectively. We tested both the inverse of the distance and the number of targets as tracking quality (which defines ).

We carried out simulations using ten robots tracking thirty moving targets, as shown in Figure 9. Initial positions of robots and targets were randomly chosen in a square environment. It may be possible that some targets were outside the FOV of any robots in the beginning.

Figure 10: Change in the number of targets over time when ten robots are tracking thirty moving targets.
(a) Actual number of targets.
(b) Estimated number of targets.
Figure 11: Histogram of the number of targets.

Figure 10 shows the change in the number of targets over time from a randomly generated instance where the objective was to track the most number of targets. We show both the estimated number of targets and the actual number of targets. The estimated number is the value of the solution found at the end of the selection period (obtained every ). This is based on the predicted trajectory of the targets.555Although we model linear motion for the targets, more sophisticated models for the prediction of target states can also be employed. The actual number of targets was found by counting the target that is within the FOV of any robots during the execution period. Figure 11 shows the histogram of the actual and estimated number of targets for 10 trials, each lasting three minutes.

Figure 12: Change in the inverse of the distance over time when ten robots are tracking thirty moving targets.
(a) Actual inverse distance.
(b) Estimated inverse distance.
Figure 13: Histogram of the inverse distance.

Figures 12 and 13 show the corresponding plots when the objective was to maximize the total quality of tracking (inverse distance to the targets). Here, we saw that the estimated and the actual values differed much more than the previous case. We conjectured that this was due to the fact that the uncertainty in the motion model of the robots, targets, and measurements had a larger effect on the actual quality of tracking as compared to the number of targets tracked. For instance, even if the actual state of the target deviates from the predicted state, it is still likely that the target will be in the FOV. However, the actual distance between the robot and the target may be much larger than estimated.

Figure 14: Snapshot of the Gazebo simulator that shows when five robots are tracking thirty stationary and moving targets. The sensing and communication ranges were set to 3 and , respectively.
Local Algorithm.

We also implemented the proposed local algorithm as shown in Figure 14. Five mobile robots were deployed to track thirty targets (a subset of which were mobile) with a FOV of 3 on the xy plane. For each robot two motion primitives were used: one was to remain in the same position and the other one was randomly generated between and of the robot’s heading traveling randomly up to .

Figure 15: Plot of trajectories of robots and targets applying the local algorithm to the simulation given in Figure 14. Black lines represent trajectories of thirty targets. denotes the end position of trajectories. The algorithm was performed for 40 seconds.
(a) Total number of targets observed.
(b) Average number of targets observed over time.
Figure 16: Change in the total and average number of targets being observed by any robots over time.

The objective of this simulation is to show the performance of the proposed algorithm for the Bottleneck version. At each time step, the local algorithm was employed to choose motion primitives that maximize the minimum number of targets being observed by any robots.

Figure 15 shows the resultant trajectories of robots and targets obtained from the simulation. Figure 16 presents the (total/average) number of targets tracked by the local algorithm for a specific instance. Although the local algorithm has a sub-optimal performance guarantee, we observe that in practice, it performs comparably to the optimal path.

5.4 Comparison of the Greedy Algorithm with Other CMOMMT Algorithm

We compared the greedy algorithm with an algorithm proposed by Parker parker2002distributed () following the CMOMMT approach. This algorithm addresses the same objective as the WinnerTakesAll. Parker’s algorithm computes a local force vector for all robots (attraction by nearby targets and repulsion by other nearby robots). It does not require any central unit to determine their motion primitives and considers limited sensing and communication ranges, similar to this paper. Parker’s algorithm determines the moving direction of robots by using the local force vector and moves the robots along this direction until they meet the available maneuverability at each time step. However, no theoretic guarantee with respect to the optimal solution was provided by this algorithm.

We created an environment of square for comparison using MATLAB. The robots can move per time step while the targets can move per time step and randomly changed their direction every time steps. If the targets met the boundary of the environment, they picked a random direction that kept them within the environment. In each instance, robots and targets were randomly located initially. The sensing and communication ranges were set to and , respectively.

We empirically studied two cases: the first is to evaluate the objective value of the proposed greedy algorithm and Parker’s algorithm for the same problem instance at a given time step; and the second is to apply the two algorithms over time steps starting from the same configuration.

Figure 17: Comparison with the Parker’s algorithm parker2002distributed (). (a) instances were run. (b) time steps were run. (c) time steps were run to compare the metric proposed by Parker parker2002distributed (). We used robots for all cases. We ran trials for (b) and (c). Bar graphs show the mean and standard deviation for different number of targets (, and targets).

When both algorithms were applied to the same problem setup (Figure 17(a)), the objective values for both algorithms increased as the number of targets increased. Nevertheless, the greedy algorithm outperformed Parker’s algorithm. This can be attributed to the fact that Parker’s algorithm computes the local force vector based on a heuristic (get closer to the targets) but does not explicitly optimize the objective function of WinnerTakesAll. In Figures 17(b) and 17(c), similar results can be seen when both algorithms generate different trajectories for robots after time steps. The comparison measure used in Figure 17(c) is the average of the objective value over time, first proposed by Parker parker2002distributed (). These empirical simulations show the superior performance of the greedy algorithm over the existing method.

In summary, we find that our algorithms perform comparably with centralized, optimal algorithms and outperform the baseline algorithm. We also find that greedy algorithm has better performance than the decentralized algorithm from Parker parker2002distributed (). In theory, the performance bound for the local algorithm worsens as , the amount of communication available, decreases. However, in practice, we find that the local algorithm does not require a large number of layers to yield good performance, which reduces the computational and communication burden.

6 Conclusion

This paper gives a new approach to solve the multi-robot multi-target assignment problem using greedy and local algorithms. Our work is motivated by scenarios where the robots would like to reduce their communication to solve the given assignment problem while at the same time maintaining some guarantees of tracking. We used powerful local communication framework employed by Floréen et al. floreen2011local () to leverage an algorithm that can trade-off the optimality with communication complexity. We empirically evaluated this algorithm and compared it with the baseline greedy strategies.

Our immediate future work is to expand the scope of the problem to solve both versions of SATA over multiple horizons. In principle, we can replace each motion primitive input with a longer horizon trajectory and plan for multiple time steps (say, time steps). However, this comes at the expense of increased number of trajectories to choose from which will result in increased computational time. Furthermore, planning for a longer horizon will require prediction of targets’ states far in the future which can lead to poorer tracking performance. We are also working on implementing the resulting algorithms on actual aerial robotic systems to carry out real-world experimentation.

Acknowledgement

The authors would like to thank Dr. Jukka Suomela from Aalto University for fruitful discussion.

References

  • (1) L. E. Parker and B. A. Emmons, “Cooperative multi-robot observation of multiple moving targets,” in Robotics and Automation, 1997. Proceedings., 1997 IEEE International Conference on, vol. 3.   IEEE, 1997, pp. 2082–2089.
  • (2) L. E. Parker, “Distributed algorithms for multi-robot observation of multiple moving targets,” Autonomous robots, vol. 12, no. 3, pp. 231–255, 2002.
  • (3) C. F. Touzet, “Robot awareness in cooperative mobile robot learning,” Autonomous Robots, vol. 8, no. 1, pp. 87–97, 2000.
  • (4) A. Kolling and S. Carpin, “Cooperative observation of multiple moving targets: an algorithm and its formalization,” The International Journal of Robotics Research, vol. 26, no. 9, pp. 935–953, 2007.
  • (5) W. Hönig and N. Ayanian, “Dynamic multi-target coverage with robotic cameras,” in Intelligent Robots and Systems (IROS), 2016 IEEE/RSJ International Conference on.   IEEE, 2016, pp. 1871–1878.
  • (6) B. Gharesifard and S. L. Smith, “Distributed submodular maximization with limited information,” IEEE Transactions on Control of Network Systems, 2017.
  • (7) T. Howard, M. Pivtoraiko, R. A. Knepper, and A. Kelly, “Model-predictive motion planning: several key developments for autonomous mobile robots,” IEEE Robotics & Automation Magazine, vol. 21, no. 1, pp. 64–73, 2014.
  • (8) J. Suomela, “Survey of local algorithms,” ACM Computing Surveys (CSUR), vol. 45, no. 2, p. 24, 2013.
  • (9) N. E. Young, “Sequential and parallel algorithms for mixed packing and covering,” in Foundations of Computer Science, 2001. Proceedings. 42nd IEEE Symposium on.   IEEE, 2001, pp. 538–546.
  • (10) G. L. Nemhauser, L. A. Wolsey, and M. L. Fisher, “An analysis of approximations for maximizing submodular set functions—1,” Mathematical programming, vol. 14, no. 1, pp. 265–294, 1978.
  • (11) P. Tokekar, V. Isler, and A. Franchi, “Multi-target visual tracking with aerial robots,” in 2014 IEEE/RSJ International Conference on Intelligent Robots and Systems.   IEEE, 2014, pp. 3067–3072.
  • (12) P. Floréen, M. Hassinen, J. Kaasinen, P. Kaski, T. Musto, and J. Suomela, “Local approximability of max-min and min-max linear programs,” Theory of Computing Systems, vol. 49, no. 4, pp. 672–697, 2011.
  • (13) Y. Sung, A. K. Budhiraja, R. K. Williams, and P. Tokekar, “Distributed simultaneous action and target assignment for multi-robot multi-target tracking,” in 2018 IEEE International Conference on Robotics and Automation (ICRA).   IEEE, 2018, pp. 1–9.
  • (14) Z. Yan, N. Jouandeau, and A. A. Cherif, “A survey and analysis of multi-robot coordination,” International Journal of Advanced Robotic Systems, vol. 10, no. 12, p. 399, 2013.
  • (15) H. Li, G. Chen, T. Huang, and Z. Dong, “High-performance consensus control in networked systems with limited bandwidth communication and time-varying directed topologies,” IEEE transactions on neural networks and learning systems, vol. 28, no. 5, pp. 1043–1054, 2017.
  • (16) M. Otte and N. Correll, “Any-com multi-robot path-planning: Maximizing collaboration for variable bandwidth,” in Distributed Autonomous Robotic Systems.   Springer, 2013, pp. 161–173.
  • (17) ——, “Dynamic teams of robots as ad hoc distributed computers: reducing the complexity of multi-robot motion planning via subspace selection,” Autonomous Robots, pp. 1–23, 2018.
  • (18) A. Kassir, R. Fitch, and S. Sukkarieh, “Communication-efficient motion coordination and data fusion in information gathering teams,” in Intelligent Robots and Systems (IROS), 2016 IEEE/RSJ International Conference on.   IEEE, 2016, pp. 5258–5265.
  • (19) R. K. Williams and G. S. Sukhatme, “Constrained interaction and coordination in proximity-limited multiagent systems,” IEEE Transactions on Robotics, vol. 29, no. 4, pp. 930–944, 2013.
  • (20) J. Vander Hook, P. Tokekar, and V. Isler, “Algorithms for cooperative active localization of static targets with mobile bearing sensors under communication constraints,” IEEE Transactions on Robotics, vol. 31, no. 4, pp. 864–876, 2015.
  • (21) Y. Kantaros, M. Thanou, and A. Tzes, “Distributed coverage control for concave areas by a heterogeneous robot–swarm with visibility sensing constraints,” Automatica, vol. 53, pp. 195–207, 2015.
  • (22) Y. Kantaros and M. M. Zavlanos, “Distributed intermittent connectivity control of mobile robot networks,” IEEE Transactions on Automatic Control, vol. 62, no. 7, pp. 3109–3121, 2017.
  • (23) R. K. Williams, A. Gasparri, G. S. Sukhatme, and G. Ulivi, “Global connectivity control for spatially interacting multi-robot systems with unicycle kinematics,” in Robotics and Automation (ICRA), 2015 IEEE International Conference on.   IEEE, 2015, pp. 1255–1261.
  • (24) D. V. Dimarogonas, E. Frazzoli, and K. H. Johansson, “Distributed event-triggered control for multi-agent systems,” IEEE Transactions on Automatic Control, vol. 57, no. 5, pp. 1291–1297, 2012.
  • (25) L. Zhou and P. Tokekar, “Active target tracking with self-triggered communications in multi-robot teams,” IEEE Transactions on Automation Science and Engineering, no. 99, pp. 1–12, 2018.
  • (26) X. Ge and Q.-L. Han, “Distributed formation control of networked multi-agent systems using a dynamic event-triggered communication mechanism,” IEEE Transactions on Industrial Electronics, vol. 64, no. 10, pp. 8118–8127, 2017.
  • (27) G. Best, M. Forrai, R. R. Mettu, and R. Fitch, “Planning-aware communication for decentralised multi-robot coordination,” in Proceedings of the International Conference on Robotics and Automation, Brisbane, Australia, vol. 21, 2018.
  • (28) M. Guo and M. M. Zavlanos, “Multirobot data gathering under buffer constraints and intermittent communication,” IEEE Transactions on Robotics, 2018.
  • (29) A. Khan, B. Rinner, and A. Cavallaro, “Cooperative robots to observe moving targets: Review,” IEEE Transactions on Cybernetics, 2016.
  • (30) C. Robin and S. Lacroix, “Multi-robot target detection and tracking: taxonomy and survey,” Autonomous Robots, vol. 40, no. 4, pp. 729–760, 2016.
  • (31) B. Charrow, V. Kumar, and N. Michael, “Approximate representations for multi-robot control policies that maximize mutual information,” Autonomous Robots, vol. 37, no. 4, pp. 383–400, 2014.
  • (32) H. Yu, K. Meier, M. Argyle, and R. W. Beard, “Cooperative path planning for target tracking in urban environments using unmanned air and ground vehicles,” IEEE/ASME Transactions on Mechatronics, vol. 20, no. 2, pp. 541–552, 2015.
  • (33) A. Ahmad, G. Lawless, and P. Lima, “An online scalable approach to unified multirobot cooperative localization and object tracking,” IEEE Transactions on Robotics, vol. 33, no. 5, pp. 1184–1199, 2017.
  • (34) K. Zhou, S. I. Roumeliotis, et al., “Multirobot active target tracking with combinations of relative observations,” IEEE Transactions on Robotics, vol. 27, no. 4, pp. 678–695, 2011.
  • (35) J. Capitan, M. T. Spaan, L. Merino, and A. Ollero, “Decentralized multi-robot cooperation with auctioned pomdps,” The International Journal of Robotics Research, vol. 32, no. 6, pp. 650–671, 2013.
  • (36) L. C. Pimenta, M. Schwager, Q. Lindsey, V. Kumar, D. Rus, R. C. Mesquita, and G. A. Pereira, “Simultaneous coverage and tracking (scat) of moving targets with robot networks,” in Algorithmic foundation of robotics VIII.   Springer, 2009, pp. 85–99.
  • (37) J. Banfi, J. Guzzi, F. Amigoni, E. F. Flushing, A. Giusti, L. Gambardella, and G. A. Di Caro, “An integer linear programming model for fair multitarget tracking in cooperative multirobot systems,” Autonomous Robots, pp. 1–16, 2018.
  • (38) Z. Xu, R. Fitch, J. Underwood, and S. Sukkarieh, “Decentralized coordinated tracking with mixed discrete–continuous decisions,” Journal of Field Robotics, vol. 30, no. 5, pp. 717–740, 2013.
  • (39) B. P. Gerkey and M. J. Matarić, “A formal analysis and taxonomy of task allocation in multi-robot systems,” The International Journal of Robotics Research, vol. 23, no. 9, pp. 939–954, 2004.
  • (40) G. A. Korsah, A. Stentz, and M. B. Dias, “A comprehensive taxonomy for multi-robot task allocation,” The International Journal of Robotics Research, vol. 32, no. 12, pp. 1495–1512, 2013.
  • (41) H.-L. Choi, L. Brunet, and J. P. How, “Consensus-based decentralized auctions for robust task allocation,” IEEE transactions on robotics, vol. 25, no. 4, pp. 912–926, 2009.
  • (42) L. Luo, N. Chakraborty, and K. Sycara, “Distributed algorithms for multirobot task assignment with task deadline constraints,” IEEE Transactions on Automation Science and Engineering, vol. 12, no. 3, pp. 876–888, 2015.
  • (43) L. Liu and D. A. Shell, “Assessing optimal assignment under uncertainty: An interval-based algorithm,” The International Journal of Robotics Research, vol. 30, no. 7, pp. 936–953, 2011.
  • (44) A. Kanakia, B. Touri, and N. Correll, “Modeling multi-robot task allocation with limited information as global game,” Swarm Intelligence, vol. 10, no. 2, pp. 147–160, 2016.
  • (45) J. Le Ny, A. Ribeiro, and G. J. Pappas, “Adaptive communication-constrained deployment of unmanned vehicle systems,” IEEE Journal on Selected Areas in Communications, vol. 30, no. 5, pp. 923–934, 2012.
  • (46) Y. Kantaros and M. M. Zavlanos, “Global planning for multi-robot communication networks in complex environments.” IEEE Trans. Robotics, vol. 32, no. 5, pp. 1045–1061, 2016.
  • (47) M. M. Zavlanos, M. B. Egerstedt, and G. J. Pappas, “Graph-theoretic connectivity control of mobile robot networks,” Proceedings of the IEEE, vol. 99, no. 9, pp. 1525–1540, 2011.
  • (48) X. Ge, F. Yang, and Q.-L. Han, “Distributed networked control systems: A brief overview,” Information Sciences, vol. 380, pp. 117–131, 2017.
  • (49) M. Turpin, N. Michael, and V. Kumar, “Capt: Concurrent assignment and planning of trajectories for multiple robots,” The International Journal of Robotics Research, vol. 33, no. 1, pp. 98–112, 2014.
  • (50) D. Morgan, G. P. Subramanian, S.-J. Chung, and F. Y. Hadaegh, “Swarm assignment and trajectory optimization using variable-swarm, distributed auction assignment and sequential convex programming,” The International Journal of Robotics Research, vol. 35, no. 10, pp. 1261–1285, 2016.
  • (51) S. Bandyopadhyay, S.-J. Chung, and F. Y. Hadaegh, “Probabilistic and distributed control of a large-scale swarm of autonomous agents,” IEEE Transactions on Robotics, vol. 33, no. 5, pp. 1103–1123, 2017.
  • (52) S.-J. Chung, A. Paranjape, P. Dames, S. Shen, and V. Kumar, “A Survey on Aerial Swarm Robotics,” IEEE Transactions on Robotics, 2018.
  • (53) M. Otte, M. Kuhlman, and D. Sofge, “Multi-robot task allocation with auctions in harsh communication environments,” in Multi-Robot and Multi-Agent Systems (MRS), 2017 International Symposium on.   IEEE, 2017, pp. 32–39.
  • (54) D. Angluin, “Local and global properties in networks of processors,” in Proceedings of the twelfth annual ACM symposium on Theory of computing.   ACM, 1980, pp. 82–93.
  • (55) N. Linial, “Locality in distributed graph algorithms,” SIAM Journal on Computing, vol. 21, no. 1, pp. 193–201, 1992.
  • (56) M. Naor and L. Stockmeyer, “What can be computed locally?” SIAM Journal on Computing, vol. 24, no. 6, pp. 1259–1277, 1995.
  • (57) M. Hanckowiak, M. Karonski, and A. Panconesi, “On the distributed complexity of computing maximal matchings,” SIAM Journal on Discrete Mathematics, vol. 15, no. 1, pp. 41–57, 2001.
  • (58) M. Åstrand, P. Floréen, V. Polishchuk, J. Rybicki, J. Suomela, and J. Uitto, “A local 2-approximation algorithm for the vertex cover problem,” in International Symposium on Distributed Computing.   Springer, 2009, pp. 191–205.
  • (59) M. Åstrand and J. Suomela, “Fast distributed approximation algorithms for vertex cover and set cover in anonymous networks,” in Proceedings of the twenty-second annual ACM symposium on Parallelism in algorithms and architectures.   ACM, 2010, pp. 294–302.
  • (60) C. Lenzen and R. Wattenhofer, “Minimum dominating set approximation in graphs of bounded arboricity,” in International Symposium on Distributed Computing.   Springer, 2010, pp. 510–524.
  • (61) F. Kuhn, T. Moscibroda, and R. Wattenhofer, “The price of being near-sighted,” in Proceedings of the seventeenth annual ACM-SIAM symposium on Discrete algorithm.   Society for Industrial and Applied Mathematics, 2006, pp. 980–989.
  • (62) W. Niehsen, “Information fusion based on fast covariance intersection filtering,” in Information Fusion, 2002. Proceedings of the Fifth International Conference on, vol. 2.   IEEE, 2002, pp. 901–904.
  • (63) V. Vazirani, Approximation algorithms.   Springer Publishing Company, Incorporated, 2001.
  • (64) “Tomlab: Optimization environment large-scale optimization in matlab,” http://tomopt.com/docs/quickguide/quickguide006.php, accessed: 2017-01-03.

Appendix A Proof of Lemma 1

Equation (5) of a max-min linear program is equivalent to the following max-min problem if the scalar variable which represents the inner minimization is eliminated:

(7)

From Equations (5) and (7), the following relationship is satisfied:

(8)

Since Equation (2) does not require to be a linear value, Equation (2) is equivalent to Equation (5) with additional integer constraints.

Appendix B Proof of Lemma 2

Considering , which is a weight between -th motion primitive of -th robot and -th target on graph , a quality of tracking () for -th target can be defined as follows:

(9)

Therefore, the sum of quality of tracking over all targets is:

(10)

Equation (10) is obtained by taking into account the conditional term of the first equation explicitly. The last equation follows from the property that chooses the maximum value of among all robots, which is shown in lines 10-14 of Algorithm 2. Therefore, the last equation is equal to the inner term of Equation (4).

Appendix C Greedy Performs Poorly for the Bottleneck Variant

We present an example of instance that shows an arbitrary poor performance of the greedy algorithm when applied to the Bottleneck variant. Consider the following case where there are two robots () having two motion primitives () for each and two targets. The realization of the communication and sensing graphs are as in the following table. The tracking quality in this example corresponds to the number of targets being tracked.

, ,

Let’s apply the Bottleneck version of greedy algorithm to this case. Since the objective of the Bottleneck variant is to maximize the minimum tracking quality, the robot () chooses motion primitive () because choosing motion primitive () gives the value of while choosing motion primitive () gives the value of . For the same reason, the robot () chooses motion primitive (). This gives the total value of , whereas the optimal solution is as the first robot and second robot choose motion primitive () and motion primitive (), respectively. The similar case is reproducible with a larger number of robots, motion primitives, and targets. Thus, the simple greedy performs arbitrarily badly for the Bottleneck variant.

Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
""
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
   
Add comment
Cancel
Loading ...
369675
This is a comment super asjknd jkasnjk adsnkj
Upvote
Downvote
""
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters
Submit
Cancel

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test
Test description