Decentralized Multi-agent Plan Repair in Dynamic Environments

02/13/2012 ∙ by Antonín Komenda, et al. ∙ 0

Achieving joint objectives by teams of cooperative planning agents requires significant coordination and communication efforts. For a single-agent system facing a plan failure in a dynamic environment, arguably, attempts to repair the failed plan in general do not straightforwardly bring any benefit in terms of time complexity. However, in multi-agent settings the communication complexity might be of a much higher importance, possibly a high communication overhead might be even prohibitive in certain domains. We hypothesize that in decentralized systems, where coordination is enforced to achieve joint objectives, attempts to repair failed multi-agent plans should lead to lower communication overhead than replanning from scratch. The contribution of the presented paper is threefold. Firstly, we formally introduce the multi-agent plan repair problem and formally present the core hypothesis underlying our work. Secondly, we propose three algorithms for multi-agent plan repair reducing the problem to specialized instances of the multi-agent planning problem. Finally, we present results of experimental validation confirming the core hypothesis of the paper.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Motivation

Classical planning and multi-agent planning based on classical planning are approaches to constructing autonomous agents and teams of agents, which attempt to achieve their objectives in an environment. The result of the planning process is traditionally a plan, a sequence of actions the agent should perform in order to achieve a given goal. When the agent is situated in a dynamic environment, occurrence of various unexpected events the environment generates might lead to the plan invalidation, a failure. A straightforward solution to this problem is to invoke a planning algorithm and compute a new plan from the state the agent found itself in after the failure to a state conforming with its original objective.

Planning, as well as replanning, in the case of a failure occurrence, is a costly procedure, especially in terms of its time complexity. It is relatively straightforward to see, that in many cases, however, a relatively minor fix to the original plan would resolve the failure possibly at a lower cost. Because it is not clear what exactly are the planning domains and types of dynamic environments which would allow for such a repair approach, it can be argued that non-informed plan repair attempts can in many cases even raise the overall complexity of the approach in comparison to replanning. This would be due to futile attempts to repair the failed plan before inevitably falling back to replanning.

In general, plan repair can be seen as planning with re-use of fragments of the old plan. There is a number of works, empirically demonstrating that plan repair in various domains performs better than replanning (e.g., [8, 2, 5]). However, in [10], Nebel and Koehler theoretically analyzed plan re-use (plan repair), and conclude that in general it does not bring any benefit over replanning in terms of computational time complexity.

In situated multi-agent systems, however, the time complexity is often not of the primary importance. In such systems, often it is the communication complexity which is a higher priority concern. Consider application domains, such as e.g., undersea operations by teams of coordinated autonomous underwater vehicles. While the state-of-the-art technology allows to employ relatively powerful computers on board of such robots, the communication links are extremely constrained and expensive; wireless networks cannot be deployed and communication is performed mostly using acoustic signaling. In such applications, it is the communication complexity of the distributed planning algorithms which matters more than time complexity. Consequently, employment of multi-agent plain repair techniques can provide a tangible benefit over replanning for a team of robots whose multi-agent plan fails.

The motivation for our research is the intuition that multi-agent plan repair, even though not always the fastest approach, should under specific conditions generate lower communication overheads in comparison to replanning. The conditions correspond to the level of required coordination and the types of failures the environment generates. While the hypothesis is rather intuitive, our approach is significant in that we give it a rigorous treatment. Besides our preliminary approach in [7], this aspect of multi-agent planning and plan repair, while obviously important with arrival of truly distributed algorithms for multi-agent planning, such as the one by Nissim et al. [11] did not witness considerable attention of the community yet.

The contribution of the the presented paper is threefold. Firstly, after introducing the general problem of multi-agent planning stemming from the formulation due to Brafman and Domshlak [3] in Section 2, in subsequent Section 3 we formally introduce the multi-agent plan repair problem and formally state the core hypothesis of the presented research. Secondly, still in Section 3, we propose three algorithms for multi-agent plan repair reducing the problem to specialized instances of the multi-agent planning problem. Finally, in Section 4 we present experimental validation confirming the core hypothesis of the paper. Section 5 concludes the paper by some final remarks regarding the shortcomings of our approach and future outlooks in the here described line of research.

2 Multi-agent planning

Classical, single-agent planning problem is characterized by a set of states with a unique initial state, a final state (a set of final states) and a set of actions representing the transitions between these states that the system undertakes upon performing the actions. We define multi-agent planning problem as an extension of the classical single-agent planning. We consider a number of cooperative and coordinated actors featuring possibly distinct sets of capabilities (actions), which concurrently plan and subsequently execute their local plans so that they achieve a joint goal.

