Proceedings of the Third International Conference on Machine Learning and Cybemetics, Shanghai, 26-29 August 2004

A COMBINED TOP-DOWN AND BOTTOM-UP APPROACH TO INTEGRATED TASK-DECOMPOSITION. AND ALLOCATION

PINAR dZmRK, ODD ERIK GUNDERSEN

Department of Computer and Information Science, Norwegian University of Science and Technology Trondheim, Norway

E-MAIL: F'inar.Ozturk@idi.ntnu.nn. Odd.Erik.Gundersen@idi.ntnu.no

Abstract: Two important isrug involved in collaborative problem

solving are the decomposition of complex tasks into smaller (primitive) snbtask and assigning these to the agents in the system. A decomposition done without b e i aware of the availability of certain agents may not be realistic and may raise a need for decomposing the task again. Task decomposition and task allocation cannot be done io a sequemtial order but should be interleaved. The dependencies among the tasks and, hence, between the agents that collaborate is extracted from the task decomposition and converted inro rules. A team space, based on a blackboard-like areqitechue manage8 dependencies through these d e s represented in the rule base Tbis paper describes an integrated task decomposition and task allocation approach For forming a team, and a team space architeehue for managing dependencies through result sharing.

Keywords:

decomposition; task allocation Collaborative problem solving; multiagent sjxtemq task

1. htrodu&on

