Year: 2021

Abstract:
This paper demonstrates how time-constrained multi-robot task allocation (MRTA) problems can be modeled as a Markov Decision Process (MDP) over graphs, such that approximate solutions can be modeled as a policy using Reinforcement Learning (RL) methods. Inspired by emerging approaches for learning to solve related combinatorial optimization (CO) problems such as multi-traveling salesman (mTSP) problems, a graph neural architecture is conceived in this paper to model the MRTA policy. The generalizability and scalability needs of the complex CO problem presented by MRTA are addressed by innovatively using the concept of Covariant Compositional Networks (CCN) to learn the local structures of graphs. The resulting learning architecture is called Covariant Attention-based Mechanism or CAM, which comprises: 1) an encoder: CCN-based embedding model to represent the task space as learnable feature vectors, 2) a decoder: an attentionbased model to facilitate sequential decision outputs, and 3) context: to represent the state of the mission and the robots. To learn the feature vectors, a policy-gradient method is used. The CAM architecture is found to generally outperform a stateof-the-art encoder-decoder method that is purely based on Multi-head Attention (MHA) mechanism in terms of task completion and cost function, when applied to a class of MRTA problems with time deadlines, robot ferry range constraints, and multi-tour allowance. CAM also demonstrated significantly better scalability in terms of cost function over unseen scenarios with larger task/robot spaces than those used for training. Lastly, evidence regarding the unique potential of learningbased approaches in delivering highly time-efficient solutions is provided for a benchmark vehicle routing problem – where solutions are achieved 100-1000 times faster compared to a non-learning baseline, and for a benchmark MRTA problem with time and capacity constraints – where solutions for larger problems are achieved 10 times faster compared to non-learning baselines.

heading: 1 INTRODUCTION
text: In multi-robot task allocation (MRTA) problems, we study how to coordinate tasks among a team of cooperative robotic systems such that the decisions are free of conflict and optimize a quantity of interest (Gerkey & Matarić, 2004). The potential real-world applications of MRTA are immense, considering that multi-robotics is one of the most important emerging directions of robotics research and development, and task allocation is fundamental to most multi-robotic or swarm-robotic operations. Example applications include disaster response (Ghassemi & Chowdhury, 2018), last-mile delivery (Aurambout et al., 2019), environment monitoring (Espina et al., 2011), reconnaissance (Olson et al., 2012) and combat Behjat et al. (2021). Although various approaches (e.g., graph-based methods (Ghassemi et al., 2019), integer-linear programming (ILP) approaches (Nallusamy et al., 2009; Toth & Vigo, 2014), and auction-based methods (Dias et al., 2006; Schneider et al., 2015)) have been proposed to solve the combinatorial optimization problem underlying MRTA operations, they usually do not scale well with number of robots and/or tasks, and do not readily adapt to complex problem characteristics without tedious hand-crafting of the underlying heuristics. In the recent years, a rich body of work has emerged on using learning-based techniques to model solutions or intelligent heuristics for combinatorial optimization (CO) problems over graphs. The existing methods are mostly limited to classical CO problems, such as multi-traveling salesman (mTSP), vehicle routing (VRP), and max-cut type of problems. We specifically focus on a class of MRTA problems that falls into the Single-task Robots, and Single-robot Tasks (SR-ST) class defined in (Gerkey & Matarić, 2004; Nunes et al., 2017). Based on iTax taxonomoy as defined in Gerkey & Matarić (2004), these problems fall into the In-schedule Dependencies (ID) category. Here, a feasible and conflict-free task
allocation is defined as assigning any task to only one robot (Ghassemi et al., 2019). For solving these problems, we propose a new covariant attention-based model (aka CAM), a neural architecture for learning over graphs to construct the MRTA policies. This architecture builds upon the attention mechanism concept and innovatively integrates an equivariant embedding of the graph to capture graph structure while remaining agnostic to node ordering. We implement CAM on an original MRTA problem, a suite of benchmark MRTA problems and benchmark VRP problems to perform generalizability, scalability and comparative analyses of the new method. We also perform an analysis on the impact of the neighborhood size on the performance on the benchmark MRTA problem.

heading: 1.1 MULTI-ROBOT TASK ALLOCATION
text: In recent years, learning approaches based on Graph Neural Networks or GNN are being increasingly used to solve planning problems with a CO formulation, e.g., TSP, VRP, Max-Cut, Min-Vertex, and MRTA Kool et al. (2019); Barrett et al. (2019); Khalil et al. (2017); Kaempfer & Wolf (2018); Mittal et al. (2019); Li et al. (2018); Nowak et al. (2017); Wang & Gombolay (2020); Tolstaya et al. (2020); Sykora et al. (2020); Dai et al. (2017). Further details on these related learning-based studies can be found in Appendix A. Some of the conventional ILP, MILP, and INLP based methods for MRTA have been discussed in Appendix D.1. GNNs provide the advantage of being able to capture both Euclidean features (e.g., task location), as well as non-Euclidean features such as task capacity, task deadline and the local structure of task neighborhoods. The latter serves as higher-level meaningful features that assist in generalized decision-making These existing studies are however limited in three key aspects: 1) They address simplified problems that often exclude common real-world factors such as resource and capacity constraints Kool et al. (2019); Kaempfer & Wolf (2018); Khalil et al. (2017); Tolstaya et al. (2020)). 2) They are mostly focused on smaller sized problems (≤ 100 tasks and 10 robots) Paleja et al. (2020); Strens & Windelinckx (2005); Wang & Gombolay (2020); Sykora et al. (2020), with their scalability remaining unclear. 3) They rarely provide evidence of generalizing to problem scenarios that are larger in size than those used for training. This capability would be particularly critical since real-world MRTA problems often involve simulating episodes whose costs scale with the number of tasks and robots, making re-training efforts burdensome. To address these gaps, here we propose a new learning framework that can solve large-sized MRTA problems (SR-ST) with commonly considered constraints – involving up to 1000+ tasks and 200+ robots – and generalize across even larger problem scenarios without the need to re-train. For most practical scenarios with larger number of locations, a highly optimal solution is not always desired, while a good feasible solution is the priority as pointed out by Cappart et al. (2021). Therefore, to enable scalable policies, we design a novel encoder based on the concept of Covariant Compositional Networks (CCN) Hy et al. (2018), which is hypothesized to effectively combine local structural information with permutation invariance. The encoder is followed by a decoder based on a Multi-head Attention mechanism Kool et al. (2019); Vaswani et al. (2017) which fuses the encoded information and problem/mission-specific information (Context) using simple matrix multiplication, in order to enable decentralized sequential decision-making.

heading: 1.2 CONTRIBUTIONS OF THIS PAPER
text: The primary contributions of this paper can thus be stated as follows: 1) We formulate the general SR-ST class of MRTA problems as a Markov Decision Process or MDP over graphs with the multirobot state information embedded as the context portion of the policy model, such that the (task allocation) policy can be learned using an RL approach. 2) We design the GNN that acts as the policy network as an encoder-decoder architecture, where the encoder is innovatively based on covariant compositional networks (CCN), whose embedding capabilities significantly improve generalizability and scalability to larger task graphs and multi-robot teams. 3) We implement an attention based decoder (inspired by Kool et al. (2019)) to enable sequential decision-making, and specifically extend it to a multi-agent combinatorial optimization setting. The proposed CAM architecture is evaluated on a representative MRTA problem that involves coordinating a team of unmanned aerial vehicles (UAVs) to time-efficiently deliver flood relief. The results of this case study demonstrate how CAM clearly outperforms the state-of-the-art attention based method AM (Kool et al., 2019), in terms of scalabilty and convergence, thereby emphasizing the effectiveness of the new encoder. Further case studies show that CAM continues to compare favorably to AM over benchmark MRTA problems (with time and capacity constraints) and CVRP problems. Comparisons to non-learning baselines for these benchmark problems demonstrate the significant online computation advantages of learnt policies, with the latter being 10-100 times faster. The remainder of the paper is organized as follows: Section 2 defines the MRTA problem and its formulation as an MDP over graphs. Section 3 presents
our proposed new GNN architecture. Section 4 describes simulation settings and different case studies. Results are discussed in Section 5.

heading: 2 MRTA: PROBLEM DEFINITION AND FORMULATIONS
text: The multi-robot task allocation (MRTA) problem is defined as the allocation of tasks and resources among several robots that act together without conflict in the same environment to accomplish a common mission. The optimum solution (decision) of the MRTA problem is a sequence of tasks for each robot (conflict-free allocation) that maximizes the mission outcome (e.g., fraction of tasks completed) or minimize the mission cost (e.g., total distance travelled) subject to the robots’ range constraints. Here, the following assumptions are made: 1) All robots are identical and start/end at the same depot; 2) There are no environmental uncertainties; 3) The location (xi, yi) of task-i and its time deadline τi are known to all robots; 4) Each robot can share its state and its world view with other robots; and 5) There is a depot (Task-0), where each robot starts from and visits if no other tasks are feasible to be undertaken due to the lack of available range. Each tour is defined as departing from the depot, undertaking at least one task, and returning to the depot. 6) Motivated by the multi-UAV relief delivery problem, tasks are considered to be instantaneous, which means that reaching the waypoint associated with a task completes that task. This MRTA problem is a class of combinatorial optimization problems, which can be modeled in graph space. In order to learn policies that yield solutions to this CO problem, we express the MRTA problem as a Markov Decision Process (MDP) over a graph, described next. The optimization formulation of MRTA is then given in Section 2.2.