An instance of a multi-agent planning problem is defined by: i) an environment characterized by a state space, ii) a finite set of agents, each characterized by a set of primitive actions (or capabilities) it can execute in the environment, iii) an initial state the agents start their activities in and iv) a characterization of the desired goal states. Before treating the problem of multi-agent planning and summarizing a state-of-the-art algorithm for solving it, we first formally introduce the underlying concepts.

2.1 Preliminaries

Consider a set of atoms . A state is a set of terms from a language where denotes a negation of . We also assume the standard tautology for every . Furthermore, we require all states to be consistent, i.e., for a state we have that if and only if . Note, in general, the states do not have to be complete, i.e., it might be that there is a , such that . denotes the set of all states and we assume there is a distinguished state denoting an undefined state in which the overall system can be in. To simplify the notation, we also extend the negation to states as follows . The set of atoms corresponding to a set of terms is denoted .

A primitive action, or simply an action, is a tuple , where is a unique action label and respectively denote the sets of preconditions and effects of . The preconditions and effects are assumed to be consistent sets of terms. Whenever the context is clear, we simply write instead of . denotes the set of all actions and we furthermore assume there is a distinguished empty action with no preconditions and no effects.

We say that an action is applicable in a state iff . An application of is defined by the state transformation operator defined as follows:

Note that given a consistent state and an action , the application of to results in either the undefined state , or, in the case was applicable in , a consistent state again. The application of to first enriches with all the effects of , however, in the case there exists some , s.t., , the simple unification would make the resulting state inconsistent. The subsequent set subtraction of terms which were the source of such inconsistencies makes the resulting state consistent again, while at the same time preserving the effects of . Furthermore, is associative, hence we can write .

An agent is characterized precisely by its capabilities, a finite repertoire of actions it can preform in the environment. From now on, we assume that there exists a language giving rise to a state space .

2.2 The Problem of Multi-agent Planning

Definition 1 (multi-agent planning).

A multi-agent planning problem is a tuple , where is a set of agents , featuring mutually disjoint sets of actions, an initial state and a set of goal states .

Before formally defining the notion of a solution to a multi-agent planning problem, we first introduce a sequel of auxiliary notions.

Given an agent , a single-agent plan is a sequence of actions , s.t., for every . denotes the -th action in , or in the case is larger than the length of , which in turn will be denoted .

A team of agents can act in the environment concurrently. A joint action of the team is specified by a tuple of actions corresponding to the individual agents, i.e., for each , its preconditions and its effects . denotes the -th action of . Similarly to actions of individual agents, and are assumed to be consistent sets of terms. The notion of action applicability in a state , as well as application of to straightforwardly extend from the definitions for primitive actions.

Definition 2 (multi-agent plan).

Let be a multi-agent planning problem with . A synchronous multi-agent plan , consisting of single agent plans respectively constructed from actions of the agents is a solution to if the plan satisfies the following:

  1. is well-formed, i.e., for all . , for some , denotes the length of the multi-agent plan ;

  2. is feasible, i.e., there exists a sequel of states , s.t.  and with for all ; and finally

  3. reaches the goal , i.e., there exists , s.t. .

We also say that solves the problem . Finally, denotes the set of plans which are solutions to a given multi-agent planning problem .

Additionally, denotes the joint action of the team in the step and denotes the primitive action of the agent in the step . This notation allows us to introduce the following plan-matrix notation for a multi-agent plan , which provides a more visual understanding of multi-agent plans:

where . Indices () and () denote the step of the plan and the agent which performs the primitive action, respectively.

We say that two multi-agent plans , are equal () iff they have the same length () and for all and we have .

A concatenation of two multi-agent plans and over the same agents is defined as a plan , where for each and we have if and for . In the plan-matrix notation, the concatenation would correspond to simple columns-appending operation. Note, concatenation of multi-agent plans is an associative operation.

Given a multi-agent plan , denotes a fragment of from the step to the step . More precisely, is a fragment of iff there exist multi-agent plans and , such that . Finally, denotes the -th suffix of the plan , i.e., . is said to be a decomposition of a multi-agent plan iff .

Given two multi-agent plans and we can define how different they are. denotes the difference between and , that is the overall number of primitive actions in , which do not correlate with the corresponding primitive actions in and vice versa. Formally, . In the case , , where

is a plan padding of