A software agent is defined as exhibiting reactive and proactive behavior, and being social. An agent can be social in many different ways. One is when agents help each other in solving a complex problem. The multi-agent systems field investigates the process underlying collaborative problem solving (e.g., [ I ] and [2] , and designs and develops protocols involved in this process. 'ho important issues in collaborative problem solving are the decomposition of the original complex task into smaller ones and the assignment of these to suitable agents. This paper deals with this 'team formation' part of collaborative problem solving.

Majority of current task allocation mechanisms decompose the complex task into smaller (i.e., that can immediately be accomplished) ones before starting the allocation process. In our approach, a task can be accomplished in different ways. That is, there may be

0-7803-8403-2/04/$20.00 a2004 IEEE

various possible decompositions of a task. We suggest that the decomposition that is most suitable in the current situation cannot be determined in a mere top-down manner. The idea is that task decomposition cannot be done independently from the agents currently registered in the system, and therefore, decomposition should be determined in a combined top-down and bottom up manner. In this paper we present our conceptualization of team construction that employs a market-based task decomposition and allocation approach. The presented team forming model is generic in the sense that it is not tailored to any specific domain as is done with many other agent systems. The number of agents in the team and their exact functionalities are not needed to be known in advance. These are identified through negotiations,The agents in the system and their availabilities and the willingness will be determinant in decomposing a task.

Knowledge modelling and representation community provides methodologies for halysing and modelling knowledge. Several approaches make a distinction between domain knowledge, task knowledge and problem solving methods [3]. By bringing to bear the ideas from knowledge modeling community we represent ?e goals, tasks and problem solving methods in a declarative form. The advantage of explicit representation of these entities is to be able to make automatic reasoning'about the tasks and methods.

The rest of the paper is organized as follows. Section 2 introduces the relationship between a multi-agent system and the knowledge modelling approaches. Section 3 introduces our combined top-down and bottom-up approach to task decomposition and allocation. In section 4 we present a team space where the'agents share results. Section 5 explains the prototy$.+d the domain we experimented with. Finally, section 6 summarizes the work done and points to future work.

163

Proceedings of the Third International Conference on Machine Laming and Cybernetics, Shanghai, 26-29 August 2004

2. Explicit representation of goals, tasks and PSMs

Recent research in the area of howledge modeling and engineering has produced several methodologies for analyzing and modeling knowledge and information at a conceptual and implementation-independent level. This level of system description is often referred to as the knowledge level, after Newell's influential paper [3], while the level of implementation and representational constrncts is referred to as the symbol level. The most known examples of knowledge level methodologies are the Generic Task and Task structures approaches [4], the COMMET methodology [51, and commonKADS 161. Almost all of these approaches make a distinction between domain knowledge, task knowledge, and problem solving methods (PSM).

Building on the results. from these examples we conceptualized the domain knowledge, task and problem solving methods within an agent-based context. Part of the domain knowledge is 'beliefs' of an agent. The goals and the tasks are related to desires and intentions in the agent field, while PSM are part of the agent skills.

In some of the example methodologies mentioned above there is a one-to-one relation between a task and a

~ PSM method meaning that a task can be accomplished by only one PSM, while Task Structures' approach presumes a

' one-tomany. relation between a task and PSMs. For example, in order to go to the down town, I may walk, I may take a bus, or I may drive, depending on the situation - e.g., if it is very icy out I wouldn't prefer to drive. Our system allows several PSMs for a task as this is the case in rich and complex domains (e.g, in medical diagnosis there are several methods for measuring the heart rate and depending on where 'the medical investigation takes place one of the methods can be more suitable or realizable than the others. In a safari trip the best way can be just to sense the heart rate by hand as the needed equipment will not be available in the environment). .. ' .

As such, a task can be accomplished in different ways by different agents. A special type of agent has the knowledge of goals, tasks and PSMs, and the relationships among these. That is, the agent knows how a goal (and, hence a task, as there is one-to-one relation between a task and a goal) can be accomplished by employing a number of alternative PSMs.. While a task specifies what should be done, PSMs specify how to do it. Since in our system there may be alternative PSMk to apply for a task, the system is faced with the problem of choosing the most appropriate PSMs. Thus, the issue of method selection and consequently, the issue of decomposition selection becomes important. We elaborate on this in section 3. A task is characterized by a goal, inputs and outputs and the methods

,

'

that can be used to perform it (see Figure 1). The relationships between tasks and methods can be

concepmalized as a directed acyclic graph, as is shown in Figure 2. There are two types of nodes in the graph task and problem solving methods. Methods can be either task decomposing methods (the nodes labeled as M4, M5, etc., in the figure) or primitive methods (those labeled as A7, A9, as these are sometimes called also called 'actions'). The leaf nodes in the graph represent primitive methods that are immediately executable (program codes,i.e., procedural knowledge) while the methods in the upper levels put a structure on the problem solving process (i.e., they specify how a task can be decomposed into smaller subtasks) and specifies how the results coming from the lower-level PSMs will be integrated. Since the methods attached to a task are altematives they have an OR relation between them, while there is an AND relation between the subtasks connected to a method node. A link from (i.e. leaving) a task to a method represents a 'realised-by' relation (e.g., task-3 is realized by.method-6 or method-7). while its inverse, that is, a link froma method to a task means 'accomplishes-subtasks'. The whole job of the task allocation can be considered as a search in the problem solving space where the aim is to discover the best task allocation. 'Best' is the one that is both realistic (e.g., a decomposition which is possible because the necessary agents are available) and of high utility'(i.e., meets the criteria set up for chmsing the methods &d agents, such as cost and time). We refer to this process also as 'team forming' in the rest of the paper.

. Description *A set of assumptions - A set of inputs

~ Control information - A Wt Of outputs

-Aset Of wbtaslcs

- Description

- A set of inputs -A set of nutputs - A set of assumptlms . Aset of PSMslactions

Figure 1. Representation of task and problem solving methods

3. Integrated task decomposition and allocation

In our approach, team formation is specified as a run-time process happening on-need basis. There are no fixed teams that are dedicated to certain tasks in advance. The teams are formed when a task is requested, either directly from the user, or from an agent that is responsible for performing a task but needs collaboration of others.

164

. .

Proceedings of the Third International Conference on Machine Learning and Cybemetics, Shanghai, 26-29 August 2004

Given a goal, the dedicated agent delivers the part of the whole task structure that is rooted in the given goal. The task structure tree looks l i e the tree in figure 2, having alternative ways (Le; more than one PSMs for a task) of decomposing a task. Forming a team, hence, means pruning the task structure tree into a task decomposition tree (see Figure 2) where there is.only one method for each task. Here,. we are dealing. with two seemingly separate'issues: task decomposition (the choice of decomposition) and task allocation. We suggest that these two cannot he done in a sequential order (i.e., decide the decomposition first and then find agents to perform the subtasks) but should be interleaved. A task cannot be planned without consulting those who will take part in performing the job. '' .'I. .

' I .-:,i,

A:? ': (-TJW' a :m @ ptm

Figure 2. Task tree. The whole tree is a task structure tree while'the subset with gray nodes is the solution space including.the task decomposition trees that are possible in the current situation.

3.1. Why integrated? . .

A 'task decomposition that seems to be the best one when making a top-down plan may not be applicable if there doesn't exist any available agent for doing a part of the job. Decompositions done without being aware of the availability of certain agents may not be realistic and, thus, call for re-decomposition. So, the best way is to interleave top-down planning with a bottom-up process where the possible candidate agents contribute (though implicitly) to ' the . planning. This indicates a

semi-centralized planning of the task execution where a task manager is responsible for the tasks but is not the sole actor in the planning process. The 'decision of how to decompose a task is taken on the hasis of the reaction.of the agents. This doesn't guarantee, of course, that the plan will be executed without any problem at run time. An important source that can make the plan stuck is that an agent that took on some tasks dies or gives up. In this case task

.manager needs to re-plan, either just to find another problem solving agent, PSA, (i.e., re-allocate) for executing the PSM ,if the task is a primitive one, or re-decompose and re-allocate the task it cannot. get away with just replacing the PSA.

Table 1. The Traversal Algorithm. The input is the whole task structure tree and the output is a set of decomposition

trees.

for each x; E ohon to which there is an agent that offered a bid, do

for eachg E element, do ckment t ekmm-g

ekmmt c xi

ifj, E PSM (either primitive or complex) rkmtnt c task that point toy/ if Iv, E m q k x PSM) AND b is not fulfilled)

