Simultaneous Task Allocation for Multi-Robot systems using ASyMTRe-D

1. Spondon Saha
Fall 2010
Masters Thesis Presentation
Department of Computer Science
Cal Poly Pomona.

2.  Introduction
 ASyMTRe-D
 Combinatorial Auctions
 The Simultaneous Task Allocation (STA) algorithm
 The A* enhancement
 The IDA* enhancement
 Simulation Setup
 Performance Metrics
 Time Complexity
 Space Complexity
 Future Work
 Conclusion
 Q&A
2

3.  Automated Synthesis of Multi-robot Task
solutions through software Reconfiguration.
 ASyMTRe:
 determines a coalition of robots to accomplish a multi-robot
task.
 uses schema theory to determine a robot coalition.
 robot teams can be heterogeneous in nature.
3

4.  Heterogeneous group of robots???
 Robots with different functional capabilities.
 Multi-robot task???
 A task that cannot be carried out by a single robot.
 Requires a “strongly cooperative” solution.
4

5.  ASyMTRe
 Centralized algorithm.
 Has full information regarding all robots and task parameters.
 Suffers from single point of failure.
 ASyMTRe-D
 Distributed ASyMTRe.
 Runs locally on each robot.
 Uses a group negotiation process to determine coalitions.
▪ Uses the Contract Net Protocol (CNP) for negotiation.
 Does not have all the information for creating optimal solutions.
5

6. R1
R4 R3
R2R5
Multi-robot
Task
Idle Robots
6

7.  ASyMTRe-D takes into account:
 Task-Specific cost.
 Robot-inherent cost.
 Determines a suitable mapping between
 Tasks.
 Robots.
7

8.  Problem:
 Can handle only one task at a time.
 Each round results in idle robots.
 Desired behavior:
 Need to reduce instances of idle robots.
 Make idle robots work on other tasks (if any).
 Instantaneously allocate multiple tasks to different
coalitions.
8

9.  Proposed approach
9

10.  Sequential Auctions.
 Parallel Auctions.
 Combinatorial Auctions.
10

11. Item 1 Item 4Item 3Item 2 Item 5
Auctioneer
[1,2] [1,3,5] [3,5] [1, 4]
??? ???
,[2,5]
11

12.  Complexity:
 A NP-Hard problem.
 Similar to the Partitioning problem → NPC.
 Dynamic Programming:
 Long execution time.
 Explores the entire solution space.
 Scales to only a small number of bids.
12

13.  Solution:
 An Anytime tree algorithm.
 Explores only the relevant solution space of
submitted bids.
 Polynomial in the number of bids submitted.
13

14. Bids:
1
2
3
4
5
1,2
1,3,5
1,4
2,5
3,5
Root
1,2
3,5 3
4 4
5
1,3,5
4
2
1,4
2,5 2
3 3,5 3
5
1
2,5 2
3 3,5 3
44 4
5
14

15.  ASyMTRe-D Drawbacks:
 Can accomplish tasks sequentially.
 Idle robots are waste of resources.
 Need:
 A task scheduler or an instantaneous task allocation system.
 Least robot idle-time → maximum utilization of resources.
 Inspiration for STA:
 Combinatorial Auctions.
15

16. Task1 Task 2 Task 3
{R1,R2,
$3}
R
2
R3R1
{R2,R3,
$4}
{R3, $5}
{R1,R2,
$4}
{R2, $1}
{R3, $3}
{R1,R3,
$4}
{R2,R3,
$4}
16

17. `
Tas
k
Bids
1
{R1, R2,
$3}
{R2, R3,
$4}
{R3, $5}
2
{R1, R2,
$4}
{R2, $1}
{R3, $3}
{R1, R3,
Ro
ot
R1,
R2
R2,
R3
R3
3 4 5 0
R3
6 3 4
R1,
R2
9
R2
6 5
R1,
R2
4
R
2
1
R
3
3 0
R2,
R3
4
R1,
R3
4
R1,
R3
5
17

18.  Anytime property:
 Will return a suboptimal solution if terminated early.
 If given enough time, will always return an optimal solution.
 Each path is a set of disjoint coalitions → Partition.
 All possible partitions of robots are considered.
 Only relevant solution space of submitted bids are considered.
 Run time complexity depends on:
 Number of bids submitted.
 Number of tasks considered.
18

19. 
 


Task B Task C …… Task N
STA Algorithm
Task D Task E Task F

 

 
 

 
 

 



Task A
19
ASyMTRe-D
equipped…

20.  Problems:
 Execution time is exceedingly long.
 The entire tree is generated irrespective.
 Need:
 Faster execution time.
 Generate only relevant parts of tree.
20

21.  The A* variant
 Uses an admissible heuristic to generate only parts of the
tree.
 Heuristic determines which path holds the highest
probability of containing the winning coalitions.
21

22. `
Tas
k
Bids
1
{R1, R2,
$3}
{R2, R3,
$4}
{R3, $5}
2
{R1, R2,
$4}
{R2, $1}
{R3, $3}
{R1, R3,
Ro
ot
R1,
R2
R2,
R3
R3
9 4 20 8
R3
R1,
R2
14
R2
11 5
R1,
R2
R
2
R
3
R2,
R3
R1,
R3
R1,
R3
22

23.  The IDA* variant:
 Execution time comparable to A*
 Does not store all nodes in previous state in
memory
▪ Less memory footprint.
▪ Should ace in space complexity.
 Optimal STA algorithm variant.
23

24.  The BFS variant generates the entire tree
 A* variant only generates parts of the tree
that holds a high probability of containing
winning coalitions.
 IDA* variant does the same as A*, but
consumes less memory and is as fast as A*.
24

25.  Test Environment:
 CPP’s “Garrison” and “Fluffy” servers.
 3.16 GHz Intel Xeon Octa-Core Processors.
 8 GB of RAM.
 Implementation in Python.
 Objective:
 To measure the execution time of the algorithm and its variants.
 To measure the space complexity of each of the variants and compare
them.
 Parameters for testing:
▪ For increasing bids.
▪ For increasing task sizes.
25

26.  Random Distribution:
 Task Sizes → 20, 40, 60, 80, 100
 Robots → 10
 Coalition sizes range from → 1 to 9
 Uniform Distribution:
 Task Sizes → 20, 40, 60, 80, 100
 Robots → 10
 Maximum allowed coalition size → 3
 Bounded Distribution:
 Task Sizes → 20, 40, 60, 80, 100
 Robots → 10
 Coalition sizes range from → 3 to 6
26

27. 27

28. 28
Task # of Bids
T1 2
T2 4

29. Random Distribution (80
Tasks)
29

30. Uniform Distribution (80
Tasks)
30

31. Bounded Distribution (80
Tasks)
31

32. Random Distribution (80
Tasks)
32

33. Uniform Distribution (80
Tasks)
33

34. Bounded Distribution (80
Tasks)
34

35.  Demonstrate the complete approach using
ASyMTRe-D.
 Treasure Hunt Mission
 Site-clearing Mission
 Create a distributed variant of the STA algorithm
 Load-balance work load
 Fault-tolerance
 Problem: Could return suboptimal solutions
35

36.  Multiple tasks are being considered.
 All possible mapping of tasks to coalitions.
 No restriction on coalition size.
 Instantaneous allocation of multiple tasks.
 STA (Higher level).
 ASyMTRe-D (Lower level).
 An Anytime Algorithm.
36

37. 37