to the overall length and filled with empty actions, i.e, for each , we have . Note that the measure is position agnostic, i.e., we define in the case .

2.3 Planning Algorithm

The above formulation of the multi-agent planning problem is well in line with the original formulation of MA-Strips planning due to Brafman and Domshlak [3]. The authors there additionally distinguish between the public and private actions of the individual agents. An action is public whenever its preconditions or effects involve atoms occurring in preconditions or effects of an action belonging to another agent of the team. Formally, given a multi-agent team , the set of public actions is defined as . Recall, denotes the set of non-negated atoms occurring in . , where is the set of all actions the team can perform.

The distinction of actions to private and public turns out to be an important one. Since private actions do not depend, nor are dependencies of other actions performable by the team, planning of sequences of private actions can be implemented strictly locally by the agent the actions belongs to. In effect, the public actions become points of coordination among the multi-agent team members and a truly decentralized multi-agent planning algorithm for a planning problem can be implemented in two interleaving stages until a suitable multi-agent plan is found: i) a plan consisting exclusively of public actions of the agent team is calculated, and subsequently ii) the sequences of private actions between the public actions of each individual agent are computed to fill in the gaps.

The main contribution of the Brafman and Domshlak’s paper lies in pointing out that the algorithms can be implemented by reduction of the first stage of the planning process to a constraint satisfaction problem (CSP) corresponding to the multi-agent planning problem with public actions only. The second stage can be subsequently solved by any classical single-agent planning algorithm. In result, solving a given multi-agent planning problem can be loosely formulated as a CSP with the following two types of constraints:

coordination constraint:

a sequence of joint actions (candidate multi-agent plan) satisfies the coordination constraint iff for every action performed by the agent in the step we have, that if is a public action, then

  • for every , there must exist , such that and (there is some previous action which causes to hold), and

  • for no , s.t.,  there exists , such that ( won’t be invalidated between causing it in the step and execution of in the step ).

internal planning constraint:

a sequence of joint actions satisfies the internal planning constraint iff for every agent, the corresponding single-agent planning problem with landmarks is solvable. I.e., a single-agent planning algorithm is able to fill in the gaps between the public actions in the candidate multi-agent plan.

0:  A multi-agent planning problem .
0:  A multi-agent plan solving , if such exists.
  
  loop
     Construct
     if solve-csp(then
        Reconstruct a plan from a solution for .
        return  
     else
        
     end if
  end loop
Algorithm 1 MA-Plan():

Algorithm 1 lists the original multi-agent planning algorithm MA-Plan by Brafman and Domshlak in [3]. The algorithm iterates through CSP formulations of the planning problem according to , informally the number of coordination points between the agents in the multi-agent team. I.e., determines the number of joint actions in a candidate multi-agent plan consisting of only public actions. Filling the gaps between the individual single-agent public actions, if possible, then gives rise to the overall multi-agent plan. In the case such a plan completion does not exist, the process continues by testing longer candidate plans.

The original multi-agent planning algorithm assumes a centralized planning architecture. I.e., it is a centralized planning algorithm computing multi-agent plans for a team of agents which are supposed to be subsequently executed in a decentralized fashion. Our motivation is however a decentralized planning/plan repair algorithm followed by a decentralized plan execution.

Nissim et al. in [11] adapted the original blueprint algorithm described above to a distributed setting. The adaptation rests on formulating the multi-agent planning problem as a distributed constraint satisfaction problem instance (DisCSP) and subsequently utilizing a a state-of-the-art DisCSP solver for solving it, plus managing the overhead involved in the resulting distributed algorithm. The resulting algorithm, however, closely follows the scheme of the original algorithm as listed in Algorithm 1. From now on, whenever we speak about the implementation of the multi-agent planning algorithm, we have in mind its decentralized version due to Nissim et al. [11].

3 Multi-agent plan repair

Consider a multi-agent planning problem and a plan solving . Furthermore, consider an environment in which, apart from the actions performed by the agents of the team , no other exogenous events occur. We say that such an environment is ideal, or non-dynamic. The execution of in such an environment is uniquely determined by the set of states , such that (cf. also Definition 2).

In dynamic environments, however, it can occur that in the course of execution of , the environment interferes and the execution of some action from the plan does not result in precisely the state as defined above. We could say that at step an unexpected event occurred in the environment. For simplicity, we consider only unexpected events happening exclusively in the course of execution of some action (as if it took a non-zero time), not such which could occur while the agent is deliberating the execution (i.e., as if the deliberation was instantaneous).

Note that not all unexpected events in a dynamic environment necessarily lead to problems with execution of the plan . However, there are at least two cases of such events, which can be considered a plan execution failure.

A weak failure of execution of the plan at step w.r.t. the multi-agent planning problem is such, when the state resulting from an attempt to perform an action for some does not satisfy some of the postconditions of , i.e., .

A strong failure of execution of the plan at step w.r.t. the planning problem occurs whenever the -th action of cannot be executed due to its inapplicability. I.e., the execution of the plan up to the step resulted in states , possibly with some weak failures occurring in the course of execution of the plan fragment and is not applicable in .

The weak and the strong plan execution failures are, however, just two examples of a plan failure. There certainly are application domains in which weak failures can be tolerated as far as the goal state is reached after execution of the multi-agent plan. Alternatively, there might be domains in which other types of plan execution failures can occur, e.g., any change of the state not caused by the involved agents can be considered a failure as well. To account for the range of various types failures, from now on, we only require that a plan execution monitoring process determines some plan execution failure at a step which results in some failed state .

Definition 3 (multi-agent plan repair).

Let be a multi-agent planning problem. A multi-agent plan repair problem is a tuple , where is a multi-agent plan solving the planning problem , is the step of in which its execution failed and is the corresponding failed state.

A solution to the plan repair problem is a multi-agent plan , such that is a solution to the planning problem . We say that repairs in . In the case , we say that the plan is irreparable given the failure occurring at the state .

Given two multi-agent plans and both repairing a multi-agent plan for a problem in a state , we say that is preserving more than iff and denote the relation by . The minimal repair of the multi-agent plan is such a plan , which is minimal w.r.t. the mutual differences between the plans solving . I.e., .

Note, there might be several distinct minimal repairs of a given multi-agent plan.

In general, the multi-agent plan repair problem can be reduced to solving a modified multi-agent planning problem and thus gives rise to a straightforward plan repair algorithm based on replanning in two steps: 1) construct the multi-agent replanning problem as prescribed in Definition 3, and subsequently 2) utilize the MA-Plan algorithm (Algorithm 1 ) to solve the problem .