continue with next ckmmt elseif2 E tmk

.~

'(e- mot nodc in the task stmcture tree , if 7 Is ac$vated

&'iwted e- '( for each mi E artivated

&'iwted t all childeren of m, that has been activated return atiwted

ekmwt t PSM that point toy, activateg

3.2. Market-oriented task &&on

Given a task structure Fee, the leaf nodes in the tree (i.e., primitive PSMs; the' 'actions') . are announcedadvertised in order to find out *e actions that can be performed by the agents' existing in the system. Those actions for. which no agents offer a bid cannot take part in a task decomposition which .means that such decompositions needs be eliminated from the'task structure. The allocation of taskdactions is done in a market-based manner. Upon receiving a request for bids, each agent may respond for one or several of the announced actions. The task manager agent (a middleware agent) allocates takes on the basis of a set of criteria (including time and cost,'as well as aiming at involving a minimum number of agents). Once those leaf nodes of the tree, that is, the actions for

165

which there are agents offering their services are determined (and marked on the tree), an algorithm traverses the task structure tree to prune the methods that are not realisable (i.e., because of the lack of agents offering their services). The algorithm is sketched in Table 1. The input of the algorithm is the task structure tree where a task may point to altemative PSM nodes (see Figure 2). The output (Le., the solution space) is a set of decomposition trees of which nodes are shown in gray color in Figure 2. One of the possible task decompositions in the solution space is then chosen.

As the last step the agents that offered a bid for the PSMs represented at the leave nodes in the resultant decomposition tree are notified and they commit to the jobs.

4. TaskSpace

After a team is formed the agents start working on the various parts of the original task. Two important issues to be addressed in collaborative problem solving is the dependency between the team members and the synthesis of the results delivered by various agents. There are dependencies between tasks - either time, resource or information related. In this paper we deal most with the information dependencies. In this respect, dependency matters, especially, at the leaf nodes of the task decomposition tree. Management of dependencies are of vital importance in collaborative problem solving environments because in many cases one problem solving agent (i.e., an agent that is assigned to the PSMs) needs the output of another agent in order to start doing its own job.

4.1. Result sharing

One way of managing dependencies are through message sending; agents knows which other 'agents are dependent of their results and send its results to those that need it. An altemative is to employ a blackboard architecture 171 that has been the most influential solution so far in similar situations. We adopt a blackboard-like mechanism for sharing the results, though with significant differences from the blackboard architectures. In our approach, the collaborative problem solving medium is a 'task space' (also called 'team space). After the tasks are assigned to the agents, the system generates a 'task space' where the task manager (also called team responsible) is the default agent. All the PSAs that have a'job assigned to them are also registered automatically in the 'task space. The task space is similar to a blackboard in the sense that agents place their iresilts into the task space in a similar way as is done with a.blackbard.