heading: 2.1 MDP OVER A GRAPH
text: The MRTA problem involves a set of nodes/vertices (V ) and a set of edges (E) that connect the vertices to each other, which can be represented as a complete graph G = (V,E). Each node represents a task, and each edge connects a pair of nodes. Let Ω be a weight matrix where the weight of the edge (ωij ∈ Ω) represents the cost (e.g., distance) incurred by a robot to take task-j after achieving task-i. For MRTA with N tasks, the number of vertices and the number of edges are N and N(N − 1)/2, respectively. Node i is assigned a 3-dimensional feature vector denoting the task location and time deadline, i.e., di = [xi, yi, τi] where i ∈ [1, N ]. Here, ωij can be computed as ωij = √ (xi − xj)2 + (yi − yj)2, where i, j ∈ [1, N ].
The MDP defined in a decentralized manner for each individual robot (to capture its task selection process) can be expressed as a tuple < S,A,Pa,R >. The components of the MDP can be defined as: State Space (S): A robot at its decision-making instance uses a state s ∈ S, which contains the following information: 1) the current mission time, 2) its current location, 3) its remaining ferry-range (battery state), 4) the planned (allocated) tasks of its peers, 5) the remaining ferry-range of its peers, and 6) the states of tasks. The states of tasks contain the location, the time deadline, and the task status – active, completed, and missed (i.e., deadline is passed). Here we assume that each robot can broadcast its information to its peers without the need for a centralized system for communication, as aligned with modern communication capabilities Sykora et al. (2020). Action Space (A): The set of actions is represented as A, where each action a is defined as the index of the selected task, {0, . . . , N} with the index of the depot as 0. The task 0 (the depot) can be selected by multiple robots, but the other tasks are allowed to be chosen once if they are active (not completed or missed tasks). Pa(s′|s, a): A robot by taking action a at state s reaches the next state s′ in a deterministic manner (i.e., deterministic transition model is defined). Reward (R): The reward function is defined as −fcost, and is calculated when there is no more active tasks (all tasks has been visited once irrespective of it being completed or missed). Transition: The transition is an event-based trigger. An event is defined as the condition that a robot reaches its selected task or visits the depot location.

heading: 2.2 MRTA AS OPTIMIZATION PROBLEM
text: This MRTA problem is adopted from (Ghassemi et al., 2019; Ghassemi & Chowdhury, 2021) with the following modification – payload constraints are not imposed on the robot. The exact solution of the MRTA problem can be obtained by formulating it as an integer nonlinear programming problem, which can be summarily expressed as:
min fcost = r − u(r)e−dr (1) where r ∈ [0, 1] and u(r) = {
1 if r = 0 0 otherwise
(2)
subject to τ fi < τi (3) δij ≤ ∆k, k ∈ [1, Nr] i, j ∈ [0, N ] (4)
Here τfi is the time at which task i was completed, ∆k is the available range for robot k at any point of time, and δij is the distance between nodes i and j. A detailed formulation of the exact ILP constraints that describe the MRTA problem with range restrictions, multi-tours per robot and tasks with deadlines, can be found (Ghassemi & Chowdhury, 2021). Note that, here we use a slightly different objective/cost function to better reflect the generalized setting for the class of MRTA problems with ferry-range and task-deadline constraints For compactness of representation, only the main constraints involved in the studied MRTA problem are shown in the above set of equations. We however consider all of the constraints, except the one related to payload capacity, as defined in the work by (Ghassemi & Chowdhury, 2021); for detailed formulation of the MRTA problem, please refer to (Ghassemi & Chowdhury, 2021).
Here, we craft the objective function (Eq. equation 1) such that it emphasises maximizing the completion rate (i.e., the number of completed tasks divided by the total number of tasks); and if perfect completion rate (100%) is feasible, then the travelled cost is also considered. The term of 1 − r is defined as task completion rate; i.e., the number of completed tasks (Nsuccess) divided by the total tasks (N ) or r = (N −Nsuccess) /N . Here, dr is a normalized value of the total distance travelled by all robots in the team. The term dr is the average travelled distance over all robots (i.e., dr = ∑Nr i=1 d total i /( √ 2 N)). The terms Nr and dtotali represent respectively the number of robots and the total traveled distance by robot-i during the entire mission. The above objective function (Eq. equation 1) gives a positive value if the completion rate is lower than 100%, otherwise it gives a negative value. Equation 1 ensures that the objective function is bounded in the range (−1, 1].

heading: 3 COVARIANT ATTENTION-BASED NEURAL ARCHITECTURE
text: For learning to work on the MDP defined over graphs in Section 2.1, we need to represent each node as a continuous vector, preserving its properties as well as the the structural information of the neighborhood of that node.
Task Graph
State
Greedy Policy CAM: Graph Neural Network
Task Graph
Robot-1
Encoder
Context
Decoder argm ax(𝑎
𝑖 )
1 2 3
4 Peers
Time
𝑡0
M H A
L in e a r
S o ftm a x
2
Action: Selected
Task0.1 0.5 0.3 0.1
Greedy Policy CAM: Graph Neural Network
Robot-2
Encoder
Context
Decoder argm ax(𝑎
𝑖 )
1 2 3
4 Peers
Time
𝑡1
M H A
L in e a r
S o ftm a x
4
Action: Selected
Task0.3 0 0.2 0.5
(a)
(b)
Output: Prob. Of Selecting Task
State
Figure 1: Deployment of an MRTA policy using CAM architecture. a) Robot-1 at t0. b) Robot-2 at t1; here, the CAM output for previously selected task (task 2 in (b)) is set at 0.
Before describing the technical components of our proposed Covariant Attention Mechanism, the so-called CAM neural architecture, we provide an illustration and summary description here of how this policy architecture is used by robots or agents during an SR-ST operation. The CAM model for task allocation is called by/for each robot right when it reaches its current destination (task location or depot), in order to decide its next
task or destination. While robots are moving toward their selected task locations, they can check if their decision is conflicting with another robot based on recent information. If there is conflict, the robot with the worst time can cancel its current task and select a new task. Since full-observability is assumed across the multi-robot team and the policy-model execution-time is almost negligible, the current setup is agnostic to whether the online CAM model is executed centrally off-board or on-board each robot. As an example, Figure 1 illustrates how robot-1 and robot-2 uses the CAM policy model to choose a task at two different decision-making instances (t = t0 and t = t1). Here, the inputs to the CAM model includes 1) the task graph information, i.e., the properties of all the tasks/nodes di and the computed weight matrix Ω, 2) the current mission time, 3) the state of robot-r, and 4) the states of robot-r’s peers. The CAM model then generates the probability of selecting each task as its output. A greedy strategy of choosing the task with the highest probability is used here, which thus provides the next destination to be visited by that robot. It should be noted that the probability values for completed tasks and missed tasks (i.e., missed deadline) are set at 0.
Figure 2 shows the detailed architecture of CAM. As shown in this figure, the CAM model consists of three key components, namely: Context, Encoder, and Decoder. The context includes the current mission time, the states of robot-r, and the states of robot-r’s peers. The state of a robot consists of it’s destination x, y coordinates and the available range ρ. The encoder and decoder components are described below.

heading: 3.1 CCN-INSPIRED NODE ENCODER
text: For learning over graphs, the performance of the trained model depends mostly on the ability of the Graph Neural Network (GNN) to transform all the required node information into a feature vector or tensor. For our case, apart from the node properties, some of the features that is essential include a node’s local neighborhood information, and permutation invariance. Using a node’s local neighborhood information which consists of its association with its local neighbors during training is
more beneficial than considering the association with the entire graph, for generalizing to unseen nodes as demonstrated by frameworks like GraphSAGE (Hamilton et al., 2017), thus enabling the GNN to generalize for problems with larger number of nodes without the need to re-train. The encoder represent the properties of each graph node (preserving its structural information) into a continuous feature vector of dimension dembed, which is fed to the decoder. Each node i, has three properties which are the x-coordinate (x), y-coordinate (y), and the time deadline (τ ) of the task. Note that our encoding mechanism can also be extended to a probabilistic scenario, for example where an estimated deadline τ follows a probability distribution (common in disaster response type operations). The encoding for each node should include its properties and the its positional association with its neighboring nodes. We implement a variation of CCN (Hy et al., 2018). We determine the nearest k neighbors of a node (Nbi) based on the positional coordinates (x and y). The first step is to compute a feature vector by linear transformation for each node i. To encode the node properties, we do a linear transformation of di to get a feature vector Fdi for all i ∈ [1, N ], i.e., Fdi = W ddTi + bd.
Here W d ε Rdembed×3, bd ε Rdembed×1, di = [xi, yi, τi]. For effective decision making, we also need to preserve the structural information. Therefore we define a matrix FNbdi as in equation 5.
FNbdi = Concat(Fdj ), j ∈ Nbi (5) We compute a matrix FNbi (as shown in Eq. equation 6), which we believe captures the association of a node with its local neighbours (one-hop neighbors) in terms of the node properties.
FNbi = W Nb(FNbdi − Fdi) + b Nb (6)
whereWNb εRdembed×dembed , bNb εRdembed×1. FNbi captures the information about how close the node properties of neighbor nodes of node i is to itself, which shows a representation of how important node i is to its neighbors. Further explanation regarding this design choice is discussed in Appendix B and we strongly encourage the reader to go over the section.
We compute the final embedding for each node using Eq. equation 7.
Fi = Aggregate(Wf (Concat(F di , F Nb i )) + bf ) (7)
Here,Wf εRdembed×dembed , bf εRdembed×1. Thus finally we get an embedding Fi for each node, where Fi ε Rdembed×1. W d, bd, WNb, bNb, Wf , and bf are learnable weights and biases. The Aggregate function is the summation across all the columns of a matrix. This summation along with the relative difference in node properties, as in Eq. equation 6, preserves permutation-invariance and the structural properties (cognizance of inter-node distances for example) of the graph. Note that, these operations make the encoded state w.r.t. a given node insensitive to the order of the neighboring nodes, and thus the overall state space becomes independent of the indexing of tasks or to graph rotations. Equations 5, 6, and 7 represents a single layer of encoding. Multiple layers of encoding can be performed with the output of the previous layer being the inputs to equations 5 and 6 in the next layer.