The original motivation underlying this paper was the hypothesis that attempts to repair failed multi-agent plans lead to lower communication overhead than replanning. Clearly, not all planning problems could benefit from such a mechanism. Since we focus on multi-agent planning problems, which in a sense enforce coordination among the members of a multi-agent team, we firstly introduce the concept of -coordinated multi-agent planning problems.

Definition 4 (-coordination).

We say that a multi-agent plan is -coordinated iff each fragment of length contains at least one joint action containing a public action. Formally, for every , s.t.  with , there exist and so that .

We say that a multi-agent problem is -coordinated iff all the plans solving , which cannot be compressed are -coordinated. A plan can be compressed iff it contains a fragment , s.t.  and .

We informally say that multi-agent planning problems leading to plans containing coordination points (public actions) placed relatively frequently throughout the plans are tightly coordinated. More formally, a multi-agent planning problem is tightly coordinated if it is -coordinated and is relatively low in comparison to the lengths of plans from . In the case is relatively high w.r.t. the plan lengths, we say that the problem is loosely coordinated and finally, if the plans do not involve public actions, i.e., coordination is not needed at all, we say the problem is uncoordinated.

The core hypothesis of the paper can be then formulated as follows:

Hypothesis 1.

Multi-agent plan repair approaches producing more preserving repairs than replanning tend to generate lower communication overhead for tightly coordinated multi-agent problems.

A crisper, though perhaps a more challenging version of the hypothesis would express the communication overhead in terms of the average communication complexity:

Hypothesis 2.

When applied to tightly coordinated planning problems, multi-agent plan repair algorithms producing more preserving repairs than replanning feature a lower average communication complexity than replanning.

In the remainder of this paper, we approach resolution of Hypothesis 1. Treatment of Hypothesis 2 is beyond the scope of this paper and is left for future work.

3.1 Back-on-track Repair

Unexpected event occurring in an environment can cause a failure in execution of a plan performed by some multi-agent team in that environment. The result is that the overall state of the system is not the one expected by the undisturbed plan execution at the particular time step. A straightforward idea to fix the problem is to utilize a multi-agent planner to produce a plan from the failed state to the originally expected state and subsequently follow the rest of the original multi-agent plan from the step in which the failure occurred. The following multi-agent plan repair approach, coined back-on-track (BoT) repair, is inspired by this idea, in fact a slight generalization of it.

Definition 5 (back-on-track repair).