. I

The main reason for preferring a 'bsk-space' solution over just making an agent send its result to the agent(s) that needs this input is that there may be need to vast amonnt of communication in case there are many small tasks that are dependent on each other. For example agent A may need input from five different agents. All the five agents will communicate their results when they finish their jobs. A blackboard architecture, through a task manager agent can manage the dependencies in an elegant way. It collects all the results coming from the five agents and then send a message to agent A, having the results of the five agents as the content. This happens through the 'working memory' in the task space. Another important component of the team space is the rule base. The dependencies, after being converted into rules are collected in the rule base.

These are situation-action rules where the situation part conveys which information should be available in the team space while the action part specifies what needs be done when the information defined in the 'situation' part becomes available. A rules in the rule base looks like the following:

IF info-1 and info-5 and info-17 THEN inform agent-36

The action part refers to the agent(s) that should be made aware of the information. When all the information on the 'situation' part of a rule are put into the working memory, the rule can be fired.

The action part involves an ACL (i.e., agent communication language) message to be sent to the 'waitingldependent' agent. The content of the message is the information that comprises the needed input for the task the agent would start performing. This is an alternative way of reaching the information where the agents don't need to poll the team space all the time but being informed when it is there. This is an event-based approach to handling the 'input/output dependency' between the team members. The whole enterprise is similar to a rule-based system where the 'working memory' changes when an agent places a result into the team space. The elements of the working memory is matched against the dependency rules in the rule base of the team space and the corresponding actions aie triggered. The action is taken by the task manager and results in sending an ACL message to the PSA.

The team space is dynamically generated at run-time, and lasts until the task is accomplished.

4.2. Extraction of dependencies

Information dependencies are specified at PSM nodes in a task decomposition tree in form of inputloutput

Proceedings of the Third International Conference on Machine Learning and Cybernetics, Shanghai, 26-29 August 2004

166

Proceedings of the "bird hiternational Conference on Machine Learning and Cyhemetics, Shanghai, 26:29 August 2004

relations. After the decomposition tree is chosen, dependencies are extracted from the tree and converted into rules. The PSM nodes (including the primitive methods, the actions) include information about input, output, and control information (see Figure 1). Control information specifies the sequence of execution-steps, the information of how to accompish a task. The dependency extraction algorithm is shown in Table 2.

Table 2. The Dependency Extraction Algorithm

The output of the algorithm is the set of all dependencies. These are then converted into mles where there will be one rule for each PSM.

5. The prototype

The paper reports ongoing research where a prototype is implemented for the 'proof of concept' purpose. In the prototype system, the user interacts with a user agent and requests that a certain task is accomplished . We identified various roles that can be played by different types of agents. For example, task decomposer, task manager, and problem solver are all roles that can be played by agents of type 'task agent' . The user agent is a role that is played by agents of type 'interface agent'. The user agent has interaction with a task agent that can play a task manager role. Task manager, on the other hand, interacts with user agents, task dkomposer and problem solvers. The role analysis done is in line with Kendall's [8] approach to agent roles.

In a problem solving session, a user agent communicates the task to a task agent which will from then on be responsible for the task being accomplished. If the task agent can perform the task alone, then it does the job and delivers the results to the user agent that contacted it in the first place. Otherwise, the task agent starts an interactive process to involve other agents in solving the

problem. In this process the task agent interacts with two types of 'agents: task decomposer and PSAs. The interaction protocol that realizes the communication between task decomposer, task manager (i.e., team responsible), and problem solver agents is illustrated in Figure 3. The protocol is based on the FIPA Request and the FIPA contract net protocols.

h h I- To T m - .j

Figure 3. The interaction protocol underlying the conversation involved in task decomposition and allocation