heading: 3.2 ATTENTION-BASED DECODER AND CONTEXT
text: The main objective of the decoder is to use the information from the encoder and the current state as context or query, and thereof choose the best task by calculating the probability value of getting selected for each (task) node. In this case, the first step is to feed the embedding for each node (from the encoder) as key-values (K, V). The keyK and value V for each node is computed by two separate linear transformations of the node embedding obtained from the encoder. The next step is to compute a vector representing the current state, also known as the context (as shown in bottom left of Fig. 2). The context for the MHA layer in this experiment consist of the following seven features: 1) Current time; 2) Available range of the robot taking decision; 3) Current location of robot taking decision; 4) Current destination of other robots; 5) Available range for other robots all concatenated to a single vector of length hq, which then undergoes a linear transformation to get a vector of length dembed also called the query Q. Figure 2 illustrates the structure of the decoder.
Now the attention mechanism can be described as mapping the query (Q) to a set of key-value (K,V) pairs. The inputs, which are the query (Q) is a vector, while K and V are matrices of size dembed×N (since there are N nodes). The output is a weighted sum of the values V , with the weight vector computed using the compatibility function expressed as:
Attention(K,V,Q) = softmax(QTK/ √ dembed)VT (8)
Here hl is the dimension of the key of any node i (ki ∈ K). In this work, we implement a multi-head attention (MHA) layer in order to determine the compatibility of Q with K and V . The MHA implemented in this work is similar to the decoder implemented in Kool et al. (2019) and Vaswani et al. (2017). As shown in (Vaswani et al., 2017) the MHA layer can be defined as: MHA(K,V,Q) = Linear(Concat(head1 . . . headhe)) (9) Here headi = Attention(K,V,Q) and he (taken as 8 here) is the number of heads. The feed-forward layer is implemented to further process the mapping that results from the MHA layer, and transform it to a dimension that is coherent with the number of nodes in the task-graph (N ). The interjecting batch normalization layers serve to bound values of a specific batch using the mean and variance of the batch. The final softmax layer outputs the probability values for all the nodes. Here, the next task to be done is then chosen based on a greedy approach, which means that the node with the highest probability will be chosen. The nodes which are already visited will be masked (by setting its probability as 0) so that these nodes are not available for selection in the future time steps of the simulation of the multi-robot operation.

heading: 4 CASE STUDIES
text: We design and execute a set of numerical experiments described in Appendix D.3, to investigate the performance of our proposed learning-based algorithm over graph space (CAM) and compare it with 1) an extended version of a state-of-the-art graph learning-based algorithm proposed by (Kool et al., 2019), so called attention-based mechanism (AM) approach; 2) a recent bipartite graph matching method BiG-MRTA (Ghassemi & Chowdhury, 2021); 3) a myopic baseline called Feasibilitypreserving Random-Walk (Feas-RND) that takes randomized but feasible actions (avoiding conflicts and satisfying other problem constraints). Since the BiG-MRTA method has been shown to provide near-optimal solutions in comparison to ILP (and competitive performance w.r.t. state-of-the-art online MRTA methods) Ghassemi & Chowdhury (2021), it is used here to comparatively gauge performance of AM and CAM. The Feas-RND method on the other hand provides a baseline that AM and CAM should clearly surpass in performance (cost function), in order to demonstrate that meaningful MRTA policies are being learnt as opposed to simply mapping random feasible actions.

heading: 5 RESULTS AND DISCUSSION

heading: 5.1 GENERALIZABILITY AND SCALABILITY ANALYSIS OF CAM
text: The CAM model has been trained on scenarios with 200 tasks and varying robot size (randomly a robot size between 10 and 50 has been selected). Then, 100 test scenarios have been generated per robot-task size from the same distribution of training scenarios. In this paper, generalizability refers to the performance of the trained model on unseen test scenarios that involve the same (or lower) number of tasks as in the scenarios used for training; and where the test and training scenarios are drawn from the same probability distribution over task locations and deadlines. In this work, generalizability was analysed on test scenarios with the number of tasks fixed at 50 and 200, drawn from the same distribution over a 2D space, and number of robots fixed at 5 and 40. In this paper, scalability refers to the performance of the trained model over test scenarios with higher (and increasing) numbers of tasks and robots than that encountered in the scenarios used for training. Here, we analyze scalability
by evaluating the CAM model on test scenarios with the number of tasks fixed at 500 and 1000, and the number of robots fixed at 50 and 1000. The task-to-robot ratio is however kept the same across the generalizability and scalability analysis cases, in order not to introduce another control factor affecting the numerical experiments. To measure and compare performance, we use two metrics: 1) Average cost function (Eq. 1): This metric accounts for the completion rate of tasks and the total travelled distance, averaged over the set of test scenarios; and 2) Average computing time: This measures how long each method takes to compute the entire solution, averaged over the test set. The latter is particularly important to note in scalability analysis, since state-of-the-art non-learning based MRTA methods scale poorly in terms of computing efficiency as numbers of tasks and robots increases. Table 1: MRTA – Multi-UAV flood response: Generalizability: Task size
100%, while a positive value indicates a task completion rate below 100%. As it can be seen from Table. 1 that the proposed CAM approach outperforms the AM approach in all the test cases by achieving better mean values of the cost function, respectively. The CAM approach performs significantly better than AM in terms of the cost function for the lower task-to-robot ratio (here, 5). Based on table 1, the proposed CAM approach achieved a perfect completion rate for most of scenarios with the task-to-robot ratio of 5. The local structure of the graph is not only important for effective decision-making, but also expected to be shared across various problems settings drawn from the same distribution, thereby promoting generalizability of policies when adequately captured.
To investigate the scalability of the learnt model, we use a new set of unseen test scenarios with numbers of tasks and robots much larger than those of the scenar-
ios used in training (the latter involved 200 tasks). Table 2 shows the performance of the trained model of CAM and AM in terms of the cost function (lower the better) for four large case studies, involving 500-tasks-50-robots, 500-tasks-100-robots, 1000-tasks-100-robots, and 1000-tasks-200-robots; for each case, 100 randomly generated scenarios (i.e., task locations and deadlines randomized) are used. As shown in Table 2, the proposed CAM method outperforms the AM method in all cases, with a significant difference in the cost function for the case studies with the task-to-robot ratio of 5. In the largest case (i.e., 1000-task-200-robot), the learnt model by CAM achieved a perfect completion rate for most of the scenarios (Appendix E). It can be argued that, for time-critical problems such as MRTA in disaster response, generating an optimal solution is less of a priority, compared to generating a feasible near-optimal solution as quickly as possible; this capability of the learnt models in evident from the results in Table 7 in Appendix E. BiG-MRTA requires a significantly larger computing time for larger sized problem (see Fig. 5 in Appendix E.1). Comparison with the BiG-MRTA solutions also indicate remaining scope of improvement for learning methods, in terms of distance travelled.
The comparison with Feas-RND shows how the learning method is markedly better than random feasible myopic decisions, thereby indicating that meaningful MRTA policies have been learnt here, as opposed to producing random feasible solution by virtue of the masked policy network design. In the Feas-RND method, a robot takes a task-selection decision randomly from a feasible set of choices that abide by all the constraints in the problems, e.g., related to inter-robot conflicts, task deadline and robot range. As shown in Table 7, CAM achieves more than 92% task completion rate for all the scenarios, which is found to be a 5%-30% gain in task completion rate over that achieved by
Feas-RND across these scenarios. The performance of CAM in terms of the task completion rate is comparable to that of BiG-MRTA (which is slightly better), with the highest difference being 6.9% for the 500-tasks-50-robots case. Note that CAM continues to be better than AM is all these cases as well. Later in Section 5.2, we also compare the performance of CAM, AM, and BiG-MRTA on a benchmark MRTA problem where the objective is just to maximize the task completion rate (hence the cost function is not affected by distance travelled), where CAM proves to be highly competitive.
Ablation study: We performed two ablation studies (Appendix E.2) on CAM to understand the importance of the novel encoder and the decoder (adopted from attention mechanism). In the first ablation study, the CCN based encoding is replaced with simple feedforward layers (as explained in Appendix E.2), with the decoder remaining the same. It should be noted that the node embedding length (dembed), is the same for all the cases. In the second ablation study, the MHA based decoding was replaced with simple feedforward layers and a softmax layer (as explained in Appendix E.2), with the encoder remaining the same. As shown by Table 8, in both of the cases (i.e., with the encoder and decoder respectively ablated), we observe a significant decrease in the performance across all scenarios, with the maximum dip in the completion rate being 19.8% and 13.4% for the first and the second study, respectively. Compiling the results from the first ablation study for the encoder and the comparison of CAM with AM, we posit that the CCN based encoding, which is able to aggregate local node neighborhoods while remaining agnostic to node ordering, clearly aids in providing better policies. Similarly, from the second case of the ablation study, we can conclude the MHA based decoding, which computes a compatibility of the current state information with the node information, aid in learning better policies.