Let be a multi-agent plan repair problem and being the corresponding modified multi-agent replanning problem.

We say that a plan is a back-on-track repair of iff there is a decomposition of , such that for some .

is said to be a proper back-on-track repair iff . I.e., preserves some non-empty suffix of .

Informally, the back-on-track approach tries to preserve a suffix of the original plan and prefix it with a newly computed plan starting in and leading to some state along the execution of in the ideal environment. Note, that all plans from are back-on-track repairs of the original plan. The length of the preserved suffix of the original plan provides a handle on the repair quality ordering of the plans. The longer the preserved suffix, the more preserving the plan is. On the other hand, even when the plan repair problem is indeed solvable, there might not be any valid proper back-on-track repair of the original planning problem.

Algorithm 2 realizes a multi-agent plan repair procedure according to the back-on-track plan repair principle. Since the MA-Plan algorithm searches for the shortest plan from the initial state to a goal state, the Back-on-Track-Repair computes plans which return back to the original one in the shortest possible way.

0:  A multi-agent plan repair problem , with and a sequence of states execution of generates in the ideal environment.
0:  A multi-agent plan solving if a solution exists.
  Construct
  if  returns a solution  then
     Retrieve the state of to which returns
     return  
  end if
Algorithm 2 Back-on-Track-Repair()

3.2 Simple Lazy Repair

The back-on-track multi-agent plan repair approach seeks to compute a new prefix to some suffix of the original plan and repair the failure by their concatenation. An alternative approach, coined lazy, attempts to preserve the remainder of the original multi-agent plan and close the gap between the state resulting from the failed plan execution and a goal state of the original planning problem.

Let be the state resulting from a failure in execution of a multi-agent plan in a step . We say that a sequence of joint actions is an executable remainder of from the step and the state iff there exists a sequence of states , such that , and for every step and every agent , we have that in the case is applicable in the state and otherwise.

The following definition provides a formal definition of the lazy approach.

Definition 6 (simple lazy repair).

Let be a multi-agent plan repair problem and being the corresponding modified multi-agent replanning problem.

We say that a plan is a lazy repair of iff there is a decomposition of , such that , where is the executable remainder of from the step , execution of which results in the state when starting in , and is a solution to the multi-agent planning problem .

Algorithm 3 realizes multi-agent plan repair based on the lazy repair approach described above.

0:  A multi-agent plan repair problem , with and .
0:  A multi-agent plan solving the problem according to the lazy approach, if a solution exists.
  Construct , the executable remainder of from the step and state
  Construct
  let be a solution to if such exists.
  return  
Algorithm 3 Lazy-Repair()

The back-on-track approach always succeeds to compute some multi-agent plan repairing the original plan from the failed state in the case the replanning form scratch would compute such a plan from that state as well. The lazy approach is in this sense incomplete, as it might happen that the execution of the executable remainder of the original plan diverges to a state from which no plan to some goal state exists. Given that dynamic environment in general could generate irreparable failures, this incompleteness cannot be considered a shortcoming of the lazy approach in general. Of course in domains in which no irreparable unexpected event might occur, while at the same time the agents are allowed to perform actions potentially having irreversible and potentially harmful effects, the lazy approach has to be employed with caution.

3.3 Repeated Lazy Repair

In dynamic environment plan failures occur repeatedly, i.e., even after a repair of a failed plan, it is possible for the repaired plan to fail again. In this situation both the back-on-track, as well as the lazy multi-agent plan repair algorithms lead to prolonging the really executed plan. In the case of the back-on-track approach, this is inevitable, since upon the repair, the subsequent plan execution process immediately processes the newly added plan fragment. In the case of the lazy repair, however, upon occurrence of another failure during execution of the repaired plan, it is not always necessary to prolong the overall multi-agent plan.

The intuition behind the repeated lazy plan repair approach is that a failure during execution of an already repaired plan makes the previous repair attempt irrelevant and its result can be discarded, unless the failure occurred already in the plan fragment appended by the previous repair. The following definition formally introduces the extension of the lazy multi-agent plan repair approach. For clarity, from now on, we refer to the lazy multi-agent plan repair approach introduced in Definition 6 as simple lazy repair.

Definition 7 (Repeated lazy repair).

Let be a multi-agent planning problem with a solution and be a multi-agent plan repair problem with a lazy repair solution and be a multi-agent plan repair problem the system is currently facing.

We say that is a repeated lazy repair of iff

  1. is a simple lazy repair solution to in the case ; and

  2. is a simple lazy repair solution to otherwise.

