Spondon Saha
Fall 2010
Masters Thesis Presentation
Department of Computer Science
Cal Poly Pomona.
 Introduction
 ASyMTRe-D
 Combinatorial Auctions
 The Simultaneous Task Allocation (STA) algorithm
 The A* enhancemen...
 Automated Synthesis of Multi-robot Task
solutions through software Reconfiguration.
 ASyMTRe:
 determines a coalition ...
 Heterogeneous group of robots???
 Robots with different functional capabilities.
 Multi-robot task???
 A task that ca...
 ASyMTRe
 Centralized algorithm.
 Has full information regarding all robots and task parameters.
 Suffers from single ...
R1
R4 R3
R2R5
Multi-robot
Task
Idle Robots
6
 ASyMTRe-D takes into account:
 Task-Specific cost.
 Robot-inherent cost.
 Determines a suitable mapping between
 Tas...
 Problem:
 Can handle only one task at a time.
 Each round results in idle robots.
 Desired behavior:
 Need to reduce...
 Proposed approach
9
 Sequential Auctions.
 Parallel Auctions.
 Combinatorial Auctions.
10
Item 1 Item 4Item 3Item 2 Item 5
Auctioneer
[1,2] [1,3,5] [3,5] [1, 4]
??? ???
,[2,5]
11
 Complexity:
 A NP-Hard problem.
 Similar to the Partitioning problem → NPC.
 Dynamic Programming:
 Long execution ti...
 Solution:
 An Anytime tree algorithm.
 Explores only the relevant solution space of
submitted bids.
 Polynomial in th...
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
 ASyMTRe-D Drawbacks:
 Can accomplish tasks sequentially.
 Idle robots are waste of resources.
 Need:
 A task schedul...
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
`
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...
 Anytime property:
 Will return a suboptimal solution if terminated early.
 If given enough time, will always return an...

 


Task B Task C …… Task N
STA Algorithm
Task D Task E Task F

 

 
 

 
 

 



Task A
19
ASyMT...
 Problems:
 Execution time is exceedingly long.
 The entire tree is generated irrespective.
 Need:
 Faster execution ...
 The A* variant
 Uses an admissible heuristic to generate only parts of the
tree.
 Heuristic determines which path hold...
`
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 ...
 The IDA* variant:
 Execution time comparable to A*
 Does not store all nodes in previous state in
memory
▪ Less memory...
 The BFS variant generates the entire tree
 A* variant only generates parts of the tree
that holds a high probability of...
 Test Environment:
 CPP’s “Garrison” and “Fluffy” servers.
 3.16 GHz Intel Xeon Octa-Core Processors.
 8 GB of RAM.
 ...
 Random Distribution:
 Task Sizes → 20, 40, 60, 80, 100
 Robots → 10
 Coalition sizes range from → 1 to 9
 Uniform Di...
27
28
Task # of Bids
T1 2
T2 4
Random Distribution (80
Tasks)
29
Uniform Distribution (80
Tasks)
30
Bounded Distribution (80
Tasks)
31
Random Distribution (80
Tasks)
32
Uniform Distribution (80
Tasks)
33
Bounded Distribution (80
Tasks)
34
 Demonstrate the complete approach using
ASyMTRe-D.
 Treasure Hunt Mission
 Site-clearing Mission
 Create a distribute...
 Multiple tasks are being considered.
 All possible mapping of tasks to coalitions.
 No restriction on coalition size.
...
37
Upcoming SlideShare
Loading in …5
×

Thesis Presentation

919 views

Published on

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

