Loading in 5 sec....

Planning with Incomplete, Unbounded InformationPowerPoint Presentation

Planning with Incomplete, Unbounded Information

- 50 Views
- Uploaded on
- Presentation posted in: General

Planning with Incomplete, Unbounded Information

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Planning with Incomplete, Unbounded Information

May 20, 2003

Tal Shaked

- Finite set of states (objects, relations)
- Uncertain of current state
- Realistic?

- Infinite set of states
- Many objects and relations (most unknown)
- Too large to reason about directly

- Unix/Internet
- Puccini and Rodney

- Web
- Web services
- DAML-S (DAML+OIL)

- Problems with existing planners
- Puccini, PKS

- What is difficult
- LCW review
- Ideas to improve planners
- How PKS works

PKS (2002)

Petrick and Bacchus

Contingent plans

Puccini (1998)

Etzioni, Golden, Weld

Internet softbot

- Partial-order-planner
- Expressive
- SADL

- Interleaves Planning with Execution
- Not clear how

- Slow
- Required domain-specific knowledge

- Contingent, forward-chaining planner
- Not Expressive
- Slow

- Constructs a complete, correct plan
- Separates plan-time and execution-time effects

- No universal quantification or LCW

- No search control

- Slow
- How do we solve these planning problems?
- What heuristics can we add?

- Execution model
- Are contingent plans practical?
- When should actions be executed?

- How can we find structure?

- LCW
- Unlimited sensing, run-time objects/relations
- Contingent plans
- Interleaved planning and execution

- What is different?
- Mutexes?
- Scalability?

- Why is LCW useful?
- How does it work?

- Avoid repeated sensing
- Universal quantification

- Inference
- Compression
- Lazy evaluation

How is inference done?

If we know all files in jokes/, then we know if the file giggy is in jokes/

If we know all files in jokes/, and know all dirty jokes, then we know if giggy is dirty and in jokes/

- Information Gain: A formula that is originally U, becomes T or F
- Generally cannot lose LCW

- Information Loss: A formula initially T or F, becomes U
- Generally, all LCW “relevant” to that literal are lost
- Know the size of all files in root/. Execute compress root/passwords.txt

- Bounded sensing
- Set of possible observations

- Unbounded sensing
- Generic types and relations

- Consider potential bindings at next level

- Search for plans in the graph
- Consider one branch at a time

- Heuristics
- Reachability
- Amount of sensing to reach a literal
- Depth in planning graph

- Control execution
- Agent-centered search?

- Reachability

- Mutexes
- Same as normal Graphplan
- LCW?
- Generic types and relations?

- Quick growth due to sensing
- Limit to relevant actions
- Learn relevance probabilities

Start: ((own my_book)

(book_subject my_book chess))

Goal: ((own ?book)

(book_subject ?book go))

Predicates:

(own ?book)

(book_subject ?book ?subject)

(at_store ?book ?book_store)

action: trade(?book1 ?book2 ?book_store)

precond: ((own ?book1) (at_store ?book2 ?book_store))

effect: ((own ?book2) (not (own?book1)))

action: search(?book_store ?subject)

precond: ()

effect: (forall (!book)

(when (at_store !book ?book_store)

(at_store !book ?book_store)

(book_subject !book ?subject)))

(LCW((at_store #book ?book_store)

(book_subject #book ?subject))

- Similar Graphplan search
- LPG-like search (local search on graph)
- Propagating sensing action links
- Executing to reach ‘better’ states
- Forward/backward chaining heuristics?

- Agent wants to find a *.pdf file
- Try ls
- hope some file exists, possibly a *.pdf file

- latex(paper.tex), dvipdf(paper.dvi)
- check for read/write permissions

- Try ls
- How can the agent learn?
- Can this be represented in a planning graph?

- Only represent what agent knows
- Actions manipulate knowledge
- Advantages
- Compact Representation
- Introducing new objects

- Disadvantages?
- Unable to distinguish between possible worlds

- Fancy way of just adding K
- is true at a particular world w iff it is true by standard rules
- K() is true at w iff is true at every possible world
- can be true, yet the agent may not know

- Databases store agent’s knowledge
- Can be converted to modal logic formulas
- Preconditions as knowledge
- Effects as database modifications
- Goals as knowledge

- Kf – stores facts like STRIPs
- Kw – agent either knows or negation
- know(this) Kw K(know(this)) v K(¬know(this))
- With variables, can model universal effects
- At run time, generates LCW
- Construct conditional branches

- Kv – function values agent will know
- Plan time just know value will exist
- Execution time will know actual value

- Kx – “exclusive or” knowledge
- Exactly one proposition in a set is true

- Databases are conjunctions of formulas
- Limits what the agent can know

- Cannot represent some sets of worlds

- w1: P(a), ¬P(b); w2: ¬P(a), P(b)
- {w1,w2} K(P(a) v P(b))
- If a directory contains the file a.out, then it also contains core

- K() – is known to be true
- K(¬) – is known to be false
- Kw() – is knowneither true or false
- Kv(t) – is t known to have fixed value
- Negation of the above
- What about LCW?

- {I, G, A, U}
- I = initial state
- G = goal conditions (primitive queries)
- A = set of actions
- U = domain specific update rules (optional)

PlanPKS

if(goalsSatisfied) return plan

else choose some action, apply it, PlanPKS

or choose some ground instance in Kw

PlanPKS with added to Kf

PlanPKS with ¬ added to Kf

return merged, contingent plan

When does this search terminate?

What are some problems and limitations?

Initial State:

Kf = {(=(pwd) root), (indir papers root), (indir planner root),

(dir root), (dir papers), (dir planner), (file paper_tex)}

Kx = {((indir paper_tex planner) | (indir paper_tex papers))}

Goal:

K(indir paper_tex (pwd))

Directory Structure

Contingent Plan

Start: (pwd) = root

Goal: Know paper_tex is in the current directory (pwd)

Exclusive Or: paper_tex is in either papers or planner

Is this plan optimal?

What are problems with this representation of plans?

- Conditions that hold in final state
- No universal quantification

- What about SADL?
- Initially?
- Restore?
- Hands-off?

- Conditional plan is a tree
- Nodes are knowledge states
- Edges are actions

- Each leave corresponds to one branch
- Each branch one linear sequences of worlds
- Reason about each linear sequence
- How?

Initial State: bottle of liquid, a healthy lawn

Goal: know whether liquid is poisonous

- Consider two consecutive states, s1and s2, in a linearization and the related action, a
- newly known ins2 and a does not change , then s1
- newly known ins1 and a does not change , then s2
- newly known ins1 and a has conditional effect , then s2
- More inferences using similar ideas…

- When can we apply these inferences?
- At what points in conditional plans?

- What about initially, restore, hands-off?

- Experiments misleading
- Unclear about LCW
- Not clear what is new and important
- More discussion about incompleteness

- Heuristic search
- Dealing with scalability issues

- Contingent planning with universal quantification
- Further implementation and testing
- Parallel plans
- Probabilistic knowledge