heading: 5.2 COMPARATIVE ANALYSIS ON BENCHMARK MRTA PROBLEMS AND CVRP PROBLEMS
text: MRTA - Task Allocation Problem with Time and Capacity (TAPTC): The CAM architecture is implemented and tested on a well-known class of (NP hard) MRTA problems known as Task Allocation Problem with Time and Capacity constraints or TAPTC, as described in Mitiche et al. (2019). In TAPTC, each task i has a time deadline (ti) and workload (wi), and each robot has a work capacity (cj). The time to finish task i by robot j is defined as wi/cj . We compare the results of CAM on TAPTC with that of AM (Kool et al., 2019) and with those of the three non-learning baseline methods, namely 1) Iterated Local Search (ILS) (Vansteenwegen et al., 2009), which uses a meta heuristic approach, 2) Enhanced Iterated Local Search (EILS) (Vansteenwegen et al., 2009), which has controlled runtime and perturbations (compared to ILS), and 3) Bi-Graph MRTA (BiGMRTA) (Ghassemi & Chowdhury, 2021)), which uses a bigraph construction and maximum weighted matching approach. Further details of the TAPTC benchmark, the baselines used here, and the changes made to CAM and AM for this case study are discussed in Appendix F. For the results shown here, the CAM model is implemented such that k = 9 nearest neighbors are considered when computing the embedding of each node of the task graph. The testing is performed for different scenarios that are characterized by the number of robots and % of tasks having slack time deadline. Mitiche et al. (2019) categorized the TAPTC problems into 2 groups based on the value of the high deadline for the tasks. Table 3 here presents the results for group 2, with the group 1 results given in Table 10 in Appendix F.4. In these tables, the scenario nomenclature is defined as: R75A5 denotes R = 75% tasks have a normally-distributed time deadline and a team of A = 5 robots. Results on the impact of neighborhood size (k) on CAM performance is also discussed in Appendix F.4.
Table 3 shows that for all scenarios with A = {5, 7}, CAM performs better than both AM and the non-learning baselines in terms of task completion rate; and CAM achieves top performance for 50% of the scenarios with A = {2, 3}.
A comparison of the computation time to generate the entire MRTA solution, shown in Table 4, demonstrates the advantage of learning based methods over non-learning baselines as the problem size increases w.r.t. the number of robots and tasks. Capacitated VRP: To demonstrate the versatility of the proposed CAM architecture, we train and test the CAM and the AM architectures (for comparison) on a benchmark variation of the Vehicle Routing Problem (VRP), known as the Capacitated VRP (CVRP). The CVRP benchmark consists of N task locations, where a vehicle is required to visit the locations and deliver packages in a manner that minimizes a cost function. We also use the LinKernighan heuristics (LKH3) solver (Helsgaun, 2017) and the Simulated Annealing (SA) algorithm implementation provided by Google Operations Research (OR) tools as well-regarded non-learning based baselines for comparing the results obtained by CAM and AM. Further details regarding the CVRP problem, the baseline method, and settings changes for CAM and AM are presented in Appendix G.1. Table 5 summarizes the results of all four approaches (i.e., AM, CAM, and Google OR) on unseen scenarios for varying task size (# of locations) ranging from 50 to 1,000, in terms of the cumulative computing time and the cost function (both as average values across scenarios of a given size). LKH3 is a well known state-of-the-art method for solving CVRP problems and also has the best performance (considering only cost and not run time). As shown in Table 5, the performance of all methods except LKH3 are comparable for small sized problems (50, 100, and 200 locations or tasks). As expected, the main advantage of the proposed CAM approach is apparent for the problems with larger number of tasks (i.e., 500 and 1000 tasks), where the average cost function of the solutions obtained by the CAM is significantly better (less than half of AM’s and one-third of Google OR’s). In these larger-sized scenarios, the computing time performance of CAM is slightly better than that of AM, and together AM and CAM are two orders of magnitude faster than SA (Google OR) and LKH3 in generating the entire solution (sequence of tasks to be undertaken).
6 CONCLUSION
Table 5: CVRP: Comparison of average cost function (and average time taken to generate the entire solution). Lower the better.
# OF AVG. COST FUNCTION (AVG. COMPUTING TIME) TASKS LKH3 GOOGLE OR AM CAM
50 10.53 (46s) 11.3 (2s) 12.3 (0.04s) 12.2 (0.04s) 100 15.58 (60s) 17.6 (5s) 17.4 (0.09s) 17.9 (0.09s) 200 17.69 (86s) 21.3 (20s) 21.6 (0.18s) 21.8 (0.17s) 500 24.87 (123s) 54.5 (20s) 34.0 (0.53s) 29.1 (0.53s) 1000 28.67 (189s) 81.8 (200s) 64.1 (1.51s) 41.6 (1.49s) In this paper, we proposed a new GNN architecture, called CAM, for a multirobot task allocation problem with a set of complexities, including tasks with time deadline and robots with constrained range. This new architecture incorporates an encoder based on covariant node-based embedding and a decoder based on attention mechanism. A simple RL algorithm has been implemented for learning the features of the encoder and decoder. In addition, to compare the performance of the proposed CAM method, an attention-based mechanism approach (aka AM) has been extended to be able to handle a multi-agent CO setting problem, along with a recent state-of-the-art method BiG-MRTA, and a mypoic baseline method Feas-RND. To evaluate the performance of the proposed CAM architecture and the extended version of AM, they are trained with the same settings. All the methods were tested on 100 unseen case studies. Performance was analyzed in terms of the cost value and the completion rate. Our primary proposition, CAM, outperformed AM and Feas-RND on test scenarios by achieving better cost function value, and was also able to achieve high task completion rate (> 92%) for even larger sized problems without the need to retrain, which is comparable to the near-optimal (but O(101 − 102) more expensively computed) solutions by BiG-MRTA, thereby demonstrating the favorable scalability of CAM. The computational cost analysis showed that the proposed CAM model takes a few milliseconds to compute a decision, thereby providing clear advantage over non-learning based approaches to MRTA in the context of online (time-sensitive) planning. Moreover, the advantage of using local neighborhood information for node encoding can be seen in the scalability analysis on the MRTA and CVRP, where CAM demonstrates superior performance when applied to graphs with larger number of tasks/nodes. The ablation studies in Appendix E.2 showed the importance of the CCN based encoding and the MHA based decoding used in CAM. A comparisons over a different suite of benchmark MRTA problems showed that CAM was competitive w.r.t. standard non-learning baselines including BiG-MRTA, in terms of task completion rate, while providing substantially faster solutions compared to the latter. Lastly, a comparative analysis on different CAM models with varying neighborhood size (while encoding) was performed (appendix F.6) to study the impact of the neighborhood size k in the encoder. Based on Appendix F.6 (for MRTA-TAPTC), k is a trade off between accuracy and computation time.
Ethics statement: The work in this paper does not have any direct negative societal consequences.
Reproducibility statement: The CAM architecture which includes the encoder, decoder and the context part, can be coded in any programming language by following the equations in section 3 and figure 2. The dataset for training the MRTA-Multi-UAV Flood response problem can be generated using the information in Appendix D.3. The codes for the AM method can be obtained from https://github.com/wouterkool/attention-learn-to-route. The AM method can be modified for solving the MRTA-Multi-UAV Flood Response problem using the information from Appendix D.5. Both CAM and AM method can be trained using the settings in table 6. The codes for the BiG-MRTA method and Feas-RND can be obtained from https://github.com/ adamslab-ub/BiG-MRTA. The training data for MRTA-TAPTC can be generated using the information in Appendix F.5. Both CAM and AM can be modified using the information in Appendix F.2. Details on running BiG-MRTA for MRTA- TAPTC can be obtained from Ghassemi et al. (2019) and the corresponding code from https://github.com/adamslab-ub/BiG-MRTA. The EILS can be coded using the inforation in Mitiche et al. (2019). The test dataset can be obtained from https://tinyurl.com/taptc15in. The CAM architecture can be modified for CVRP using the information in Appendix G.1.1 and G.1.2. The codes for the AM method and implementation for LKH3 can be obtained from https://github.com/wouterkool/ attention-learn-to-route. The google OR tools implementation can be done using the example in https://developers.google.com/optimization/routing/vrp with the dataset generated using the information in Appendix G.4.

heading: A LEARNING OVER GRAPHS
text: Neural network based methods for learning CO can be broadly classified into: (i) Reinforcement Learning (RL) methods Kool et al. (2019); Barrett et al. (2019); Khalil et al. (2017); Strens & Windelinckx (2005); and (ii) Supervised learning (often combined with RL) methods Kaempfer & Wolf (2018); Mittal et al. (2019); Li et al. (2018); Nowak et al. (2017). The supervised learning approaches typically address problem scenarios where samples are abundant (e.g., influence maximization in social networks Mittal et al. (2019)) or inexpensive to evaluate (e.g., TSP Kaempfer & Wolf (2018)), and are thus unlikely to be readily applicable to solve complex problems over real-world graphs. RL based techniques to learn on graphs include attention models with REINFORCE Kool et al. (2019) and deep Q-learning Khalil et al. (2017); Barrett et al. (2019), among others, with some extending solutions to multi-agent settings Jiang et al. (2020). In this work, we are interested in the first class of the methods (i.e., RL methods over graph space).
Dai et al. Dai et al. (2017) showed that a combination of graph embedding and RL methods can be used to approximate optimal solutions for combinatorial optimization problems, as long as the training and test samples are drawn from the same distribution. Mittal et al. (2019) presented a new framework to solve a combinatorial optimization problem. In this framework, Graph Convolutional Network (GCN) performs the graph embedding and Q-Learning learns the policy. The results demonstrated that the proposed framework can learn to solve unseen test problems that have been drawn from the same distribution as that of the training data set. More importantly, it has been shown that using a learned network policy instead of tree search, both methods are using the same embedding GCN, showed a speedup of 5.5 for a problem size of 20,000 for influence maximization. Similarly, the effectiveness of learning a network policy using Q-Learning to solve the Max Cut problem (a combinatorial problem) has been demonstrated by Barrett et al. (2019).
Recently, there has been a growing interest in using sequence-to-sequence models (e.g., pointer networks and attention mechanism) to encode and learn the combinatorial optimization problems in graph space Kaempfer & Wolf (2018); Kool et al. (2019). Kool et al. Kool et al. (2019) implemented a framework using an encoder/decoder based on attention mechanism and REINFORCE algorithm for solving a wide variety of combinatorial optimization problems as graphs, with the main contribution being flexibility of the approach on multiple problems with the same hyperparameters. Wang et al. Wang & Gombolay (2020) showed how learning can lead to generate faster solutions than standard exact methods for multi-robot scheduling problems. However, the size of the problem that has been studied in that work and other similar studies Paleja et al. (2020); Sykora et al. (2020) is limited to 5 robots and 100 tasks, and only temporal constraints were considered. In this paper, we study larger problems (up to 1000 tasks/200 robots) as well as include complexities such as time deadlines for tasks, robot ferry range constraints, capacity constraints, multiple routes, etc. Graph learning has been implemented for a multi-robot coverage problem in Tolstaya et al. (2020), which demonstrates good scalability. However, this work is addressing a multi-robot exploration problem (and not MRTA), and it is not clear how this proposed method can be applied to an MRTA problem with complexities such as range constrain, capacity constraints, time extended tasks, multiple routes, etc. Apart from CO problems, graph learning can also be used to perform path planning as demonstrated in Li et al. (2020).
In this paper, a new neural architecture is proposed that combines the attention mechanism with an enhanced encoding network (embedding layers), where the latter is particularly designed to capture local structural features of the graph in an equivariant manner. The embedding layer is a variation of Covariant Compositional Networks (CCN), introduced by Hy et al. (2018). CCN was originally implemented for predicting molecular properties by learning local structural information of the molecules. This node-based embedding has been chosen since it: i) operates on an undirected graph; ii) uses receptive field and aggregation functions based on tensor product and contraction operations (which are equivariant), which leads to a permutation- and rotation-invariant embedding; and iii) provides an extendable representation (n-th order tensor representation can be useful to extend the work to multi-level networks, e.g., involving multiple node properties). We found an exact implementation of the CCN to be computationally burdensome for learning policies in large MRTA problems, and hence a variation of the CCN is proposed in this work. An attention mechanism has been successfully implemented for problems with sequential processes, e.g., Natural Language Processing (NLP) Vaswani et al. (2017). Here we are interested in the attention mechanisms since they involve simple matrix multiplications, which make them not only computationally inexpensive
(by utilizing modern GPUs), but also programmatically easy to be implemented. In this work, we implement an attention-based decoder for CAM as proposed in Kool et al. (2019); Vaswani et al. (2017).

