those planners manage to produce correct solutions for a quite large number of problems into simple and static domains, they can not cope with most of

Transcription

1 Interactive Constraint Satisfaction for Information Gathering in Planning R. Barru (1), E.Lamma (1), P.Mello (2), M.Milano (1) (1) DEIS, Universita di Bologna Viale Risorgimento 2, Bologna, Italy (2) Dipartimento di Ingegneria, Universita di Ferrara Via Saragat, Ferrara, Italy Abstract Many modern Articial Intelligence planners are based on Constraint Satisfaction (CS) techniques. The basic idea is to introduce constraints which must be satised during the plan construction in order to have a consistent solution. CS techniques allow the search space to be pruned during the planning process thanks to constraint propagation. However, classical CS approaches need all the information on variable domains at the beginning of the computation. This is not the case in a typical networked environment where the knowledge is not completely dened at the beginning, but has to be dynamically acquired during the computational process. A possible solution to this problem is to introduce in the current plan sensing actions devoted to knowledge acquisition. An alternative approach is based on the idea of allowing a CSP (Constraint Satisfaction Problem) to deal with incomplete knowledge and to interactively acquire new consistent information. In this paper, we dene an Interactive CSP framework where constraints are posted on variables ranging on partially or completely undened domains. The basic idea is to use constraints both for maintaining the consistency of the current plan, and for performing knowledge acquisition when needed. A more interesting feature of this framework concerns the possibility of driving the knowledge acquisition by means of interactive constraints in order to retrieve only consistent information for the planner. 1 Introduction Planning in complex domains has to deal with the problem of incomplete knowledge. Traditional planners are based on the unrealistic assumption of omniscience, i.e., the planner requires a complete knowledge of the initial state of the world. Thus, while 1

2 those planners manage to produce correct solutions for a quite large number of problems into simple and static domains, they can not cope with most of the real world domains where the knowledge model is typically incomplete and highly dynamic. For example, the management of networked systems [7] represents a typical environment where it is not possible to have a complete knowledge, given its complexity and the large amount of data. In this paper we propose an integrated architecture based on Constraint Satisfaction (CS) techniques that joins the problem solving ability of generative (o-line) planners, as typical Partial Order Planners, and the capability of reactive (on-line) planners to acquire information on demand. A Constraint Satisfaction Problem (CSP) is dened on a set of variables fv 1 ; v 2 ; : : : ; v n g ranging on a domain fd 1 ; d 2 ; : : : ; d n g. Variables are linked by constraints c(v 1i ; : : : ; v ki ) that dene a subset of the cartesian product of variables domains, i.e., combinations of values that can appear in a consistent solution. We extend this framework in order to treat constraints on variables ranging on partially or completely undened domains. Those constraints, called Interactive Constraints [6], may result in a knowledge acquisition process and a consequent propagation. For example, suppose we have a variable P representing a printer, and we do not know at the beginning which printers are available in the system, thus the domain of variable P is undened. If the constraint online(p ) is veried it performs a knowledge acquisition in order to identify the printers available. On the other hand, if P has an already dened domain, (already retrieved by other constraints), online(p ) behaves as a standard constraint by removing those printers which are not on line. A more interesting feature of this framework is that the knowledge acquisition can be driven by interactive constraints in order to retrieve only consistent information. For example, the constraint online(p ) can guide the knowledge acquisition process in order to retrieve only printers on line and not all the printers of the domain. This feature is useful from a computational viewpoint since it allows to work with signicantly smaller domains containing only consistent values. This general framework can be used in many applications, particularly in all the applications where a low level system provides a large amount of constrained data to be processed, as for instance a vision system used for extracting visual features of objects from an image [6]. We tailor this general solution to planning problems. Basically, in our architecture the planner is not aware of all the true facts of the real world. Thus, when the planner tries to verify if a precondition is already satised in the initial state, if the necessary information is not available, it needs to acquire knowledge from the underlying system. In practice, we consider action preconditions as interactive constraints. They behave as usual preconditions and constraints when they work on variables ranging on dened domains. Otherwise, they perform knowledge acquisition. It is worth noting that in this way the knowledge acquisition process is transparent to the planner which does not need to take into account information gathering actions. The aim of this paper is to sketch this approach, and to suggest how a planner could benet from it. The paper is organised as follows: section 2 discusses the problems related with incomplete knowledge; section 3 focuses on the Interactive Constraint Satisfaction Problem (ICSP) model after a brief description of Constraints Satisfaction techniques 2

