# abstraction heuristics extended with counting abstractions · abstraction heuristics extended with...

Embed Size (px)

TRANSCRIPT

Abstraction Heuristics Extendedwith Counting Abstractions

Blai Bonet

Universidad Simon Bolıvar, Caracas, Venezuela

ICAPS 2011 – Freiburg, June 2011

Introduction

Abstractions is one of four main classes of heuristics

Abstractions are not dominated by the delete-free h+

Merge-and-shrink (MAS) heuristics are powerful abstractions

Underlying model of MAS is quite general

Contribution

Define counting abstractions (CA) within the model of MAS

A CA tracks the number of atoms true at states in admissiblemanner; e.g. number of unachieved goals

CAs can be defined with respect to any set of atoms; notbound to SAS+ variables

CAs can be composed with standard MAS heuristics

Abstraction Heuristics

(Very) General Framework

abstractions −→ (labeled) transition systems

compositions −→ synchronized products

Transition Systems

Abstract state space with transitions

Tuple T = 〈S,L,A, s0, ST 〉 where:

S is finite set of states

L finite set of labels (actions)

labeled transitions A ⊆ S × L× S

initial state s0 ∈ S

goals ST ⊆ S

Minimum distances to goals denoted by hT

Abstractions

Abstraction of T = 〈S,L,A, s0, ST 〉 is

transition system T ′ = 〈S′, L,A′, s′0, S′T 〉 over same labels

homomorphism α : S → S′; i.e.,

– (s, `, t) ∈ A =⇒ (α(s), `, α(t)) ∈ A′

– s′0 = α(s0)

– α(ST ) ⊆ ST

If (T ′, α) is abstraction of T , hT′(α(s)) ≤ hT (s)

Thus, hT′

is admissible heuristic for searching T

Synchronized Products

Abstractions (T ′, α′) and (T ′′, α′′) combined into abstractionT ′ ⊗ T ′′ = 〈S,L,A, s0, sT 〉 where:

S = S′ × S′′