heading: B EMBEDDING LOCAL STRUCTURAL INFORMATION
text: Local structural or neighborhood information of a graph node/ task refers to the association of the node to its neighboring nodes. These information includes how the properties of the neighborhood nodes differ from that of the node under consideration. It is this information that is being encoded in the node embedding along with the information of the node properties di. The encoder should be able to use this local structural information in order to scale to larger-sized problems as pointed out by (Cappart et al., 2021). Here, we explain how local structural information is being encoded with the help of two graphs, one which is small and the other is a larger graph but having some nodes with similar neighborhood as shown in figure 3. Node A in graph G1, and nodes B, and C in graph G2 have almost similar neighborhood. Here the local neighborhood information encoding of nodes A, B, and C (which are FNbA , F Nb B , and F Nb C respectively) will be almost same, irrespective of the size of the graph. Therefore by equation 6, ((FNbdA − FdA) ≈ (F Nb dB − FdB ) ≈ (FNbdC − FdC )) =⇒ (FNbA ≈ FNbB ≈ FNbC ). Even though the actual locations of nodes A, B, and C are different, their association with it’s neighboring are almost the same, which is being captured by equation 6.

heading: C LEARNING FRAMEWORK
text: Both the CCN-inspired encoder and the attention-based decoder consist of learnable weight matrices as explained in Sections 3.1 and 3.2. In order to learn these weight matrices, both supervised and unsupervised learning methods can be used. However, supervised learning methods are not tractable since the computational complexity of the exact I(N)LP solution process required to generate labels. The complexity of the ILP formulation of the MRTA problem scales with O(n3m2h2), where n, m, and h represent the number of tasks, the number of robots, and the maximum number of tours per robot, respectively Therefore, we use a reinforcement learning algorithm to conduct the learning. Learning Method: In this work we implement a simple policy gradient method (REINFORCE) as the learning algorithm with greedy rollout baseline, which also enables us to compare the effectiveness of our method with that of (Kool et al., 2019). For each epoch, two sets of data are used which are the training set and the validation set. The training data set is used to train the training model (θCAM) while the validation data set is used to update the baseline model (θBLCAM). The size of the training data and the validation data used for this paper is mentioned in section D.3. Each sample data from the training and validation data-set consist of a graph as defined in Section 2.1. The pseudo code of the training algorithm for our architecture is shown in Alg. 1 in Appendix E. It should be noted that the policy gradient method requires the evaluation of a cost function, which is defined to be same as in Eq. equation 1. Policy: We define the policy such that if the robot r does not satisfy the constraints in Eqs. equation 3, it returns to depot (i.e., a = 0). Otherwise the robot r runs the learnt CAM network
and chooses the output (task) based on a greedy approach (selects a task with the highest probability value), as shown in Fig. 1.
Algorithm 1 Training Algorithm Input: NE: Number of epochs, Nb: Number of batch, B: Batch size, Ntr: Training data size, Nvl: Validation data size. 1: θCAM-RL - CAM-RL 2: θBLCAM-RL - Baseline CAM-RL 3: for epoch = 1..Nepoch do 4: Dtr,Dvl ← GenerateScenarios(Ntr, Nvl) 5: Nb ← bNtr/Bc 6: for step = 1..Nb do 7: Dtr,b ← SampleRandom(Dtr,M) {Dtr,b: Batch Training Dataset} 8: aBL, fBLcost ← CalculateCost(θBLCAM-RL,Dtr,b) 9: a, fcost ← CalculateCost(θCAM-RL,Dtr,b) 10: ∇L ← 1 B ∑B i=1(fcost,i − f BL cost,i) log softmax(ai) 11: θCAM-RL ← ADAM(∇L, θCAM-RL) 12: end for 13: aBLvl , f BL cost,vl ← CalculateCost(θBLCAM-RL,Dvl) 14: a, fcost ← CalculateCost(θCAM-RL,Dvl) 15: if ( ∑Nvl i=1 f BL cost,i > ∑Nvl i=1 fcost,i) ∧ (T-Test(avl,a BL vl ) > ) then 16: θBLCAM-RL ← θCAM-RL 17: end if 18: end for 19: CalcuateCost Procedure: 20: for i = 1..|D| do 21: ai, fcost,i ← Simulation(θ,Di) 22: a← a ∪ ai 23: fcost ← fcost ∪ fcost,i 24: end for 25: return a, fcost