3 and their application to planning. Section 4 proposes an example in the eld of network management. Conclusion and future work follow. 2 The problem of incomplete knowledge in planning One of the main system management activities consists in performing conguration and reconguration tasks. The traditional way to deal with this issue is by mapping high level commands with shell scripts and conventional procedural applications. This approach does not cope well with a networked computer systems always growing in complexity. A promising alternative is represented by planning techniques, a much more exible approach able to deal with unexpected situations and updates of the system. Planning, in fact, allows to dynamically synthesise the sequence of commands necessary to accomplish the current goal by using basic actions. However, traditional planners make the unrealistic Close World Assumption (CWA) [5], meaning that: (i) all the information about the world is known, (ii) anything unknown is false. This hypotesis does not allow to apply planning to dynamic environments such as a networked system domain [7]. In fact, it is really inecient if not impossible to make the agent load all the hierarchical knowledge of the real system conguration. Planners which make the Open World Assumption (OWA) work in dierent way. They are based on the hypotesis that anything not indicated into the list of the known facts is unknown. Some of them base their planning decisions on assumptions made on unknown facts [7]; these assumptions are tested at execution time by means of verication actions. In case of wrong esteem the agent needs to replan. Other planners build conditional plans [11], i.e., plans with dierent alternative branches which are selected at execution time. This can lead to a computational explosion of the planning process. Another approach shifts the complexity from the planning process to the action denition, by embedding into action descriptions all the possible alternatives in which a situation can come [8]. Althought it could seem a good compromise, we cannot abuse with this sort of action denition since, in this way, we run the risk to loose all the advantages of declarativeness and dynamic planning. In general, all these options are appropriate when a limited number of possible alternatives is given. Another alternative consists of exploiting the reactive approach to planning in charge of acquiring information in a dynamic way during the planning process by interleaving planning and execution of knowledge acquisition actions 1, usually called sensing actions [10]. Sensing actions are described as proper actions in a declarative formal language by pre and post conditions. The main drawbacks of this approach mainly concern the facts that: (i) sensing actions have to be explicitly dened in the action domain; (ii) they retrieve the whole state of the underlying system in a systematic way, leaving to the planner the task of selecting information consistent with the case under consideration; (iii) often there may be plans containing many instances of the same sensing action. This happens because the planner automatically inserts an instance of a sensing action into the plan, each time a resource 1 A networked system is observable since its operative system provides sensor commands to check the state of the system (i.e. Unix commands as ls, finger, pwd and so on). 3

4 information is required, sometimes resulting in sensor abuse. Our challenge is to provide the planner with a sensing mechanism which mostly overcomes these limits. 3 Interactive Constraints Satisfaction techniques Many modern Articial Intelligence planners are based on Constraint Satisfaction Techniques. CS techniques can be used to augment the search eciency of the planner by avoiding failures instead of recovering from them, thus reducing computationally heavy backtracking steps [5, 3, 9]. In order to exploit this feature we have to map the planning problem into a Constraint Satisfaction Problem (CSP). Many approaches to planning as CS problem have been proposed. Particularly some of them exploit CS techniques for temporal reasoning [9], resource allocation [9], conicts resolution [12, 13, 3], open condition achievement [3]. We focus on the CSP represented by the variables appearing in the pre and post condition of action schemata instances introduced into the plan. They are associated to a domain which can be reduced during the computation thanks to constraint propagation. However, classical CS approaches [4] need all the information on variable domains at the beginning of the computation. This does not t with a typical networked environment where knowledge is not completely dened at the beginning; there is need of interaction between the low level system and the data processing module, which in our case is a constraint solver. The traditional approach keeps the knowledge acquisition mechanism separated from the CSP resolution. Instead, we describe a method to dynamically acquire the information from the real world during the computational process, making the CSP system itself drive the information gathering process. Our sensing mechanism represents a promising alternative to the sensing actions denition. We associate an information gathering procedure with most of the predicates, appearing as preconditions in the basic actions denition, without need to dene further declarative actions. When these preconditions are tested, they behave as Interactive Constraints [6]; that is, they behave as pure constraints when their variable domains are already dened, otherwise information is gathered from the real world in order to dene the domains. It is worth noting that, those constraints retrieve only information consistent with the context so as to simplify the task of pruning inconsistent alternatives. The context in which this framework works is a Partial Order Planner (POP) whose kernel is similar to the UCPOP algorithm [5]. As all the POP algorithms, our planner performs least commitment on ordering decisions. It does not commit prematurely to a complete, totally ordered sequence of actions. Plans are represented as a partially ordered sequence, and only the essential ordering decisions are recorded into a set O. During the planning process the consistency of O has to be ensured. In this context the planner needs also to ensure that the dierent actions introduced for dierent goals do not interfere each other. Casual links (set L) record the dependencies between actions so as, when a threat to one of these links, (i.e., a newly introduced action which might interferes with past decisions), is detected, the planner makes some commitments in order to remove it. As the UCPOP algorithm, our planner starts by generating the NullP lan with the dummy actions Start and End. Start has no preconditions and its postconditions consist of a set, 4