The repeated lazy repair leads to a straightforward extension of the lazy plan repair algorithm listed in Algorithm 3. Note, that the repeated lazy repair algorithms enables a plan execution model which preserves significantly longer fragments of the original plan. That is, upon a failure, instead of trying to repair the failed plan right away, as both the back-on-track and simple lazy plan repair algorithms do, the system can simply proceed with execution of the remainder of the original plan and only after its complete execution the lazy plan repair is triggered. The approach simply ignores the plan failures during execution and postpones the repair the very end of the process, hence the “lazy” label for the two algorithms.

0:  A multi-agent planning problem , a multi-agent plan solving , and two multi-agent plan repair problems with a solution and .
0:  A multi-agent plan solving if a solution exists.
  if  then
     Construct
  else
     
  end if
  return  a solution to Lazy-Repair() if such exists
Algorithm 4 Repeated-Lazy-Repair()

4 Experimental validation

To verify the Hypothesis 1, we conducted a series of experiments with implementations of the multi-agent plan repair algorithms described in Section 3. Below, we firstly describe the experimental setup used for the experiments and subsequently interpret the data collected and revisit Hypothesis 1.

4.1 Experimental Setup

The experiments were based on a two-stage algorithm. In the first phase, for a given domain a multi-agent plan was computed using the MA-Plan algorithm based on a distributed constraint satisfaction solver for computing the candidate coordination plans and implementation of a best-first-search action planning algorithm as part of FF [6] for computing the local, single-agent plans. We used the implementation of the distributed multi-agent planner authored by Nissim et al. also used for the experiments conducted in their paper [11]

. In the second phase, we executed the multi-agent plan. In the course of the plan execution, we simulated the environment dynamics by producing various plan failures according to a variable failure probability. The plan execution was monitored and upon a failure detection a plan repair algorithm was invoked. Algorithm 

5 lists the pseudo-code of the process.

Before execution of each plan step, the joint action is checked for applicability in the current state. In the case it is not applicable, a plan repair algorithm is invoked and the execution continues on the repaired plan. Otherwise, the state is updated with the joint action.

The execute-fail function in the algorithm either updates the current state by the joint action provided as a parameter as if in the ideal environment, or to generate an unexpected event occurring in the simulated dynamic environment.

We distinguish two types of plan failures: action failures and state perturbations

. Both failure types are parametrized by a uniformly distributed probability

, which determines whether a simulation step fails, or not. Both failure types are weak failures. That is, they are not handled immediately, but can preclude the plan execution and later result in a strong failure. Upon detection, a strong failure is handled by one of the plan repairing algorithms.

0:  An initial multi-agent planning problem .
  
  ;
  repeat
     if  then
        
        
     end if
     
     
  until 
Algorithm 5 Plan execution and monitoring algorithm.

An action failure is simulated by not-executing some of the individual agent actions from the actual plan step. The individual action is chosen according to a uniformly distributed probability. The individual action is removed from the joint action and the current state is updated by the modified joint action.

The other simulated failure type, state perturbation, is parametrized by a positive non-zero integer , which determines the number of state terms, which are removed from the current state, as well as the number of terms which are added to it. The terms to be added or removed are selected also randomly from the domain language according to a uniform distribution.

The experimental setup was implemented as a centralized simulator of the environment integrating a decentralized multi-agent domain-independent planner MA-Plan. The individual agents are initialized by a planning domain, together with a particular planning problem instance. Each agent runs in its own thread and they deliberate asynchronously. The agents send peer-to-peer messages among themselves. Message passing is mediated by the centralized simulator as well. The messages are sent in the DisCSP phase by the integrated solver, which is a part of the MA-Plan planner.

The experiments were performed on Phenom Quad Core 9950 processor at 2.6GHz with Java Virtual Machine limited to 2.5GB of RAM. The individual measurements were parametrized by the plan failure probability

and each problem instance was executed 6–10 with various value samples. The resulting data are, in the figures, presented with natural distribution. The candlestick charts depict the difference between the minimal and the maximal measurements, together with the standard deviation.

4.2 Test Problems, Algorithms and Metrics

The experiments were conducted on three planning domains. The domains originate in the standard benchmark single-agent ICP planning domains published at [1]. Similarly to [11], we chose domains, which are straightforwardly modifiable to multi-agent planning problems: logistics (3 agents), rovers (3 agents), and satellites (2–5 agents).