heading: C.1 SIMULATION AND FRAMEWORK SETTINGS
text: The ”Python” 3.7 and the 64-bit distribution of ”Anaconda 2020.02” are used to implement the MRTA approaches. The environment, training algorithm, and the evaluation of the trained model, are all implemented in Pytorch-1.5 for CAM and AM. The training, based on Pytorch, is deployed on two GPUs (NVIDIA Tesla V100) with 16GB RAM.

heading: D MORE DETAILS ON MRTA

heading: D.1 CONVENTIONAL METHODS FOR MRTA
text: The MRTA problem can be formulated as an Integer Linear Programming (ILP), mixed ILP or Integer Non-Linear Programming (INLP) problem depending on the application. When tasks are defined in terms of location, the MRTA problem becomes analogical to the Multi-Traveling Salesmen Problem (mTSP) (Khamis et al., 2015) and its generalized version, the Vehicle Route Planning (VRP) problem (Dantzig & Ramser, 1959). Existing solutions to mTSP and VRP problems in the literature (Bektas, 2006; Braekers et al., 2016) have addressed analogical problem characteristics of interest to MRTA, albeit in a disparate manner; these characteristics include tasks with time deadlines, and multiple tours per vehicle, with applications in the operations research and logistics communities (Azi et al., 2010; Wang et al., 2018). ILP-based mTSP-type formulations and solution methods have also been extended to task allocation problems in the multi-robotic domain (Jose & Pratihar, 2016). Although the ILP-based approaches can in theory provide optimal solutions, due to the NP-hard time complexity of the SR-ST problems (Mazyavkina et al., 2021; Archetti et al., 2011), they are characterized by exploding computational effort as the number of robots and tasks increases (Toth & Vigo, 2014; Cattaruzza et al., 2016). For example, for the studied SR-ST problem, the cost of solving the exact integer programming formulation of the problem scales withO(n3m2h2), where n, m, and h represent the number of tasks, the number of robots, and the maximum number
of tours per robot, respectively (Ghassemi et al., 2019). As a result, most practical online MRTA methods, e.g., auction-based methods (Dias et al., 2006) and bi-graph matching methods (Ghassemi & Chowdhury, 2018; Ismail & Sun, 2017), use some sort of heuristics, and often report the optimality gap at least for smaller test cases compared to the exact ILP or INLP solutions (where tractable).

heading: D.2 MORE DETAILS ON ENCODING THE CONTEXT
text: As discussed in section 3.2, the context portion of while a robot r makes a decision, consists of 1) Current time t; 2) Available range of the robot taking decision ρr; 3) Current location of robot taking decision (xr, yr); 4) Current destination of other robots (xp, yp,∀ p ∈ Pr); 5) Available range for other robots (ρp,∀ p ∈ Pr), where Pr represents the peers of robot r. Here, features 2 and 3 represent the current state of the robot taking the decision, while features 4 and 4 represents the states of the peer robots. The context feature vector can be computed as shown in Eq.10.
Q = Linear(Concat(t, Qr, QPr )) (10)
where, Qr = Linear([xr, yr, ρr] (11)
and QPr = Σp∈PrLinear([xp, yp, ρp]) (12)
The dimensions of Qr, and QPr is dembed, and the length of the final feature vector Q is also considered dembed. The summation aggregation operation in Eq.12, makes the context vector agnostic to the number of robots.

heading: D.3 DESIGN OF EXPERIMENTS & LEARNING PROCEDURES
text: To evaluate the proposed CAM method, we define an MRTA case study with varying number of UAVs and 200 task (flood victims) locations. A 2D environment with 1 sq. km area is used for this purpose, with the time deadline of tasks varied from 0.1 to 1 hour. The UAVs are assumed to have a range of 4 km, and a nominal speed of 10 km/h. We assume instantaneous battery swap is provided at depot location, which is used when UAVs return to depot since they were running low on battery. It is important to note that the flood victim application is used here merely for motivation, and the CAM architecture is in no way restricted to this application, but can rather solve problems in the broad (important) class of capacity/range-constrained and timed task-constrained SR-ST problems. Moreover, even the policies learnt here for CAM demonstration on the described case settings can generalize to related SR-ST problems with up to 1,000 tasks, which represents a fairly large MRTA problem in reference to the existing literature in the MR domain.
To perform learning and testing of the learned model, we proceed as follows: Learning Phase: We use a policy gradient reinforcement learning algorithm (REINFORCE with rollout baselines in this case) for learning the optimal policy. The learnable parameters in this architecture includes all the weights in the encoder and the decoder. The training is carried out for a total of 100 epochs. Each epoch consists of 10,000 random training samples, which are evaluated and trained in batches of 100 samples. Testing Phase: In order to provide a statistically insightful evaluation and comparison, the models are tested for different cases of varying number of tasks and varying number of robots with each case having 100 random test scenarios from training data distribution. Here, for each task in a sample scenario, the location of the tasks, time deadline, location of the depot are all generated from a random uniform distribution. More details on the learning framework is given in Appendix C. The training and testing settings and the modifications to AM for MRTA are given in Appendix D.

heading: D.4 BASELINES
text: BiG-MRTA: The BiG-MRTA algorithm Ghassemi & Chowdhury (2021); Ghassemi et al. (2019) is an online method based on the construction and maximum weighted matching of a bipartite graph. BiG-MRTA (Ghassemi & Chowdhury, 2021) uses a novel combination of a bipartite graph construction, an incentive model to assign edge weights in the bigraph, and maximum weighted matching (based on the Karp algorithm (Karp, 1980)) over the bigraph to allocate tasks to robots. This method has been developed as an online solver for SR-ST type MRTA problems, where tasks have
deadlines, new tasks could appear during the mission, and robots are subject to range and payload constraints.
AM: The number of attention heads for the encoder is 8, with 3 layers of encoding. The node embedding length is 128.
Feas-RND: In the Feas-RND approach, each robot randomly chooses available tasks that are feasible to be undertaken by the UAV, satisfying all the constraints in section 2.2. The algorithm used for Feas-RND can be found in (Ghassemi & Chowdhury, 2021).

heading: D.5 MORE DETAILS ON TRAINING FOR MRTA
text: Learning Curve : In order to compare the convergence of the proposed CAM method with that of the AM approach, we run both methods with similar settings and plot their learning curve (convergence history), as shown in Fig. 4 in appendix D. As seen from this figure, the AM method took 3 epochs to reach its best cost value and stagnated. On the other hand, the CAM method took 20 epochs to reach the best cost value of AM and continued to improve up to∼24 epochs, leading to a significantly better cost function value (f∗cost,CAM = −0.266) compared to AM (f∗cost,AM = −0.009). The stagnation of AM could be attributed to direct implementation of the transformer network (Vaswani et al., 2017), which was designed for machine translation and thus consists of multiple layers of Multi-head attention. In contrast, our CAM model uses simple linear transformations of the node properties and its relative differences in local neighborhoods to capture structural information.
0 20 40 60 80 100
Epoch
0.2
0.1
0.0
0.1
0.2
0.3
Co st
Fu nc
tio n
CAM AM
Figure 4: MRTA: Learning curve of CAM and AM for 200 tasks.
Modifications to AM: The attention-based mechanism (AM) reported by (Kool et al., 2019) has been shown to solve a few different classes of single-agent/robot combinatorial optimization problems. To be able to implement the AM method for our problem (for comparison with our CAM method), the AM method is adapted to a multi-robot setting. For this purpose, we make the following three changes to the AM method: (i) The node properties that are defined in Section 2.1 are used in AM; (ii) The context for the attention mechanism is modified to be the same as that used for CAM; and (iii) The cost function used for training is changed to that in Eq. equation 1.
We want to compare the structural representational quality of CAM and AM for generalizability and scalabilty. Hence, for a fair comparison, both CAM and AM models were trained with the same settings (Table 6 and14).

heading: D.5.1 COMPUTING TIME (TRAINING AND EXECUTION)
text: Based on the epoch information in Section D.3, the average time to complete a training epoch was found to be 19.50 minutes (i.e., ∼11.7 seconds per sample) for CAM and AM. The average computing time (from Tables 1 and 2) taken by the learnt policies for producing the entire MRTA solution (sequence of tasks assigned to each robot) was found to grow from 0.14 s to 20 s, as the number of tasks grew from 50 to 1000, and thus remaining unprecedentedly attractive for real-time decision-making even for large problems.

heading: E MRTA – MULTI-UAV FLOOD RESPONSE: FURTHER RESULTS

heading: E.1 TASK COMPLETION RATE AND COMPUTATION TIME
text: Table 7 shows the completion rate which corresponds to the test cases for generalizability (Table 1) and the test for scalability (Table.2), respectively.
Figure 5, shows the comparison of the average computation time between CAM and BiG-MRTA. It can be seen that, the computation time of BiG-MRTA increases exponentially as compared to that of CAM. Even though the completion rate for BiG-MRTA is slightly greater than that of CAM as can be seen from table 7, this advantage comes with a very high computational cost. This shows the scalability of CAM to larger-sized problems. On comparing the cost function in tables 1 and 2, it can be seen that, compared to BiG-MRTA, the performance of CAM drops for scenarios with higher tasks/robot ratios (such as 200-tasks-20-robots, 500-tasks-50-robots). However, this dip in performance is marginal when comparing the task completion rate (in tables 7), with the maximum dip in performance for CAM being 7.3% (between 100-tasks-10-robots and 100-tasks-20-robots). One of the reason for this behaviour, is due to the cost function (Eq.1), where the distance minimization is only taken into account when the task completion rate is 100%. Hence, we also compared the performance of CAM, AM, and BiG-MRTA on a benchmark MRTA problem in section 5.2, where
the objective is just to maximize the task completion rate, in which CAM demonstrates a superior performance compared to the other methods.

heading: E.2 ABLATION STUDIES
text: For Encoder: In order to study the true impact of the graph node encoding, we compared the performance of CAM with it’s covariant based encoding removed to get a new model CAMEFF . In this case the, node encoding is performed using a simple feedforward network, following Eq.14. The decoder for CAMEFF is the same as that of CAM .
Fdi = W ddTi + bd (13)
Fi = W FFdi + bF (14)
where, di = [xi, yi, τi], ∀i ∈ V . W d, WF , bd, and bF are learnable weights and biases, where W d ε Rdembed×3, bd ε Rdembed×1, and WF ε Rdembed×dembed , bF ε Rdembed×1
For Decoder: In order to study the impact of the MHA based decoder, we compare the performance of CAM, with it’s decoder being replaced by a simple feedforward network to get a new model CAMDFF , which takes in the node embeddings and the context information, and computes the output probabilities using the following equations. The encoder for CAMDFF is the same as that of CAM .
PAct = softmax([PAct1 , . . . , P Act N ]), (15)
PActi = LeakyReLU(W decConcat(Fi,Q)T + bdec), where i ∈ V (16)
Here W dec and bdec are learnable weights and biases, where W dec ∈ RN×2dembed and bdec ∈ RN×1. Fi ∀ i ∈ V are the node embeddings from the encoder, and Q ∈ Rdembed is the context vector. The value of dembed for both the models is the same as that of CAM in section 5. Both the models were trained on the MRTA-Multi-UAV flood response problem in section 4, using the parameters in table 6, and tested on the same test scenarios as that used for CAM , AM , and BiG-MRTA, for varying number of locations and varying number of robots (shown in table 8). The third and the fourth column in table 8 shows the average cost function of 100 test scenarios, and it’s corresponding % completion rate, for CAMEFF and CAMDFF ablation study, respectively.
As can be seen from table 8, the performance of both CAMEFF and CAMDFF is significantly poor compared to CAM , in terms of both cost function and task completion rate. The performance drop is more for scenarios with lower number of robots, with the maximum drop in task completion rate being for CAMEFF being 19.8% (for 50-tasks-5-robots), and for CAMDFF being 13.4% (for 200-tasks-20-robots). It can also be observed that, the performance drop is greater for CAMEFF than CAMDFF , this indicates that the CCN-based encoder has a slightly more influence on the performance, than the decoder.

heading: F MRTA - TASK ALLOCATION PROBLEM W/ TIME & CAPACITY (TAPTC)

heading: F.1 PROBLEM DESCRIPTION AND FORMULATION
text: In order to assess the effectiveness of the CAM architecture for MRTA problems with time-extended assignments, we test and validate our CAM on Task Allocation Problem with Time and Capacity (TAPTC) benchmark problem Mitiche et al. (2019), which falls into the ST-SR-TA-TW (Single Task robot, Single Robot task, Time-extended Assignment, TimeWindows). The TAPTC involves task locations within a 100 × 100 grid map, with each task i having a time deadline ti, and also a workload wi. Each robot j has a work capacity of cj . All the robots move with a maximum speed of 1 unit per second. A task i is considered to be completed only if a robot j visits node i and spends a time of wi/cj . Each scenario is generated based on a uniform distribution reported in Mitiche et al. (2019) and the training samples for our models are generated from the same distribution.
For evaluating the performance of the learned model and conducting a comparative analysis, we use the TAPTC dataset (accessible from http://tinyurl.com/taptc15in. This dataset consists of test cases with 100 tasks and varying number of robots (A = 2, 3, 5, 7 robots), and the speed of every robot is considered to be the same (1 unit per second). The test cases can be divided equally into two groups, based on tight deadlines (Group 1) and slack deadlines (Group 2). Each group can be further divided into 4 sub-categories based on the fraction of tasks (R = 25%, 50%, 75%, and 100%) that have normally distributed task deadlines. For example, 25% indicates that there are 25 tasks with deadlines normally distributed between the limits tlow and thigh, while the remaining 75 tasks have a deadline of thigh. For group 1 (tight deadline), the value of thigh is considered as half as that for group 2 (tight deadline). In both the groups, for all values of A and R, there will be 3 samples. Therefore the total number of test cases is given by number of groups × |A| × |R| × 3) = 96, where each group has 48 test cases. Further description of the test cases can be found in Mitiche et al. (2019).
The exact solution of the MRTA-TAPTC problem can be obtained by formulating it as the following integer non-linear programming (INLP) problem:
min fcost = N∑ i=1 ri,
{ ri = τfi τi , if τfi > τi
0, otherwise (17)
subject to
si ∈ S ∀ i ∈ [1..N ] (18) si 6= sj ∀ i 6= j (19)
Here, N is the number of tasks/nodes, τfi is the time at which task i was completed, τi is the time deadline of task i, and S = [s1, s2, ...sN ] is the sequence of all the nodes that were visited. The minimum cost function that can be achieved using Eq. 1 is 0, which corresponds to the case where all the tasks are successfully completed. A detailed formulation of the exact ILP constraints that describe the MRTA-TAPTC problem can be found in Mitiche et al. (2019). Note that, in our paper we use a slightly different reward function as compared to the objective function in Mitiche et al. (2019), but the intention of both the functions are essentially the same, which is to maximize the number of successfully completed tasks.
Here, we craft the objective function (Eq. equation 17) such that only missed tasks (τfi > τi) contribute to the cost function. It is important to note that the objective function can be tailored according to the priority of the problem. Since the main priority in Mitiche et al. (2019) is to maximize the number of successfully completed tasks, the objective function (Eq. 17) also prioritizes task completion for a fair comparison with the baseline methods. The constraints in Eq. 18 and 19 are such that each tasks must be visited exactly once by any robot.

heading: F.2 MODIFICATIONS TO CAM AND AM
text: 1. Change in encoder: The encoder for MRTA-TAPTC problems consider additional node properties, namely the location of the tasks (xi, yi), the time deadline (τi), and the workload wi, i.e., di = [xi, yi, τi, wi].
2. Change in context: The context for the MHA layer in the decoder consists of the following five features: 1) elapsed mission time; 2) Work capacity of the robot taking decision; 3) Current location of robot taking decision; 4) Current destination of peers; and 5) Work capacity of peer.
3. Cost function: We use Eq. 17 as cost function.
The decoder need no change in this case.