5 called InitialState (IS). IS contains the knowledge of the underlying system that the planner is aware of, while in a traditional generative planner it represents all the true facts in the real world. All the knowledge in IS is organized in information clusters according to the \type" of the object to which the information is referred. For instance as far as the object type \le" is concerned, in the IS there will be facts structured as follows: file(rights; name; path; disk; dim; type; date). In our framework IS is not a static set, but grows continuously according to the new information retrieved by the planner. The End action has no eects, and its preconditions are the conjunction of the goals of the planning problem. All these conjuncts are initially put into an Agenda representing the set of subgoals the planner has to satisfy. During the planning process, as soon as a new action is introduced into the plan, its preconditions are added to Agenda. Since the planner treats preconditions as constraint, as soon as it selects one item from the Agenda it will put it into the constraint store. These constraint are called `Interactive Constraints' (IC) since on one hand they represent constraints of the plan (precisely they represent constraints between the variables of the predicate itself), on the other hand they are \interactive" because they treat also the case in which the domains of these variables are not yet completely dened into the planning problem, (i.e., the IS set does not cointain all the information on the variables of the precondition itself). In these cases such constraints run low level functions that work as access modules to the real world which will retrieve the values of the variable domain satisfying the constraint represented by the predicate under consideration. In other words those variables range on partially dened domain D i = fdef i [ Undef i g where Def i represents the set of dened values of the variable i and Undef i represents the information not yet available which can be gathered by knowledge acquisition. The implementation of an interactive constraints is uniformly associated with each predicate. Note that we make the assumption that all the predicates are expressed as binary constraints. Operationally, they work as follows: 1. If no variable is associated to a domain, suspend the constraint; 2. else, if both the variables are associated to a domain, propagate the constraint; in this case it can return: (a) the previous domains pruned from all the values not consistent with the constraint itself; if one of the domain is empty the procedure returns a failure; else suspend the constraint. (b) the same domain if all the previously existing values satisfy the constraint; 3. else, if no domain is associated to one of the variables, knowledge acquisition is performed; the procedure returns: (a) a nite set of values representing the domain associated to the variable; update IS; suspend the constraint again; (b) an empty set; in this case the procedure results in a failure; 4. else if both variables are instantiated the procedure returns a boolean value: 5

6 (a) the true value means satisfaction; (b) the false value results in a failure. These constraints are awaked, during the planning process, when some variables are instantiated or their domain pruned. The main steps of the algorithm are the following: PLAN(hA; O; Li) 1. Termination. If the Agenda is empty then perform the labeling of not yet instantiated variables and return ha; O; Li. 2. Goal selection. Choose a pair hq; A k i from the Agenda where A k belongs to the set A of actions already instantiated and Q is a precondition of A k. 3. Action selection. Choose no deterministically either Start or an action A j (either newly instantiated from the domain theory, or already in A) which can be consistently ordered prior to A k and whose eects cointain a conjunct R that unies with Q consistenly with the constraints of the problem. if the chosen action is Start then call the Interactive Constraint associated to Q (IC(Q)): if IC(Q) does not fail (i.e. Start satises Q) then Update L: L1 = L [ fstart Q! A k g, Update O: O1 = O [ fstart < A k g [ fa k < endg; else fail. else Unify Q with R Q Update L: L1 = L [ fa j! A k g, Update O: O1 = O [ fa j < A k g, if A j is a newly instantiated action then Update A: A1 = A [ fa j g 8 precondition Q i of A j : Agenda = Agenda + hq i ; A j i else if no such action exists then return failure; 4. Update the goal set. Agenda = Agenda? hq; A k i 5. Casual link protection. For each causal link c = fa i q! A j g 2 L and for each Action A t threatening c choose a consistent ordering constraint, by either demotion (A j < A t ) or promotion (A t < A i ). If neither constraint is consistent, then return failure. 6. Recursive invocation of PLAN(hA; O; Li). 6

7 4 Example in the eld of network systems We are currently implementing some of these constraints by using the nite domain libraries of ECL i P S e [1], a Constraint Logic Programming (CLP) system. CLP is an approach to programming which merges all the features and advantages of Logic Programming and Constraint Satisfaction techniques [2, 4]. CLP(FD) can be used to represent planning problems as CSPs. In order to see how our planner works, we present an example in the eld of network management. Let's suppose to have as goal the task to move the le \mydocument" in the disk \B" and let's suppose that this le is initially located in disk \A". In the domain theory there are the following two action schemata: Action MakeSpace(Disk) - Preconditions: disk(disk), le(file), type(file; \tmp"), ondisk(file; Disk), fdim(file; Dimens), dspace(disk; Fs). Postconditions: dspace(disk; Fs + Dimens), not le(file), not ondisk(file; Disk). Action MvFileToDisk(File; Disk1 ; Disk2 ) - Preconditions: disk(disk1 ), disk(disk2 ), le(file), Disk1 6= Disk2, dspace(disk1 ; Fs1 ) ondisk(file; Disk1 ), fdim(file; Dim), dspace(disk2 ; Fs2 ), Fs2 Dim. Postconditions: ondisk(file; Disk2 ); dspace(disk2 ; Fs2? Dim), not ondisk(file; Disk1 ), dspace(disk1 ; Fs1 + Dim). The former is devoted to free some space on a disk by deleting some \:tmp" les. The latter moves a le from a location to another. Our goal is G = ondisk(\mydocument"; \B"). If the planner tries to verify the goal in the initial state it nds that IS is empty, thus it needs to acquire information from the underlying system. Since both the variables are bound the low level procedure associated to the predicate ondisk(f ile; Disk) will return a boolean value, f alse in this case, which means failure. Thus, the goal can not be satised from the action Start. The planner introduces into the plan the action MvF ilet odisk(f ile; Disk1; Disk2) since one of its eect, ondisk(f ile; Disk2) unies with G, with F ile instantiated to the value \mydocument", and Disk2 to \B". The sets A, O, L and Agenda are update. In order to verify if Start satises the precondition ondisk(\mydocument"; Disk1), since the domain of Disk1 is still undened, the planner needs to acquire, from the underlying system, the values of the variable Disk1 satisfying the predicate ondisk. Here we are supposing that only disk \A" contains a le named \mydocument", thus the domain of Disk1 is represented exclusively from the value \A". Disk1 is instantiated to the value \A", and the fact file(rights; \mydocument"; path; \A"; dim; type; date) is added to IS along with the fact disk(\a"; dimens; partitions; f reespace; :::); nally the sets O and L are updated. When the planner veries f dim(\mydocument"; Dim) in the initial state, it nds the values of the domain of Dim in the item \dim" of the les whose name is \mydocument". The value returned is the actual dimension \size" of \mydocument": Start satises f dim(\mydocument"; \size"). The algorithm instantiates the variable Dim to \size" 7

8 and updates O and L. To check if Start satises dspace(\b"; F s2) the planner would need to perform knowledge acquisition; the value returned is the actual free space of the disk \B", \f reeb"; the information disk(\b"; dimens; partitions; \f reeb"; :::) is added to IS. If the value \freeb" veries the constraint F s2 \size" it means that the condition is satised in the initial state, thus F s2 is instantiated to the value \freeb", O and L are updated and the plan returned. Otherwise, the planner performs a backtracking step and goes on considering other actions (dierent from Start) in order to nd those that can satisfy the constraints dspace(\b"; F s2), consistently with the constraint F s2 \size". If the action M akespace(disk) is selected, the variable Disk is istantiated to the value \B" and, the variable F s2 is unied with F s + Dimens, then the constraint F s2 \size" becomes F s + Dimens \size". When the condition ondisk(f ile; \B") is considered, the domain of F ile is acquired by the interactive constraint associated and it cointains all the les of the disk \B". For each of them a fact file(rights; name; path; \B"; dim; type; date) is added to the IS set so as the verication of the precondition type(f ile; \tmp") will result in a propagation of the constraint on the domain of F ile. All the values but the les \:tmp" will be pruned from this domain. Furthermore, in order to verify dspace(\b"; F s) in the initial state the variable F s is instantiated to the values \f reeb". When f dim(f ile; Dimens) is selected the planner nds the information needed in IS; the domain of F ile is pruned from all the values whose dimension does not satisfy the constraint \freeb" + Dimens \size". If the domain becomes empty it means that there is need to delete more than one le in order to obtain the free space needed; thus iteratively the plan will add an instance of the actions M akespace(disk) until the constraint \f reeb"f+dimensg \size" will be satised. 5 Conclusion and future work We presented an hybrid approach to planning which integrates the problem solving ability of a generative planner and the capacity of acquiring information on demand typical of a reactive planner. We provided it with an ICSP model which allows the planner to exploit Constraint Satisfaction techniques to improve its eciency both during the computation of the plan and in the knowledge acquisition activity. Particularly, this framework makes it possible to integrate the two processes driving the planner in its decisions by means of constraints maintenance and propagation. The work in progress mostly regards the application of the planner to a computer network domain. One of our main purpose is to reduce as much as possible the interaction of the planner with the real system so as to avoid sensor abuse, by providing it with a mechanism to know when to stop sensing. A good approach is the one that use the Local Closed World (LCW) [7] assumption instead than the OWA which basically consists in adding a LCW annotation all the time the knowledge of the planner about a kind of information is complete. In the IS set knowledge is represented in such a way that allows the planner to reason about local closed world information, so as to avoid redundant information gathering activity. In practice we want to explicit the fact that the planner is aware of everything about a circumscripted set of information, i.e. if the planner performs knowledge acquisition with 8

9 the predicate ondisk(f; Disk1), it means that afterwards it will be aware of all the les on Disk1, thus it adds to the IS, the information LCW (ondisk(disk1)). We are also considering the possibility to interface the planner with a \proxy" system, instead than directly with the real world, which would behave as a knowledge acquisition module. In this context it would be possible to further reduce the number of sensing operations by querying this system with conjunction of goals concerning the same variable so as to retrieve only information consistent with all the conjuncts. In the example above, the preconditions type(f ile; \tmp") and ondisk(f ile; \B") would be veried as conjunction by retrieving, for the variable F ile, those values whose type is \tmp" and whose location is disk \B". References [1] ECL i PS e User Manual Release 3.3, ECRC [2] J.Jaar, M.J.Maher, \Constraint Logic Programming: a Survey", Journal of Logic Programming on 10 years of Logic Programming, [3] D.Joslin, M.Pollack, \Passive and Active Decision Postponment", Proceedings of European Workshop of Planning, [4] P.Van Hentenryck, \Constraint Satisfaction in Logic Programming", MIT Press, [5] D.S. Weld, \An Introduction to Least Commitment Planning", AI Magazine, vol. 15, 1994, pp. 27{61. [6] E. Lamma, M. Milano, R. Cucchiara, P. Mello, \An Interactive Constraint based system for selective attention in Visual search", Proceedings of the 10th ISMIS, [7] K. Golden, \Planning and Knowledge Representation for Softbots", PHD Thesis, University of Washgton, 1997 [8] R.J. Firby, \Adaptive Execution in Complex Dynamic Worlds", Yale University, 1989 [9] J. Lever, B. Richards, \parcplan: a Planning Architecture with Parallel Actions, Resources and Constraints", Proceedings of the 8th ISMIS, [10] K. Golden, D. Weld, \Representing sensing actions: The middle ground revisited", Proceedings of the 5th Int. Conf. on Knowledge Representation and Reasoning, [11] M. Peot, D. Smith, \Conditional Nonlinear Planning" Proceedings of the 1st Int. Conf. on Principles of Knowledge Representation and Reasoning, [12] Subbarao Kambhampati, \Using Disjunctive orderings instead of Conict Resolution in Partial order planning", Technical Report, Department of Computer Science and Engineering Arizona State University, January [13] Qiang Yang, \A theory of conict resolution in planning", Articial Intelligence, no. 58 (1992), Elsevier Science Publisher, pp. 361{392. 9