The logistics domain is a tightly coordinated in that it requires relatively frequent coordination among the involved agents: airplanes and trucks need to wait for each other to load or unload the transported packages. The rovers domain is loosely coordinated in that it requires coordination only at the end of plans: there is a single shared communication channel between one of the rovers and the receiving station. Finally, the satellites domain is uncoordinated in that it does not need any coordination between the satellites acquiring images individually.

To evaluate validity of Hypothesis 1, the multi-agent planning problems were tested on the experimental setup against a plan repair algorithm implementing replanning from scratch and two of the repair algorithms Back-on-Track-Repair (Algorithm 2) and Repeated-Lazy-Repair (Algorithm 4) introduced in Section 3.

Efficiency problems of the MA-Plan implementation limited the experiments to plans with maximally two landmarks (coordination points). The measurements of Back-on-Track-Repair algorithm runs were negatively influenced by sensitivity of the planner implementation to the number of terms in the goal state. Additionally, the Back-on-Track-Repair algorithm could not leverage disjunctive goal form (cf. Definition 5) and this was emulated by iterative process testing all term conjunctions in a sequence and thus resulting in multiple runs of the DisCSP solver instead of a single run with disjunctive goal.

We used three metrics to evaluate the measurements:

execution length

is the overall number of joint actions the experimental setup executed.

planning time

is the measured cumulative time consumed by the underlying MA-Plan planner used for generating initial and repairing plans; and finally

communication

is measuring the number of messages passed between the agents during the planning or plan repair process. That is messages generated by the DisCSP solver in the MA-Plan planner.

4.3 Results and Discussion

Figure 1: Experimental results for logistics domain with 3 agents and action failures.
Figure 2: Experimental results for rovers domain with 3 agents and action failures (top). Experimental results for logistics domain with 3 agents and state perturbations with (bottom).
Figure 3: Experimental results for logistics domain with 3 agents and state perturbations with .

The first batch of experiments directly targets validation of Hypothesis 1: multi-agent plan repair is expected to generate lower communication overhead in tightly coordinated domains. We used logistics as a tightly coordinated domain and dynamics of the simulated environment modeled as action failures. Figure 1 depicts the results of the experiment. The communication overhead generated by the Back-on-Track-Repair algorithm is on average only 59% (36% at best) of that generated by the replanning approach. Furthermore, the Repeated-Lazy-Repair algorithm performed even better and on average produced only 43% (11% at best) of the communication overhead generated by the replanning algorithm. In result, the experiments strongly support our hypothesis.

Additionally, the overall time spent in the planning phase (used by the MA-Plan algorithm) by the plan repair algorithms was 54% (34% at best) and 51% (12% at best) for Back-on-Track-Repair and Repeated-Lazy-Repair respectively. The execution length was lower in comparison the replanning approach as well being in average 96% (72% at best, 130% at worst) by Back-on-Track-Repair and lower being 81% (34% at best, 132% at worst) for Repeated-Lazy-Repair.

The second batch of experiments focused on boundaries of validity of the positive result presented above. In particular, we validated the condition on the coordination tightness and feasibility of failures. The auxiliary hypothesis we validated states: with decreasing coordination tightness of the domain, the communication efficiency gains of repairing techniques should decrease. For loosely coordinated domains the communication efficiency of plan repair should be on-par with that of the replanning approach.

To validate the auxiliary hypothesis we ran experiments with the rovers as a loosely coordinated domain. Figure 3 (top) presents the results supporting the hypothesis.

The third batch of experiments targeted the perturbation magnitude of the plan failures. The second auxiliary hypothesis we validated states: communication efficiency gain of plan repairing in contrast to replanning should decrease as the difference between a nominal and related failed state increases. The underlying intuition is that, in the case the dynamic environment generates only relatively small state perturbations and the failed states are “not far” from the actual state, the plan repair should perform relatively well. On the other hand, if the state essentially “teleports” the agents to completely different states, replanning tends to generate more efficient solutions than plan repair.

To answer this hypothesis, we have prepared another logistics experiment employing state perturbations as the model of the environment dynamics. Figure 3 (bottom) depicts results of the experiment for . The perturbed state for is produced by removing one term from the actual state and adding another one. As the chart shows, under random perturbations the plan repairing technique lost its improvement against replanning. For stronger perturbations with , the ratio between plan repairing and replanning remained on average the same. The trend of the absolute numbers of messages, planning time and execution length was slightly decreasing, as the probability of opportunistic effects increased.

Finally, we conducted a series of experiments with a non-coordinated sattelites domain. The results depicted in Figure 3 show the anticipated lower plan repair communication efficiency in contrast to replanning.