heading: F.3 BASELINE METHODS
text: We consider three non-learning methods, which are i) Iterated Local Search (ILS), ii) Enhanced Iterated Local Search (EILS), iii) Bi-Graph MRTA (BiG-MRTA), which are briefly described below. The learning based baseline method we implemented here is AM with minor modifications as also discussed below.
i) Iterated Local Search (ILS): This is an online meta heuristic iterated search algorithm Vansteenwegen et al. (2009), where the output of one iteration is partially used as the input to the next iteration. During each iteration, the best solution is improved by a perturbation step, followed by a local search.
ii) Enhanced Iterated Local Search (EILS): EILS is also an online meta heuristic iterated search method Mitiche et al. (2019), with an improved perturbation step as compared to Vansteenwegen et al. (2009).
iii) Bi-Graph MRTA (BiG-MRTA): The BiG-MRTA algorithm Ghassemi & Chowdhury (2021); Ghassemi et al. (2019) is an online method based on the construction and maximum weighted matching of a bipartite graph. BiG-MRTA (Ghassemi & Chowdhury, 2021) uses a novel combination of a bipartite graph construction, an incentive model to assign edge weights in the bigraph, and maximum weighted matching (based on the Karp alogirthm (Karp, 1980)) over the bigraph to allocate tasks to robots. This method has been developed as an online solver for SR-ST type MRTA problems, where tasks have deadlines, new tasks could appear during the mission, and robots are subject to range and payload constraints.
iii) AM: The AM implementation is almost the same for the MRTA-TAPTC problem as that implemented for the multi-UAV flood response problem in section D.3. In addition, the changes implemented in CAM, as explained in Section F.2, are also applied here. The number of attention heads for the encoder is 8, with 3 layers of encoding. The node embedding length is 128.
Both CAM and AM are trained using REINFORCE as described in algorithm 1 using the settings given in Table 9.