Published in: Technology, Business
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
919
On SlideShare
0
From Embeds
0
Number of Embeds
11
Actions
Shares
0
Downloads
10
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide
  • NOTES:

    ASyMTRe-D is a distributed resource allocation system for multi-robot environments.

    ASyMTRe-D is used to:
    determine a suitable coalition of robots
    from a heterogeneous group of robots
    that can work together to accomplish a given multi-robot task.

    A copy of ASyMTRe-D runs as a local copy on each robot. This has been shown to scale better than its centralized counterpart for increasing numbers of robots.

    Definitions:

    Heterogeneous Group of Robots – Robots that have different sensor and effector capabilities as opposed to a homogeneous group of robots where each robot in the group has the same set of sensors and effectors.

    Multi-Robot Tasks – Tasks that are not trivially serializable and cannot be decomposed into subtasks that can be completed by individual robots operating independently. These tasks require a “strongly cooperative” solution, meaning it requires the robots to act in concert to achieve the task. This type of task is classified as “tightly-coupled” or “tightly-coordinated”.

    Sensor – A device used by a robot to perceive and measure various features in its surrounding environment. Some examples of sensors are: Sonar Sensors, Laser sensors, GPS, Cameras, etc.

    Effector – A device used by the robot that produces or causes a change in the surrounding environment for the means of accomplishing a programmed goal or task. Actuators are also known as effectors and examples of them are: motors, servos, robotic arms, grippers, etc.
  • NOTES:

    ASyMTRe-D is a distributed resource allocation system for multi-robot environments.

    ASyMTRe-D is used to:
    determine a suitable coalition of robots
    from a heterogeneous group of robots
    that can work together to accomplish a given multi-robot task.

    A copy of ASyMTRe-D runs as a local copy on each robot. This has been shown to scale better than its centralized counterpart for increasing numbers of robots.

    Definitions:

    Heterogeneous Group of Robots – Robots that have different sensor and effector capabilities as opposed to a homogeneous group of robots where each robot in the group has the same set of sensors and effectors.

    Multi-Robot Tasks – Tasks that are not trivially serializable and cannot be decomposed into subtasks that can be completed by individual robots operating independently. These tasks require a “strongly cooperative” solution, meaning it requires the robots to act in concert to achieve the task. This type of task is classified as “tightly-coupled” or “tightly-coordinated”.

    Sensor – A device used by a robot to perceive and measure various features in its surrounding environment. Some examples of sensors are: Sonar Sensors, Laser sensors, GPS, Cameras, etc.

    Effector – A device used by the robot that produces or causes a change in the surrounding environment for the means of accomplishing a programmed goal or task. Actuators are also known as effectors and examples of them are: motors, servos, robotic arms, grippers, etc.
  • NOTES:

    R1, R2, R3, R4 and R5 are a heterogeneous group of robots.

    Each Robot has different sensing and effector capabilities.

    When a multi-robot Task-A is presented to the group, an instance of ASyMTRe-D on each robot initiates a group negotiation process with the other robots.

    By taking into account the cost of carrying out Task-A and the contributions available from each robot, ASyMTRe-D determines a suitable coalition/group of robots that can carry out Task A.

    Once ASyMTRe-D determines a coalition, the selected robots carry out the task.

    ASyMTRe-D is a distributed resource scheduling system for multi-robot environments.s
  • NOTES:

    ASyMTRe-D works by allocating robots to a particular multi-robot task.

    ASyMTRe-D works by taking into account:
    the cost of performing the task (task-specific cost).
    the costs induced by each robot for performing that task (robot-inherent cost).
    Using these two sets of data, ASyMTRe-D tries to find the right coalition of robots whose collective inherent cost is a perfect match for the task-specific cost.

    ASyMTRe-D can only handle one task at a time, which means that there are frequent cases where some robots are not allocated into the coalition for carrying out a particular task. This results in “idle robots” which is a waste of resource.
  • NOTES:

    “Combinatorial Auctions” are like parallel auctions where all the items are presented at once except bidders are allowed to bid on any combinations of items.

    Bidders in a combinatorial auction are generally “happy bidders” because they can bid on the set of items that they have their eyes on and still compete fairly with other bidders.

    The problem arises in the case of the auctioneer who has to determine the winning combination of items because each submitted bid can have overlapping items and so there is no simple method to determine the winner.

    Definitions:

    Sequential Auctions – An auction where the items are presented sequentially and bidders place bids as the items are presented.

    Parallel Auctions – An auction where all the items are presented before bidding ensues and then bidders can bid on individual items.
  • NOTES:

    Dynamic Programming is one approach to determine the winners but that can result in exploring the entire solution space, compared to exploring only the relevant solution space. So the execution time can be unnecessarily long, which means that this approach is valid for only a small number of bids.

    This is a NP-Complete problem which is very similar to the Partitioning Problem (also NP-complete).

    An appropriate solution is an Anytime Algorithm that explores only the relevant solution space for winner determination. The algorithm is polynomial in the number of bids submitted.

    Definitions:

    Anytime Algorithm – Also known as an “interruptible algorithm”, is one that can generate a partial answer even if the algorithm is terminated prior to completion.

    Partitioning Problem – The partition problem is an NP-complete problem in computer science. The problem is to decide whether a given multi-set of integers can be partitioned into two "halves" that have the same sum.
  • NOTES:

    Dynamic Programming is one approach to determine the winners but that can result in exploring the entire solution space, compared to exploring only the relevant solution space. So the execution time can be unnecessarily long, which means that this approach is valid for only a small number of bids.

    This is a NP-Complete problem which is very similar to the Partitioning Problem (also NP-complete).

    An appropriate solution is an Anytime Algorithm that explores only the relevant solution space for winner determination. The algorithm is polynomial in the number of bids submitted.

    Definitions:

    Anytime Algorithm – Also known as an “interruptible algorithm”, is one that can generate a partial answer even if the algorithm is terminated prior to completion.

    Partitioning Problem – The partition problem is an NP-complete problem in computer science. The problem is to decide whether a given multi-set of integers can be partitioned into two "halves" that have the same sum.
  • NOTES:

    Items are added to the tree starting with the least indexed bid.

    Each path in the tree is from the root node to the leaf node.

    Bids that contain items that already have been used in the path are not added.

    Each path is a collection of disjoint bids.

    Dummy bids are used so that all possible sets of combination bids are represented in the tree.

    The winning set of bids are the set of bids on a path that have the highest total bid value.

    Definitions:

    Partition of a Set – In mathematics, a partition of a set X is a division of X into non-overlapping “parts” or “blocks” or “cells” that cover all of X. More formally, these “cells” are both collectively exhaustive and mutually exclusive with respect to the set being partitioned.
  • NOTES:

    The current working version of ASyMTRe-D is designed to only handle one task at a time.

    So if there were a batch of tasks to be executed, the order in they get executed will affect the total execution time

    This evokes the need for developing a task-scheduler that can assign the tasks in an efficient manner such that the total execution time of tasks is minimized. This will call for maximum utilization of robots, resulting in minimum robot idle-time.

    Based on the anytime algorithm for winner determination in combinatorial auctions, an algorithm has been designed that will assign tasks simultaneously to ASyMTRe-D.

    The goal of the winner determination process is to find the set of coalitions for executing the batch of tasks such that the total contribution from the winner coalitions is maximized and the members in the winning coalitions do not overlap.
  • NOTES:

    Suppose 3 tasks (Task1, Task2, Task3) has been presented to a heterogeneous group of robots (R1, R2, R3).

    Using the approach of Combinatorial auctions, for each task ASyMTRe-D performs a group negotiation process and submits bids to each task. Each bid consists of the coalition of robots and the price of the bid (a dollar amount).

    In our current setting, the bid value is a weighted combination of both the “robot-inherent” cost (such as sensing and computational cost) and the “task-specific” cost (such as task completion time and success probability). For example, the coalition that can complete a task with a shorter time, higher success probability, and lower cost results in a higher bid value.
  • NOTES:

    All submitted bids are first arranged by their respective tasks.

    For each task, bids are added to the tree in a sequential order.

    Only those bids are added whose set of Robots form a disjoint set from the remaining bids already assigned on the current path. So this results in each path containing a disjoint set of bids.

    As bids are added, the total accumulated bid value is stored in each leaf node.

    An additional dummy bid of bid-value zero is added after each iteration, so that the space of possible sets of coalitions are well represented. This dummy bid is not added for the last iteration.

    Once the tree has been constructed, the path with the highest accumulated bid value is the winning partition of robots that are allocated to their respective tasks. This is done using depth-first search.

    In this example, robot coalition {R3} is assigned to “Task1” and coalition {R1,R2} is assigned to “Task2”. No robots could be allocated for “Task3” for the current round and so this task is saved for the next round.
  • NOTES:

    Due to the very nature of Anytime algorithms, this solution will always return an answer, even if execution is terminated prior to completion time.

    So, given enough time, this algorithm will generate the optimal solution.

    The algorithm also guarantees that each path is a disjoint set of bids, also known as a Partition.

    All possible partitions of robots are considered instead of restricting the size of a coalition for the sake of improving efficiency.

    Run time complexity of the algorithm depends on the size of the search space and therefore depends on the number of bids submitted and the number of tasks being considered.

    Definitions:

    Partition of a Set – In mathematics, a partition of a set X is a division of X into non-overlapping “parts” or “blocks” or “cells” that cover all of X. More formally, these “cells” are both collectively exhaustive and mutually exclusive with respect to the set being partitioned.
  • NOTES:

    Due to the very nature of Anytime algorithms, this solution will always return an answer, even if execution is terminated prior to completion time.

    So, given enough time, this algorithm will generate the optimal solution.

    The algorithm also guarantees that each path is a disjoint set of bids, also known as a Partition.

    All possible partitions of robots are considered instead of restricting the size of a coalition for the sake of improving efficiency.

    Run time complexity of the algorithm depends on the size of the search space and therefore depends on the number of bids submitted and the number of tasks being considered.

    Definitions:

    Partition of a Set – In mathematics, a partition of a set X is a division of X into non-overlapping “parts” or “blocks” or “cells” that cover all of X. More formally, these “cells” are both collectively exhaustive and mutually exclusive with respect to the set being partitioned.
  • NOTES:

    The current problem with the algorithm is that it uses Depth First Search to calculate the winning partitions. This involves looking at every path and so a better idea of the winning partition is required so that this exploration is minimized.

    In order to reduce the chances of extended execution time, we need to stress on generating sparser trees and hence require generating only the relevant parts of the tree.
  • NOTES:

    Due to the very nature of Anytime algorithms, this solution will always return an answer, even if execution is terminated prior to completion time.

    So, given enough time, this algorithm will generate the optimal solution.

    The algorithm also guarantees that each path is a disjoint set of bids, also known as a Partition.

    All possible partitions of robots are considered instead of restricting the size of a coalition for the sake of improving efficiency.

    Run time complexity of the algorithm depends on the size of the search space and therefore depends on the number of bids submitted and the number of tasks being considered.

    Definitions:

    Partition of a Set – In mathematics, a partition of a set X is a division of X into non-overlapping “parts” or “blocks” or “cells” that cover all of X. More formally, these “cells” are both collectively exhaustive and mutually exclusive with respect to the set being partitioned.
  • NOTES:

    All submitted bids are first arranged by their respective tasks.

    For each task, bids are added to the tree in a sequential order.

    Only those bids are added whose set of Robots form a disjoint set from the remaining bids already assigned on the current path. So this results in each path containing a disjoint set of bids.

    As bids are added, the total accumulated bid value is stored in each leaf node.

    An additional dummy bid of bid-value zero is added after each iteration, so that the space of possible sets of coalitions are well represented. This dummy bid is not added for the last iteration.

    Once the tree has been constructed, the path with the highest accumulated bid value is the winning partition of robots that are allocated to their respective tasks. This is done using depth-first search.

    In this example, robot coalition {R3} is assigned to “Task1” and coalition {R1,R2} is assigned to “Task2”. No robots could be allocated for “Task3” for the current round and so this task is saved for the next round.
  • NOTES:

    Due to the very nature of Anytime algorithms, this solution will always return an answer, even if execution is terminated prior to completion time.

    So, given enough time, this algorithm will generate the optimal solution.

    The algorithm also guarantees that each path is a disjoint set of bids, also known as a Partition.

    All possible partitions of robots are considered instead of restricting the size of a coalition for the sake of improving efficiency.

    Run time complexity of the algorithm depends on the size of the search space and therefore depends on the number of bids submitted and the number of tasks being considered.

    Definitions:

    Partition of a Set – In mathematics, a partition of a set X is a division of X into non-overlapping “parts” or “blocks” or “cells” that cover all of X. More formally, these “cells” are both collectively exhaustive and mutually exclusive with respect to the set being partitioned.
  • NOTES:

    Due to the very nature of Anytime algorithms, this solution will always return an answer, even if execution is terminated prior to completion time.

    So, given enough time, this algorithm will generate the optimal solution.

    The algorithm also guarantees that each path is a disjoint set of bids, also known as a Partition.

    All possible partitions of robots are considered instead of restricting the size of a coalition for the sake of improving efficiency.

    Run time complexity of the algorithm depends on the size of the search space and therefore depends on the number of bids submitted and the number of tasks being considered.

    Definitions:

    Partition of a Set – In mathematics, a partition of a set X is a division of X into non-overlapping “parts” or “blocks” or “cells” that cover all of X. More formally, these “cells” are both collectively exhaustive and mutually exclusive with respect to the set being partitioned.
  • NOTES:

    Each distribution aims at measuring the execution time of the algorithm against the number of bids submitted.

    Bids were not generated by ASyMTRe-D and so a input generator was used.

    We designed these 2 distributions so that we could test the robustness of the algorithm and measure the sparseness of the trees created, by observing their execution time for increasing number of bids.
  • NOTES:

    Each distribution aims at measuring the execution time of the algorithm against the number of bids submitted.

    Bids were not generated by ASyMTRe-D and so a input generator was used.

    We designed these 2 distributions so that we could test the robustness of the algorithm and measure the sparseness of the trees created, by observing their execution time for increasing number of bids.
  • NOTES:

    Each distribution aims at measuring the execution time of the algorithm against the number of bids submitted.

    Bids were not generated by ASyMTRe-D and so a input generator was used.

    We designed these 2 distributions so that we could test the robustness of the algorithm and measure the sparseness of the trees created, by observing their execution time for increasing number of bids.
  • NOTES:

    Random Distributions are supposed to create sparser trees because the coalition size should limit the number of successive bids that can be added in a tree. If a bid with a coalition has 9 robots, then there is 1 out of 10 chances that a bid submitted by only 1 robot not repeated on the current path will be added. Therefore, this should result in sparser trees and lesser execution time.

    The maximum execution time recorded for Random Distribution is 1.23 seconds.

  • NOTES:

    Random Distributions are supposed to create sparser trees because the coalition size should limit the number of successive bids that can be added in a tree. If a bid with a coalition has 9 robots, then there is 1 out of 10 chances that a bid submitted by only 1 robot not repeated on the current path will be added. Therefore, this should result in sparser trees and lesser execution time.

    The maximum execution time recorded for Random Distribution is 1.23 seconds.

  • NOTES:

    Random Distributions are supposed to create sparser trees because the coalition size should limit the number of successive bids that can be added in a tree. If a bid with a coalition has 9 robots, then there is 1 out of 10 chances that a bid submitted by only 1 robot not repeated on the current path will be added. Therefore, this should result in sparser trees and lesser execution time.

    The maximum execution time recorded for Random Distribution is 1.23 seconds.

  • NOTES:

    Random Distributions are supposed to create sparser trees because the coalition size should limit the number of successive bids that can be added in a tree. If a bid with a coalition has 9 robots, then there is 1 out of 10 chances that a bid submitted by only 1 robot not repeated on the current path will be added. Therefore, this should result in sparser trees and lesser execution time.

    The maximum execution time recorded for Random Distribution is 1.23 seconds.

  • NOTES:

    Random Distributions are supposed to create sparser trees because the coalition size should limit the number of successive bids that can be added in a tree. If a bid with a coalition has 9 robots, then there is 1 out of 10 chances that a bid submitted by only 1 robot not repeated on the current path will be added. Therefore, this should result in sparser trees and lesser execution time.

    The maximum execution time recorded for Random Distribution is 1.23 seconds.

  • NOTES:

    Random Distributions are supposed to create sparser trees because the coalition size should limit the number of successive bids that can be added in a tree. If a bid with a coalition has 9 robots, then there is 1 out of 10 chances that a bid submitted by only 1 robot not repeated on the current path will be added. Therefore, this should result in sparser trees and lesser execution time.

    The maximum execution time recorded for Random Distribution is 1.23 seconds.

  • NOTES:

    Since execution time is directly correlated with the density of the tree, the execution time can be substantially minimized by generating only the relevant parts of the tree that involves the winning partition of robots.

    Iterative Deepening A* is one such algorithm that has been considered for this approach where a heuristic analysis will hint on generating only the relevant partitions in the tree.

    This will encourage generating only portions of the tree, thereby reducing execution time.

    Other work also includes optimizing the current version of the algorithm by conducting a more granular analysis of the algorithm and fix areas that can impede execution time.

    In the end, we wish to test this in a real-world application using ASyMTRe-D and a group of robots so that tasks can be assigned concurrently to the coalitions of robots.
  • NOTES:

    The approach using the STA aims at a more concurrent level of operation, as opposed to the instantaneous approach followed by ASyMTRe-D

    This algorithm aims at being the task scheduler for ASyMTRe-D, where the objective is to maximize the use of resources and minimize the total execution time.

    STA will therefore operate at the higher level while ASyMTRe-D will be operating on the lower level.

    So when a batch of tasks are presented to STA, it will first call ASyMTRe-D to generate all the possible coalitions using its resource pool of robots. Once the coalitions are generated with an accompanying bid-value signifying their interest in accomplishing a particular task, STA determines the winning partition of robots that are suitable for the current round. All pending tasks and idle robots are then carried over to the next round.

    The best feature about STA is that it is an Anytime algorithm and hence will always return a sub-optimal solution even if it is terminated prior to completion.
  • Thesis Presentation

    1. 1. Spondon Saha Fall 2010 Masters Thesis Presentation Department of Computer Science Cal Poly Pomona.
    2. 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. 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. 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. 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. 6. R1 R4 R3 R2R5 Multi-robot Task Idle Robots 6
    7. 7.  ASyMTRe-D takes into account:  Task-Specific cost.  Robot-inherent cost.  Determines a suitable mapping between  Tasks.  Robots. 7
    8. 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. 9.  Proposed approach 9
    10. 10.  Sequential Auctions.  Parallel Auctions.  Combinatorial Auctions. 10
    11. 11. Item 1 Item 4Item 3Item 2 Item 5 Auctioneer [1,2] [1,3,5] [3,5] [1, 4] ??? ??? ,[2,5] 11
    12. 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. 13.  Solution:  An Anytime tree algorithm.  Explores only the relevant solution space of submitted bids.  Polynomial in the number of bids submitted. 13
    14. 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. 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. 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. 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. 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. 19.      Task B Task C …… Task N STA Algorithm Task D Task E Task F                    Task A 19 ASyMTRe-D equipped…
    20. 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. 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. 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. 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. 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. 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. 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. 27
    28. 28. 28 Task # of Bids T1 2 T2 4
    29. 29. Random Distribution (80 Tasks) 29
    30. 30. Uniform Distribution (80 Tasks) 30
    31. 31. Bounded Distribution (80 Tasks) 31
    32. 32. Random Distribution (80 Tasks) 32
    33. 33. Uniform Distribution (80 Tasks) 33
    34. 34. Bounded Distribution (80 Tasks) 34
    35. 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. 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. 37

    ×