5 Final remarks

In the presented paper, we formally introduced the problem of multi-agent plan repair, proposed three algorithms for solving it and experimentally validated the hypothesis stating that under certain conditions, multi-agent plan repair approach tends to be more efficient in terms of the communication overhead it generates in comparison to the replanning approach. Our results well support the core hypothesis of the paper and we additionally performed a series of experiments validating its boundary conditions.

The line of research underlying this paper well correlates with recent works on classical single-agent planning sub-domains, such as partial ordered plan monitoring and repairing [9]

, conformant and contingency planning, plan re-use and plan adaptation. Environment dynamics is also handled by approaches based on Markov decision processes. The main difference to our approach is that the state perturbations utilized in our experiments have

a priori unknown probabilities. Our own recent approach to the problem of multi-agent plan repair in [7] can be seen only as a precursor to the formal and rigorous treatment of the problem in this paper. Therein, we described the first steps towards formal treatment of the problem, as well as proposed two specific incomplete algorithms for solving the problem, very distinct from the ones presented here.

There are several open challenges resulting from the presented work. Firstly, the multi-agent planning framework (MA-Strips) is not expressive enough to describe certain aspects of concurrent actions and should be extended to this end, what, we suspect, will also influence the multi-agent planning complexity analysis. In particular, there is no way to account for joint actions which have effects strictly different than the unity of the individual actions involved. Another issue is that there is no way to enforce or forbid concurrent execution of certain individual actions. Secondly, the framework is not able to describe concurrent resource consumption, which is not an issue in single-agent Strips [4] planning, but in the multi-agent extension two individual concurrently executed actions might “consume” the same precondition, even though it is undesirable in the domain. Thirdly, there is a need for more efficient implementations of multi-agent planners with more features as the gap between the state-of-the-art classical planners and multi-agent planners is enormous. Fourthly, there is a lack of standardized planning benchmarks for multi-agent planning, especially considering tightly coordinated planning problems. Such are needed to further evaluate the hypotheses presented in this paper. Finally, we leave out the work towards resolving the validity of Hypothesis 2 aiming at investigation of complexity issues of multi-agent plan repair to future work.

References

  • [1] The international planning competition, ICAPS, http://ipc.informatik.uni-freiburg.de/.
  • [2] T. C. Au and H. Munoz-Avila. On the complexity of plan adaptation by derivational analogy in a universal classical planning framework. Advances in Case-Based Reasoning, pages 13–27, 2002.
  • [3] Ronen I. Brafman and Carmel Domshlak. From one to many: Planning for loosely coupled multi-agent systems. In Proc. of ICAPS, pages 28–35, 2008.
  • [4] R. Fikes and N. Nilsson. STRIPS: A new approach to the application of theorem proving to problem solving. In

    Proc. of the 2nd International Joint Conference on Artificial Intelligence

    , pages 608–620, 1971.
  • [5] Maria Fox, Alfonso Gerevini, Derek Long, and Ivan Serina. Plan stability: Replanning versus plan repair. In Proc. of ICAPS, 2006.
  • [6] Jörg Hoffmann and Bernhard Nebel.

    The FF planning system: Fast plan generation through heuristic search.

    Journal of Artificial Intelligence Research, 14:253–302, 2001.
  • [7] Antonín Komenda and Peter Novák. Multi-agent plan repairing. In Christopher Amato, Emma Brunskill, Guy Shani, and Matthijs Spaan, editors, Proceedings of Decision Making in Partially Observable, Uncertain Worlds: Exploring Insights from Multiple Communities, DMPOUW 2011, IJCAI’11 collocated workshop, 2011.
  • [8] Roman van der Krogt and Mathijs de Weerdt. Self-interested planning agents using plan repair. In Proceedings of the ICAPS 2005 Workshop on Multiagent Planning and Scheduling, pages 36–44, 2005.
  • [9] Christian Muise, Sheila A McIlraith, and J Christopher Beck. Monitoring the execution of partial-order plans via regression. In Proc. of 22nd International Joint Conference on Artificial Intelligence, pages 1975–1982, 2011.
  • [10] B. Nebel and Koehler J. Plan reuse versus plan generation: a theoretical and empirical analysis. Artificial Intelligence, 76(1-2):427–454, July 1995.
  • [11] Raz Nissim, Ronen I. Brafman, and Carmel Domshlak. A general, fully distributed multi-agent planning algorithm. In Proc. of AAMAS, pages 1323–1330, 2010.