heading: F.4 RESULT AND DISCUSSIONS
text: Tables 3 and 10 summarize the performance of CAM alongside the baseline methods, in terms of the average completion rate, i.e, the ratio of the number of successfully completed tasks to the total number of tasks averaged over 3 samples for all the scenarios (denoted by A and R). The CAM model here uses k = 9, where k represents the number of nearest neighbors considered for a node for computing its node embedding. For group 1, the CAM model was able to generate the best results for 8 out of the 16 different scenarios (Table 10). From Table 10, it can be inferred that CAM has a superior performance compared to the baselines for cases with larger number of robots (best performance for all cases withA = 7, and for 3 out of 4 scenarios withA = 5), including a maximum
margin of 19% for R75A7 compared to the next best solution (EILS). While for cases with smaller number of robots (A = {2, 3}), CAM achieved the best performance for one scenario (R25A3), with the worst performance having a margin of only 7% (scenario R75A3) compared to best performer (EILS) in that case.
For group 2, CAM achieves top performance for all scenarios with A = {5, 7}, while achieving top performance for 50% of the scenarios with A = 2, 3, as discussed in Section 5.2 of the main text.
Tables 11 and 4 gives the average computation time (in milliseconds) to generate the entire solution for all the methods. As it can be seen from these tables, for the non-learning methods EILS and BiG-MRTA, the general trend is an increase in the computation time with increasing number of robots, while for both the learning-based methods (CAM and AM) the computation time increases marginally with increasing number of robots.

heading: F.5 MORE DETAILS ON TRAINING DATASET FOR MRTA-TAPTC
text: Each training sample has 100 tasks, and are located randomly within a 100 × 100 grid map. Each task i has a time deadline 50 ≤ τi ≤ 600, and a workload 10 ≤ wi ≤ 30. Each sample has nr number of robots where 2 ≤ nr ≤ 7. The initial positions of the robots in a sample is also chosen randomly within the grids. Each robot j has a work capacity of cj where 1 ≤ cj ≤ 3. All the robots move at a speed of 1 unit. A task i is considered to be completed only if a robot j visits node i and spends a time of wi/cj . All the training samples are generated such that all the associated variables (mentioned above) follow a uniform distribution within their respective bounds.
F.6 IMPACT OF NEIGHBORHOOD SIZE FOR CAM ENCODER
Tables 12 and 13 compare the performance of CAM models with varying neighborhood size (k) in the encoder, based on the average completion rate (average of the 3 samples) for all the scenarios (all
values of A and R for the two groups). The impact of the neighborhood size k (during encoding) is more evident on the performance of Group 1 test cases which has tasks with more number of tight deadlines. As shown in Table 12, the completion rate of CAM (with k = {6, 9, 12}) are almost comparable, while the performance of CAM with k = 3 is significantly lower than the other models. Lower the neighborhood size, smaller will be the local structural information learned, which could result in performance loss. However, increasing neighborhood size beyond a point may not necessarily improve performance. The average epoch time for training for the models with k = {3, 6, 9, 12} are 11, 13, 14.3, and 15 minutes respectively. Figure 6 shows the learning curve for training all the CAM models and AM model.

heading: G FURTHER DETAILS ON CAPACITATED VEHICLE ROUTING PROBLEM

heading: G.1 FORMULATION OF CAPACITATED VEHICLE ROUTING PROBLEM (CVRP)
text: The vehicle routing problem here we considered is a capacitated vehicle routing problem (CVRP), where a vehicle is required to deliver packages to a number of locations N . Each task is designated an index from 1 to N . We also consider a depot with id as 0. Each location has a demand ci on the number of packages where i ∈ [1, N ], and the vehicles has a constraint for the maximum number of packages C it can carry, such that ci < D. We assume that each package is of the same size. The vehicle is required to create multiple routes visiting different locations to deliver the packages. The vehicle starts from a depot, has a maximum capacity for the number of packages, and can have multiple routes to deliver all the packages satisfying the demands in every location. Here we assume that the vehicle can return to the depot for refilling to maximum capacity before starting a new route. In this experiment we do not consider split delivery where the demand of a location is fulfilled partially during a route, and then completed in another route. The ILP formulation for CVRP can be represented as:
min fcost = Σδj , j ∈ [1, R] (20)
subject to Ct+1 = {
max(0, Ct − ci) i 6∈ V D, i = 0
(21)
where R is the number of routes, δj is total distance travelled in route j, Ct is the available capacity at a time t, V is the set of locations visited. The node encoding and the context encoding are modified for CVRP (as explained in appendix G.1.1 and G.1.2) for both CAM and AM. Both CAM and AM are trained for the scenarios with 100 locations and tested on the unseen scenarios with varying number of locations ranging from 50 to 1,000. The experimental details of this comparative study are given in Appendix G.2.

heading: G.1.1 ENCODING FOR CVRP
text: Except for the node properties, all the other steps for computing the node embeddings is same for CVRP as compared to MRTA for CAM and AM. The node properties associated with the CVRP
includes the x coordinate, y coordinate, and the demand ci for each location. Therefore each node can be represented as di = [xi, yi, ci], where xi, yi, and ci are the x coordinate, y coordinate, and capacity respectively for node i. For the encoding,di for CVRP will be used in equation 22 for CAM.
F di = W ddTi + bd (22)

heading: G.1.2 CONTEXT ENCODING
text: The context serves the same purpose for which is represent the current state. For CVRP the current location and the remaining capacity as the context, for CAM and AM.

heading: G.2 TRAINING DETAILS FOR CVRP
text: The training procedure for CVRP follows algorithm 1 in appendix D with the only change being in the calculation of the cost. Equation 20 is used in the algorithm 1 to compute the cost. Table 14 shows the different parametric setting for training CAM and AM for CVRP. CAM and AM models were trained for 100 tasks and tested on CVRP with 5 different task sizes (50, 100, 200, 500, 1000). Figure 7 shows the learning curve for training CAM and AM.

heading: G.3 BASELINE DETAILS FOR CVRP
text: Lin-Kernighan heuristics (LKH3): We performed a single run with a maximum number of trails as 10000.
AM: Same as that of MRTA-Multi-UAV flood response and MRTA-TAPTC.
Google OR tools: The first solution strategy algorithm used was PATH CHEAPEST ARC and the local search algorithm was Simulated Annealing.

heading: G.4 MORE DETAILS ON CVRP DATASET
text: The dataset used for training CVRP consists of scenarios with 100 locations and one depot. The x and y coordinates of the locations (including the depot) are randomly generated from a uniform distribution within the limits [0, 1]. The demand for all task locations will be a random integer from a uniform distribution between [1,9], with depot assigned a 0 demand. The vehicle capacity (C)
for a scenario with 100 locations, is considered as 50. The dataset used for testing (to analyze both generalizability and scalibility) has the same limits as explained above. The assumed capacity of the vehicle for test scenarios of different number of locations are shown in Table 15.

heading: H LIMITATIONS OF CAM
text: This work is implemented for a fixed number of nodes but can be easily extended for cases where nodes are determined dynamically. The impact of the learning algorithm parameters such as the learning rate, training frequency or training batch size, etc. is not analyzed. Parametric analysis of the learning algorithm, as well as the implementation of more recent state-of-the-art RL algorithms (e.g., PPO), can be considered as other directions of future work with CAM. The current learning framework for CAM has been implemented with a greedy approach for decision-making. The performance can be improved by adopting an epsilon greedy approach. In real-world settings, it is possible that two robots want to make decisions at the same time, which might cause them to visit the same location. This is very rare and there are various mitigations to address this issue. For example, while robots are moving toward their selected task locations, they can check if their decision is conflicting with another robot based on recent information. If there is conflict, the robot with the worst time can cancel its current task and select a new task.

heading: I ABBREVIATIONS:

Review summaries:
This paper presents an interesting idea of using neural-network-based RL to solve a type of vehicle routing problems, where the vehicles are tasked with visiting spatial locations to deliver items, and are subject to load capacity and delivery time constraints. In order to solve this problem, the authors propose an encoder-decoder architecture to decide for each robot, where to move next. The encoder is inspired from the Covariance Compositional Networks and the decoder utilizes an attention module, and the network is trained via REINFORCE. The results show that the proposed method outperforms the baseline in unseen test cases, in terms of task completion rate and the specified cost function.

The paper proposes a graph learning approach for solving the multi-robot task allocation (MRTA) problem. It frames the problem as a Markov Decision Process (MDP) and trains a policy with a graph neural network architecture using REINFORCE. Results show that the proposed approach scales better compared to a non-learning baseline and is more accurate than a multi-headed attention (MHA) approach.

This paper proposed a neural architecture for learning to solve multi-robot task allocation (MRTA) problems. The MRTA problem is modeled as a MDP, and then the so-called covariant attention-based neural architecture (CAM) is proposed. The main paper contribution is the CAM architecture.  Case studies are presented in which the proposed CAM is compared with other learning based and non-learning based methods. In the reported experiments CAM obtained smaller errors (average cost) and smaller processing time. 

This paper considers the multi-robot task allocation problems. To address the limitations of existing studies, such as real-world constraints, larger-sized problems and generalizations, this paper proposed a learning architecture, Covariant Attention-based Mechanism. They further conduct adequate evaluations and the results have shown great improvements over the state-of-the-art methods.  

This paper proposes a new method, including neural network architecture, for solving time-constrained multi-robot task allocation (MRTA) problems. The proposed approach models the target problem as a Markov Decision Process (MDP) over graphs and use Reinforcement Learning (RL) methods to solve the problem. The proposed learning architecture is called Covariant Attention-based Mechanism (CAM).  The architecture is shown to have better performance than an existing state-of-the-art encoder-decoder method regarding task completion, cost function, and scalability. Though the performance is still lower than non-learning-based baseline methods, i.e., BiG-MRTA, the computational cost is significantly smaller than the baselines.