((s′, s′′), `, (t′, t′′)) ∈ A iff (s′, `, t′) ∈ A′ and (s′′, `, t′′) ∈ A′′

s0 = (s′0, s′′0)

ST = S′T × S′′T

Homomorphism is α(s) = (α′(s), α′′(s))

Thm: max{hT ′, hT

′′} ≤ hT ′⊗T ′′

Merge-and-Shrink Heuristics

Start with abstractions corresponding to single SAS+ variables

Combine them (in some order) using synchronized products

Control size of products by shrinking the abstractions

Example: Gripper with 1 Arm and 2 Balls

Atomic transition systems:

inA

inB

HF

HT

0B

0G

0A

1B

1G

1A

position holding ball0 ball1

moveB

mov

eA

pick??

pic

k0A

pick0B

pic

k1A

pick1B

dro

p??

drop

0A

dro

p0B

drop

1A

dro

p1B

Example: Gripper with 1 Arm and 2 Balls

Composition: position + holding

inA,HF

inA,HT

inB,HF

inB,HT

moveA

moveB

moveA

moveB

pick?A

pick?B

dro

p?A

dro

p?B

Example: Gripper with 1 Arm and 2 Balls

Composition: position + holding + ball0

inA,HF,0B inA,HT,0B

inB,HF,0B inB,HT,0B

inA,HF,0G inB,HF,0G

inB,HT,0G inA,HT,0G inA,HF,0A inB,HF,0A

inA,HT,0A inB,HT,0A

moveA

moveA

moveA

moveA

mov

eA

mov

eA

moveB

moveB

moveB

moveB

moveB

moveB

pick0A

pick0B

drop0A

dro

p0B

pick1A

pic

k1B

dro

p1A

dro

p1B

pick1A

pick1B

drop1A

drop1B

Counting

Goal: to define abstractions that count atoms

Atoms: of the form ‘X = x’ for SAS+ variable X and x ∈ DX

Fix set C of atoms. For state s, C(s) = |{p ∈ C : s |= p}|

Abstraction (TC = 〈S′, A′, s′0, S′T 〉, α) that counts C is

S′ = {0, 1, . . . , |C|}

(C(s), `, C(t)) ∈ A′ iff (s, `, t) ∈ A

s′0 = C(s0)

S′T = {C(s) : s ∈ ST }

α(s) = C(s)

Thm: TC gives admissible estimates

but cannot be computed without considering all states in T

Goal: to define abstractions that count atoms

Atoms: of the form ‘X = x’ for SAS+ variable X and x ∈ DX

Fix set C of atoms. For state s, C(s) = |{p ∈ C : s |= p}|

Abstraction (TC = 〈S′, A′, s′0, S′T 〉, α) that counts C is

S′ = {0, 1, . . . , |C|}

(C(s), `, C(t)) ∈ A′ iff (s, `, t) ∈ A

s′0 = C(s0)

S′T = {C(s) : s ∈ ST }

α(s) = C(s)

Thm: TC gives admissible estimates

but cannot be computed without considering all states in T

Goal: to define abstractions that count atoms

Atoms: of the form ‘X = x’ for SAS+ variable X and x ∈ DX

Fix set C of atoms. For state s, C(s) = |{p ∈ C : s |= p}|

Abstraction (TC = 〈S′, A′, s′0, S′T 〉, α) that counts C is

S′ = {0, 1, . . . , |C|}

(C(s), `, C(t)) ∈ A′ iff (s, `, t) ∈ A

s′0 = C(s0)

S′T = {C(s) : s ∈ ST }

α(s) = C(s)

Thm: TC gives admissible estimates

but cannot be computed without considering all states in T

Goal: to define abstractions that count atoms

Atoms: of the form ‘X = x’ for SAS+ variable X and x ∈ DX

Fix set C of atoms. For state s, C(s) = |{p ∈ C : s |= p}|

Abstraction (TC = 〈S′, A′, s′0, S′T 〉, α) that counts C is

S′ = {0, 1, . . . , |C|}

(C(s), `, C(t)) ∈ A′ iff (s, `, t) ∈ A

s′0 = C(s0)

S′T = {C(s) : s ∈ ST }

α(s) = C(s)

Thm: TC gives admissible estimates

but cannot be computed without considering all states in T

Effective Construction

Idea: compute abstraction at representation level (SAS+ level)

How: count for each operator how many atoms in C are deletedand how many are added; i.e., net difference

But:

if p is true and ‘added’, the count should not increase

if p is false and ‘deleted’, the count should not decrease

Solution: approximate the count in an admissible manner

Effective Construction

Idea: compute abstraction at representation level (SAS+ level)

How: count for each operator how many atoms in C are deletedand how many are added; i.e., net difference

But:

if p is true and ‘added’, the count should not increase

if p is false and ‘deleted’, the count should not decrease

Solution: approximate the count in an admissible manner

Effective Construction

Idea: compute abstraction at representation level (SAS+ level)

How: count for each operator how many atoms in C are deletedand how many are added; i.e., net difference

But:

if p is true and ‘added’, the count should not increase

if p is false and ‘deleted’, the count should not decrease

Solution: approximate the count in an admissible manner

Effective Construction

Idea: compute abstraction at representation level (SAS+ level)

But:

if p is true and ‘added’, the count should not increase

if p is false and ‘deleted’, the count should not decrease

Solution: approximate the count in an admissible manner

Consider the sets (computed from SAS+ representation):

baseo = C ∩ pre[o]

δ+o = {X : X = X(pre[o]) /∈ C ∧X = X(post[o]) ∈ C}

δ−o = {X : X = X(pre[o]) ∈ C ∧X = X(post[o]) /∈ C}

αo = {X : X(pre[o]) = ⊥ ∧X = X(post[o]) ∈ C}

βo = VarsC ∩ {X : X(pre[o]) = ⊥ ∧X = X(post[o]) /∈ C}

Thm: Let o be applicable at s, and s′ = result(s, o). Then,

C(s) ≥ |baseo|C(s′) = C(s) + |δ+o | − |δ−o |+ k

where −|βo| ≤ k ≤ |αo|

Consider the sets (computed from SAS+ representation):

baseo = C ∩ pre[o]

δ+o = {X : X = X(pre[o]) /∈ C ∧X = X(post[o]) ∈ C}

δ−o = {X : X = X(pre[o]) ∈ C ∧X = X(post[o]) /∈ C}

αo = {X : X(pre[o]) = ⊥ ∧X = X(post[o]) ∈ C}

βo = VarsC ∩ {X : X(pre[o]) = ⊥ ∧X = X(post[o]) /∈ C}

Thm: Let o be applicable at s, and s′ = result(s, o). Then,

C(s) ≥ |baseo|C(s′) = C(s) + |δ+o | − |δ−o |+ k

where −|βo| ≤ k ≤ |αo|

Approximation

Abstraction AC = (〈S,L,A, s0, ST 〉, α) where

S = {0, 1, . . . , |C|}

L is set of SAS+ operators

s0 = C(sinit)

ST = {v ∈ S : C(sgoal) ≤ v}

〈v, o, v′〉 ∈ A iff

v ≥ |baseo|v′ = v + |δ+o | − |δ−o |+ k

for some −|βo| ≤ k ≤ |αo| with 0 ≤ v′ ≤ |C|

Thm: AC is polytime computable and admissible

Example: Gripper with 1 Arm and 2 Balls

Atomic transition systems:

inA

inB

HF

HT

0

1

2

position holding #ballsA

moveB

mov

eA

pick??

pic

k?A

pic

k?A

dro

p??

drop

?Ad

rop?A

Example: Gripper with 1 Arm and 2 Balls

Composition: position + holding + #ballsA

inA,HF,0 inB,HF,0 inB,HT,0 inA,HT,0

inA,HT,1 inB,HT,1 inB,HF,1 inA,HF,1

inA,HF,2 inB,HF,2 inB,HT,2 inA,HT,2

moveA

moveA

moveA

moveA

moveA

moveA

moveB

moveB

moveB

moveB

moveB

moveB

pick?A

pick?A

pick?B

pick?B

pick?B

dro

p?A

dro

p?A

drop?B

drop?B

drop?B

Experimental Results: Gripper with 2 Arms (IPC)

Strategies: static (default) and LIFO

Counting: Cinit, Cgoal, and 3 random each with 2 atoms

Size: N = 50, 000 nodes in abstraction

static strategy LIFO strategy

inst. h∗(s◦) M&S M&S-# M&S M&S-#

03 23 9,318 10,298 0 004 29 68,186 65,681 32,514 005 35 376,494 371,720 332,629 006 41 1,982,014 1,974,279 1,934,383 007 47 10,091,966 10,080,246 10,047,485 0

Lessons Learned

General abstractions:

Function that maps states into domain generates abstraction

Abstraction may not be effective

Approximate abstraction with an effective abstraction

Counting abstractions:

powerful abstractions

can be combined with other abstractions

how to select good sets C of atoms is open issue

. . . see the paper for more interesting stuff . . .

Thanks!