We used a frame-based representation for explicit representation of goals, tasks and PSMs. For this purpose we used CREEK system. CREEK is a case-based reasoning system [9] which also provides a frame-based knowledge representation language, It provides also mechanisms for spreading activation in a semantic network (the task tree in the prototype). As the agent platform we use JADE, and thus, FIPA compliant ACL as the communication language.

A simple domain we used in out prototype is related to transportation, illustrated in Figure 4. As seen, the task of 'load' can be realized by two alternative methods; machine loading and manual. loading. The 'machine loading' PSM has three subtasks: 'get loading vehicle', 'get loading vehicle driver' , and 'vehicle load'. The control information of this PSM specifies in what order these subtasks should be performed. As is seen in the figure, the subset of the tree with gray nodes is chosen as the decomposing tree meaning that manual loading is not viable under current situation of agent availability.

167

Proceedup of the Third International Conference on Machine Learning and Cyherneacs, Shanghai, 26-29 August 2004

Figure 4. Task Structure for the domain of transportation

6. Summary and future work

The paper deals with the collaborative problem solving process where multiple agents are involved. A combined top-down and bottom up approach to team formation is presented. The two important issues pertinent to team formation are task decomposition and task allocation. We argue that a a sequential approach to'task decomposition and task allocation may not be suitable in many cases, and therefore propose an interleaved task

We adopt an explicit representation of tasks, domain knowledge and problem solving methods. In our approach a task ca be accomplished in more than one way'meaning that there' can be several problem solving methods associated to each tasks. As such, there'are more than one decomposition of a task. The choice 'of the.decomposition is done in interaction with the agents:c&rently registered into the system, and on the basis,of.~eir.response to the task announcements done by the task^ manager (that attempts to start a collaborative problem 8olving.process).

The relations among the tasks (hence; problem' solving methods), that is, the dependencies are described explicitly. The traversal algorithm traverses, the task decomposition tree, extracts the dependencies between the PSMsfhence PSAs) and 'converts this into rules. Task manager administers a task space where result sharing is realized on

decomposition and task allocation. . .

'

. . ' I . : . .

the basis of a rubbased system where the dependency rules comprise the rule base. The action part of the rules refers to the results provided by the problem solver agenst, and actions are the ACL messages to the other problem solving agents of which tasks are depedent of these results. We have implemented a prototype for testing the model and obtained the preliminary reports. We need to elaborate our model in various ways. For example, the task structure pruning we suggest may not always end up with a single decomposition tree. In some places of the three we may still have more than one PSMs applicable because there may be agents offering their services. In such cases, the task manager should make a decision for choosing one of the PSMs. We need to analyse the criteria for choosing between PSMs, and fmd out how to represent that knowledge.

References

E. H. Durfee, Distributed Problem Solving and Planning, in.Multiagent Systems (G. Weifl ea.), MIT Press, Cambridge,MA., 1999,pp. 121-164. Keith S . Decker. TEMS: A framework for analysis and design of coordination mechanisms. In G. OHare and N. Jennings, editors, Foundations of Distributed Artificial Intelligence. Wiley Inter-Science, 1995 The knowledge level. Artificial Intelligence, 18:87-127, 1982. Chandrasekaran, B. \8r Johnson, T. R. (1993). Generic tasks and task structures: History, critique and new directions. In J.-M. David, J.-P. Krivine, \& R. Simmons (Ed.), Second Generation Expert Systems (pp. 232-272). Berlin: Springer-Verlag. Steels, .L. (1990). 'Components of Expertise. ,AI Magazine, Il(2). Joost Breuker and Walter Van de Velde, editors. CommonKADS Library for Expertise Modeling: reusable problem solving . 'components. IOS-PresdOhmsha, Ams te rddokyo , 1994. N. Carver and V. Lesser. The -Evolution of Blackboard Control Architectures. Tech. report. UM-CS-1992-071. 1992 Kendall. Aspect-Oriented Programming for Role Models. ECOOP Worksh0ps.p. 294-295. 1999 Agnar Aamodt: Explanation-driven case-based reasoning, In S. Wess, K. Althoff,.M. Richter (eds.): Topics in Case-based reasoning. Springer Verlag, 1993

168