Loading in 5 sec....

Combinatorial Optimization for Graphical ModelsPowerPoint Presentation

Combinatorial Optimization for Graphical Models

- By
**ipo** - Follow User

- 83 Views
- Uploaded on

Download Presentation
## PowerPoint Slideshow about ' Combinatorial Optimization for Graphical Models' - ipo

**An Image/Link below is provided (as is) to download presentation**

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 - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript

### Combinatorial Optimization for Graphical Models

Rina Dechter

Donald Bren School of Computer Science

University of California, Irvine, USA

Radu Marinescu

Cork Constraint Computation Centre

University College Cork, Ireland

Simon de Givry & Thomas Schiex

Dept. de Mathématique et Informatique Appliquées

INRA, Toulouse, France

Outline

- Introduction
- Graphical models
- Optimization tasks for graphical models
- Fundamental operations on cost functions

- Inference
- Bucket Elimination, Bucket-Tree and Cluster-Tree Elimination
- Polynomial classes based on structure

- Search (OR)
- Branch-and-Bound and Best-First Search
- Local search and Partial search

- Lower-bounds and relaxations
- Bounded inference, local consistency and continuous relaxations

- Exploiting problem structure in search
- AND/OR search spaces (trees, graphs)

- Other hybrids of search and inference
- Cutset decomposition, boosting search with VE, super-bucket scheme

- Software & Applications

Outline

- Introduction
- Graphical models
- Optimization tasks for graphical models
- Solving optimization problems by inference and search
- Fundamental operations on cost functions

- Inference
- Search (OR)
- Lower-bounds and relaxations
- Exploiting problem structure in search
- Other hybrids of search and inference
- Software & Applications

B

C

D

F

G

Constraint Optimization Problemsfor Graphical Modelsf(A,B,D) has scope {A,B,D}

- Primal graph =
- Variables --> nodes
- Functions, Constraints - arcs

F(a,b,c,d,f,g)= f1(a,b,d)+f2(d,f,g)+f3(b,c,f)

E

A

A B

red green

red yellow

green red

green yellow

yellow green

yellow red

A

E

D

B

D

F

B

G

F

C

G

C

Constraint NetworksMap coloring

Variables: countries (A B C etc.)

Values: colors (redgreenblue)

Constraints:

ConstrainedOptimization

Example: power plant scheduling

Smoking

P(C|S)

P(B|S)

Bronchitis

Cancer

Dyspnoea

P(D|C,B)

P(X|C,S)

X-Ray

Probabilistic NetworksBN = (X,D,G,P)

P(D|C,B)

P(S,C,B,X,D) = P(S)· P(C|S)·P(B|S)·P(X|C,S)·P(D|C,B)

MPE= Find a maximum probability assignment, given evidence

MPE= find argmax P(S)· P(C|S)· P(B|S)· P(X|C,S)· P(D|C,B)

The “alarm” network - 37 variables, 509 parameters (instead of 237)

MINVOLSET

KINKEDTUBE

PULMEMBOLUS

INTUBATION

VENTMACH

DISCONNECT

PAP

SHUNT

VENTLUNG

VENITUBE

PRESS

MINOVL

FIO2

VENTALV

PVSAT

ANAPHYLAXIS

ARTCO2

EXPCO2

SAO2

TPR

INSUFFANESTH

HYPOVOLEMIA

LVFAILURE

CATECHOL

LVEDVOLUME

STROEVOLUME

ERRCAUTER

HR

ERRBLOWOUTPUT

HISTORY

CO

CVP

PCWP

HREKG

HRSAT

HRBP

BP

Monitoring Intensive-Care PatientsOil (instead of 2

sales

Test

cost

Drill

cost

Test

Test

result

Oil

produced

Chance variables: over domains.

Decision variables:

CPT’s for chance variables:

Reward components:

Utility function:

Oil sale

policy

Drill

Sales

cost

Seismic

structure

Oil

underground

Market

information

Influence DiagramsTask: find optimal policy:

Influence diagram ID = (X,D,P,R).

A (instead of 2

F

B

C

E

D

Graphical Models- A graphical model (X,D,F):
- X = {X1,…Xn} variables
- D = {D1, … Dn} domains
- F = {f1,…,fr} functions(constraints, CPTS, CNFs …)

- Operators:
- combination
- elimination (projection)

- Tasks:
- Beliefupdating: X-y j Pi
- MPE: maxX j Pj
- CSP: X j Cj
- Max-CSP: minX j Fj

Conditional ProbabilityTable (CPT)

Relation

Primal graph

(interaction graph)

- All these tasks are NP-hard
- exploit problem structure
- identify special cases
- approximate

Sample Domains for GM (instead of 2

- Web Pages and Link Analysis
- Communication Networks (Cell phone Fraud Detection)
- Natural Language Processing (e.g. Information Extraction and Semantic Parsing)
- Battle-space Awareness
- Epidemiological Studies
- Citation Networks
- Intelligence Analysis (Terrorist Networks)
- Financial Transactions (Money Laundering)
- Computational Biology
- Object Recognition and Scene Analysis
…

Types of Constraint Optimization (instead of 2

- Valued CSPs, Weighted CSPs, Max-CSPs, Max-SAT
- Most Probable Explanation (MPE)
- Linear Integer Programs
- Examples:
- Problems translated from planning
- Unit scheduling maintenance
- Combinatorial auctions
- Maximum-likelihood haplotypes in linkage

Outline (instead of 2

- Introduction
- Graphical models
- Optimization tasks for graphical models
- Solving optimization problems by inference and search
- Fundamental operations on cost functions

- Inference
- Search (OR)
- Lower-bounds and relaxations
- Exploiting problem structure in search
- Other hybrids of search and inference
- Software & Applications

Graphical Models Reasoning (instead of 2

Time: exp(n)

Space: linear

Search: Conditioning

Incomplete

Simulated Annealing

Complete

Gradient Descent

Time: exp(w*)

Space: exp(w*)

Depth-first search

Branch-and-Bound

A* search

Incomplete

Hybrids:

Local Consistency

Complete

Unit Resolution

mini-bucket(i)

Adaptive Consistency

Tree Clustering

Dynamic Programming

Resolution

Inference: Elimination

Bucket Elimination (instead of 2(Variable Elimination)

=

¹

D = C

A ¹ C

B = A

contradiction

=

Bucket E: E ¹ D, E ¹ C

Bucket D: D ¹ A

Bucket C: C ¹ B

Bucket B: B ¹ A

Bucket A:

The Idea of Conditioning (instead of 2

A (instead of 2

A

D

D

B

B

C

C

F

F

E

E

G

G

…

A=1

A=k

D

D

B

B

D

B

C

F

C

F

C

F

E

E

G

G

E

G

Conditioning vs. EliminationConditioning (search)

Elimination (inference)

k “sparser” problems

1 “denser” problem

Outline (instead of 2

- Introduction
- Graphical models
- Optimization tasks for graphical models
- Solving optimization problems by inference and search
- Fundamental operations on cost functions

- Inference
- Search (OR)
- Lower-bounds and relaxations
- Exploiting problem structure in search
- Other hybrids of search and inference
- Software & Applications

Fundamental Operations on Cost Functions (instead of 2

- To be completed …

Outline (instead of 2

- Introduction
- Inference
- Bucket Elimination
- Bucket-Tree Elimination and Cluster-Tree Elimination
- Polynomial classes based on structure

- Search (OR)
- Lower-bounds and relaxations
- Exploiting problem structure in search
- Other hybrids of search and inference
- Software & Applications

F(a, (instead of 2b)+F(a,c)+F(a,d)+F(b,c)+F(b,d)+F(b,e)+F(c,e)

OPT =

Variable Elimination

F(a,b)+F(b,c)+F(b,d)+F(b,e)

F(a,c)+F(c,e) +

F(a,d) +

Computing the Optimal Cost SolutionA

Constraint graph

B

C

B

C

D

E

D

E

OPT (instead of 2

FindingAlgorithm elim-opt(Dechter, 1996)Non-serial Dynamic Programming(Bertele & Briochi, 1973)

Elimination operator

bucket B:

F(a,b) F(b,c) F(b,d) F(b,e)

B

bucket C:

F(c,a) F(c,e)

C

bucket D:

F(a,d)

D

bucket E:

e=0

E

bucket A:

A

Generating the Optimal Assignment (instead of 2

B:

F(a,b) F(b,c) F(b,d) F(b,e)

C:

F(c,a) F(c,e)

D:

F(a,d)

E:

e=0

A:

OPT (instead of 2

ComplexityAlgorithm elim-opt(Dechter, 1996)Non-serial Dynamic Programming(Bertele & Briochi, 1973)

Elimination operator

bucket B:

F(a,b) F(b,c) F(b,d) F(b,e)

B

bucket C:

F(c,a) F(c,e)

C

bucket D:

F(a,d)

D

bucket E:

e=0

E

exp(w*=4)

”induced width”

(max clique size)

bucket A:

A

Induced-width (instead of 2

- Width along ordering d, w(d):
- max # of previous neighbors (parents)

- Induced width along ordering d, w*(d):
- The width in the ordered induced graph, obtained by connecting “parents” of each node X, recursively from top to bottom

E

D

C

B

A

A (instead of 2

B

C

D

E

constraint graph

B

E

C

D

D

C

E

B

A

A

Complexity of Bucket EliminationBucket-Elimination is time and space

The effect of the ordering:

r = number of functions

Finding smallest induced-width is hard!

Bucket-Tree Elimination (instead of 2

- Describe BTE

Cluster-Tree Elimination (instead of 2

- Describe CTE

Outline (instead of 2

- Introduction
- Inference
- Search (OR)
- Branch-and-Bound and Best-First search
- Branching schemes, variable and value orderings
- Local search and Partial search

- Lower-bounds and relaxations
- Exploiting problem structure in search
- Other hybrids of search and inference
- Software & Applications

C (instead of 2

A

F

D

B

E

A

B

C

D

E

F

The Search SpaceObjective function:

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

C (instead of 2

A

F

D

B

E

A

B

C

D

E

F

The Search Space0

0

0

1

2

0

0

4

0

1

0

1

3

1

5

4

0

2

2

5

0

1

0

1

0

1

0

1

5

6

4

2

2

4

1

0

5

6

4

2

2

4

1

0

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

3

5

3

5

3

5

3

5

1

3

1

3

1

3

1

3

5

2

5

2

5

2

5

2

3

0

3

0

3

0

3

0

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

3

0

2

2

3

0

2

2

3

0

2

2

1

2

0

4

1

2

0

4

1

2

0

4

3

0

2

2

3

0

2

2

3

0

2

2

3

0

2

2

3

0

2

2

1

2

0

4

1

2

0

4

1

2

0

4

1

2

0

4

1

2

0

4

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

Arc-cost is calculated based on cost components.

C (instead of 2

A

F

D

B

E

A

B

C

D

E

F

The Value Function5

0

0

5

7

0

1

2

0

0

4

6

5

7

4

0

1

0

1

3

1

5

4

0

2

2

5

8

5

3

1

7

4

2

0

0

1

0

1

0

1

0

1

5

6

4

2

2

4

1

0

5

6

4

2

2

4

1

0

3

3

3

3

1

1

1

1

2

2

2

2

0

0

0

0

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

3

5

3

5

3

5

3

5

1

3

1

3

1

3

1

3

5

2

5

2

5

2

5

2

3

0

3

0

3

0

3

0

0

2

0

2

0

2

0

2

0

2

0

2

0

2

0

2

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

3

0

2

2

3

0

2

2

3

0

2

2

1

2

0

4

1

2

0

4

1

2

0

4

3

0

2

2

3

0

2

2

3

0

2

2

3

0

2

2

3

0

2

2

1

2

0

4

1

2

0

4

1

2

0

4

1

2

0

4

1

2

0

4

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

Value of node = minimal cost solution below it

C (instead of 2

A

F

D

B

E

A

B

C

D

E

F

An Optimal Solution5

0

0

5

7

0

1

2

0

0

4

6

5

7

4

0

1

0

1

3

1

5

4

0

2

2

5

8

5

3

1

7

4

2

0

0

1

0

1

0

1

0

1

5

6

4

2

2

4

1

0

5

6

4

2

2

4

1

0

3

3

3

3

1

1

1

1

2

2

2

2

0

0

0

0

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

3

5

3

5

3

5

3

5

1

3

1

3

1

3

1

3

5

2

5

2

5

2

5

2

3

0

3

0

3

0

3

0

0

2

0

2

0

2

0

2

0

2

0

2

0

2

0

2

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

3

0

2

2

3

0

2

2

3

0

2

2

1

2

0

4

1

2

0

4

1

2

0

4

3

0

2

2

3

0

2

2

3

0

2

2

3

0

2

2

3

0

2

2

1

2

0

4

1

2

0

4

1

2

0

4

1

2

0

4

1

2

0

4

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

Value of node = minimal cost solution below it

2. Best-First Search (instead of 2

Always expand the node with the highest heuristic value f(xp)

Needs lots of memory

1. Branch-and-Bound

Use heuristic function f(xp) to prune the depth-first search tree

Linear space

f L

L

Basic Heuristic Search SchemesHeuristic function f(xp) computes a lower bound on the best

extension of xp and can be used to guide a heuristic

search algorithm. We focus on:

Best-First vs. Depth-first Branch-and-Bound (instead of 2

- Best-First (A*): (optimal)
- Expand least number of nodes given h
- Requires to store all search tree

- Depth-first Branch-and-Bound:
- Can use only linear space
- If find an optimal solution early will expand the same space as Best-First (if search space is a tree)
- B&B can improve heuristic function dynamically

How to Generate Heuristics (instead of 2

- The principle of relaxed models
- Mini-Bucket Elimination
- Bounded directional consistency ideas
- Linear relaxation for integer programs

Outline (instead of 2

- Introduction
- Inference
- Search (OR)
- Lower-bounds and relaxations
- Bounded inference
- Mini-Bucket Elimination
- Static and dynamic mini-bucket heuristics

- Local consistency
- Continuous relaxations

- Bounded inference
- Exploiting problem structure in search
- Other hybrids of search and inference
- Software & Applications

Mini-Bucket Approximation (instead of 2

Split a bucket into mini-buckets => bound complexity

bucket (X) =

{ h1, …, hr, hr+1, …, hn }

{ h1, …, hr }

{ hr+1, …, hn }

Mini-Bucket Elimination (instead of 2

Mini-buckets

minBΣ

bucket B:

F(b,e)

F(a,b)

F(b,d)

A

bucket C:

F(c,e)

F(a,c)

B

C

F(a,d)

hB(a,d)

bucket D:

E

D

hC(e,a)

hB(e)

bucket E:

hE(a)

hD(a)

bucket A:

L = lower bound

Semantics of Mini-Bucket: Splitting a Node (instead of 2

Variables in different buckets are renamed and duplicated

(Kask et. al., 2001), (Geffner et. al., 2007), (Choi, Chavira, Darwiche , 2007)

Before Splitting:Network N

After Splitting:Network N'

U

U

Û

MBE-MPE(i) (instead of 2Algorithm Approx-MPE(Dechter & Rish, 1997)

- Input: i – max number of variables allowed in a mini-bucket
- Output: [lower bound (P of a sub-optimal solution), upper bound]

Example: approx-mpe(3) versus elim-mpe

Properties of MBE(i) (instead of 2

- Complexity: O(r exp(i)) time and O(exp(i))space
- Yields an upper-bound and a lower-bound
- Accuracy: determined by upper/lower (U/L) bound
- As i increases, both accuracy and complexity increase
- Possible use of mini-bucket approximations:
- As anytime algorithms
- As heuristics in search

- Other tasks: similar mini-bucket approximations for:
- Belief updating, MAP and MEU(Dechter & Rish, 1997)

Anytime Approximation (instead of 2

Empirical Evaluation (instead of 2(Rish & Dechter, 1999)

- Benchmarks
- Randomly generated networks
- CPCS networks
- Probabilistic decoding

- Task
- Comparing approx-mpe and anytime-mpe versus bucket-elimination (elim-mpe)

Time (sec) (instead of 2

Algorithm

cpcs360

cpcs422

elim-mpe

115.8

1697.6

anytime-mpe( ),

70.3

505.2

anytime-mpe( ),

70.3

110.5

CPCS networks – medical diagnosis(noisy-OR model)Test case: no evidence

Outline (instead of 2

- Introduction
- Inference
- Search (OR)
- Lower-bounds and relaxations
- Bounded inference
- Mini-Bucket Elimination
- Static and dynamic mini-bucket heuristics

- Local consistency
- Continuous relaxations

- Bounded inference
- Exploiting problem structure in search
- Other hybrids of search and inference
- Software & Applications

0 (instead of 2

D

0

B

E

0

D

1

A

B

1

D

E

1

Generating Heuristic for Graphical Models(Kask & Dechter, AIJ’01)Given a cost function

C(a,b,c,d,e) = F(a) + F(b,a) + F(c,a) + F(e,b,c) + F(d,b,a)

Define an evaluation function over a partial assignment as the

probability of it’s best extension

D

f*(a,e,d) = minb,c F(a,b,c,d,e) =

= F(a) + minb,c F(b,a) + F(c,a) + F(e,b,c) + F(d,a,b)

= g(a,e,d) • H*(a,e,d)

Generating Heuristics (cont.) (instead of 2

H*(a,e,d) = minb,c F(b,a) + F(c,a) + F(e,b,c) + F(d,a,b)

= minc [F(c,a)+ minb [F(e,b,c) + F(b,a) + F(d,a,b)]]

>=minc [F(c,a)+ minb F(e,b,c) + minb [F(b,a) + F(d,a,b)]]

= minb [F(b,a) + F(d,a,b)] + minc [F(c,a)+ minb F(e,b,c)]

= hB(d,a) + hC(e,a)

= H(a,e,d)

f(a,e,d) = g(a,e,d) + H(a,e,d)<=f*(a,e,d)

The heuristic function H is what is compiled during the

preprocessing stage of the Mini-Bucket algorithm.

Generating Heuristics (cont.) (instead of 2

H*(a,e,d) = minb,c F(b,a) + F(c,a) + F(e,b,c) + F(d,a,b)

= minc [F(c,a)+ minb [F(e,b,c) + F(b,a) + F(d,a,b)]]

>=minc [F(c,a)+ minb F(e,b,c) + minb [F(b,a) + F(d,a,b)]]

= minb [F(b,a) + F(d,a,b)] + minc [F(c,a)+ minb F(e,b,c)]

= hB(d,a) + hC(e,a)

= H(a,e,d)

f(a,e,d) = g(a,e,d) + H(a,e,d)<=f*(a,e,d)

The heuristic function H is what is compiled during the preprocessing stage of the

Mini-Bucket algorithm.

B: (instead of 2

F(E,B,C)

F(D,A,B)

F(B,A)

C:

F(C,A)

hB(E,C)

D:

hB(D,A)

0

D

B

0

E

0

E:

hC(E,A)

D

1

A

B

1

A:

F(A)

hE(A)

hD(A)

D

E

1

f(a,e,D) = F(a) + hB(D,a) + hC(e,a)

g

h – is admissible

Static MBE Heuristics- Given a partial assignment xp, estimate the cost of the best extension to a full solution
- The evaluation function f(xp) can be computed using function recorded by the Mini-Bucket scheme

A

B

C

E

D

Cost Network

f(a,e,D))=g(a,e) + H(a,e,D )

Heuristics Properties (instead of 2

- MB Heuristic is monotone, admissible
- Computed in linear time
- IMPORTANT:
- Heuristic strength can vary by MB(i)
- Higher i-bound more pre-processing stronger heuristic less search

- Allows controlled trade-off between preprocessing and search

BIDS (instead of 2

B1 = {1, 2, 3, 4}

B2 = {2, 3, 6}

B3 = {1, 4, 5}

B4 = {2, 8}

B5 = {5, 6}

PRICES

P1 = 8

P2 = 6

P3 = 5

P4 = 2

P5 = 2

Combinatorial Auctions Example- Constraint Optimization Problem
- Variables: b1, b2, b3, b4, b5 (i.e., bids)
- Domains: {0, 1}
- Constraints: R12, R13, R14, R24, R25, R35
- Costfunctions: r(b1), r(b2), r(b3), r(b4), r(b5)

Combinatorial Auctions (instead of 2

OPT

Experimental Methodology (instead of 2

- Algorithms
- BBMB(i) - Branch-and-Bound with MB(i)
- BBFB(i) - Best-First with MB(i)
- MBE(i) – Mini-Bucket Elimination

- Benchmarks
- Random Coding (Bayesian)
- CPCS (Bayesian)
- Random (CSP)

- Measures of performance
- Compare accuracy given a fixed amount of time
- i.e., how close is the cost found to the optimal solution

- Compare trade-off performance as a function of time

- Compare accuracy given a fixed amount of time

Empirical Evaluation of Mini-Bucket heuristics: (instead of 2Random coding networks (Kask & Dechter, UAI’99)

Random Coding, K=100, noise=0.28

Random Coding, K=100, noise=0.32

Each data point represents an average over 100 random instances

Max-CSP Experiments (instead of 2(Kask & Dechter, CP’00)

Dynamic MB and MBTE Heuristics (instead of 2(Kask, Marinescu and Dechter, UAI’03)

- Rather than pre-compile compute the heuristics during search
- Dynamic MB: use the Mini-Bucket algorithm to produce a bound for any node during search
- Dynamic MBTE: We can compute heuristics simultaneously for all un-instantiated variables using mini-bucket-tree elimination
- MBTE is an approximation scheme defined over cluster-trees. It outputs multiple bounds for each variable and value extension at once

Mini Bucket Tree Elimination (instead of 2

ABC

ABC

1

1

BC

BC

BCDF

BCDF

2

2

BF

BF

BEF

BEF

3

3

EF

EF

EFG

4

EFG

4

Branch-and-Bound w/ Mini-Buckets (instead of 2

- BB with static Mini-Bucket Heuristics (s-BBMB)
- Heuristic information is pre-compiled before search
- Static variable ordering, prunes current variable

- BB with dynamic Mini-Bucket Heuristics (d-BBMB)
- Heuristic information is assembled during search
- Static variable ordering, prunes current variable

- BB with dynamic Mini-Bucket-Tree Heuristics (BBBT)
- Heuristic information is assembled during search.
- Dynamic variable ordering, prunes all future variables

Empirical Evaluation (instead of 2

- Algorithms:
- Complete
- BBBT
- BBMB

- Incomplete
- DLM
- GLS
- SLS
- IJGP
- IBP (coding)

- Complete

- Measures:
- Time
- Accuracy (% exact)
- #Backtracks
- Bit Error Rate (coding)

- Benchmarks:
- Coding networks
- Bayesian Network Repository
- Grid networks (N-by-N)
- Random noisy-OR networks
- Random networks

Real World Benchmarks (instead of 2

(Marinescu, Kask & Dechter, UAI’03)

Average Accuracy and Time. 30 samples, 10 observations, 30 seconds

Empirical Results: Max-CSP (instead of 2

- Random Binary Problems: <N, K, C, T>
- N: number of variables
- K: domain size
- C: number of constraints
- T: Tightness

- Task: Max-CSP

i=2 (instead of 2

i=3

i=4

i=6

i=7

i=5

i=2

BBBT(i) vs. BBMB(i), N=100(Kask & Dechter, CP’00)

BBBT(i) vs. BBMB(i).

Outline (instead of 2

- Introduction
- Inference
- Search (OR)
- Lower-bounds and relaxations
- Bounded inference
- Local consistency
- Equivalence preserving transformations
- Directional arc-consistency and other local consistencies
- Polynomial classes based on cost functions semantics
- Global cost functions

- Continuous relaxations

- Exploiting problem structure in search
- Other hybrids of search and inference
- Software & Applications

Local Consistency (instead of 2

- To be completed …

Outline (instead of 2

- Introduction
- Inference
- Search (OR)
- Lower-bounds and relaxations
- Exploiting problem structure in search
- AND/OR search trees (linear space)
- AND/OR search graphs (caching)
- Searching the AND/OR spaces

- Other hybrids of search and inference
- Software & Applications

A (instead of 2

F

B

C

E

D

A

B

E

C

D

F

Classic OR Search SpaceOrdering: A B E C D F

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

A (instead of 2

A

F

F

B

B

C

C

E

E

D

D

A

B

OR

A

E

C

AND

0

1

D

F

OR

B

B

AND

0

0

1

1

OR

E

C

E

C

E

C

E

C

AND

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

OR

D

F

D

F

D

F

D

F

D

F

D

F

D

F

D

F

AND

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

AND/OR Search SpaceA

F

B

C

E

D

Primal graph

DFS tree

A (instead of 2

F

B

C

E

D

A

B

A

OR

A

0

1

E

C

B

0

1

0

1

D

F

A

A

E

0

0

1

1

0

1

0

1

0

1

0

1

B

B

C

0

0

1

1

0

0

1

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

E

E

D

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

C

C

F

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

D

D

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

F

F

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

AND/OR vs. ORAND

0

1

AND/OR

OR

B

B

AND

0

0

1

1

OR

E

C

E

C

E

C

E

C

AND

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

OR

D

F

D

F

D

F

D

F

D

F

D

F

D

F

D

F

AND

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

AND/OR size: exp(4), OR size exp(6)

OR

OR space vs. AND/OR space (instead of 2

Random graphs with 20 nodes, 20 edges and 2 values per node.

A (instead of 2

C

A

F

B

D

B

E

C

E

D

F

OR

AND

0

OR

7

1

AND

B

7

0

1

4

OR

5

6

4

1

1

0

AND

C

C

C

4

4

E

E

4

E

1

2

0

5

4

1

3

0

2

5

2

2

5

3

0

OR

0

1

0

1

2

0

0

2

5

2

1

0

2

0

1

0

0

1

0

1

0

1

0

1

AND

D

D

D

D

D

D

F

F

F

F

2

0

0

2

5

2

1

F

0

F

2

0

1

0

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

2

4

1

0

3

0

2

2

5

6

4

2

1

2

0

4

2

4

1

0

1

2

0

4

AND/OR Tree Search for COP5

A

0

5

0

B

5

2

6

0

C

3

E

3

3

1

3

5

5

0

2

1

0

2

0

1

D

D

F

F

5

2

0

2

0

1

0

1

0

1

0

1

5

6

4

2

3

0

2

2

OR node = Marginalization operator (minimization)

AND node = Combination operator (summation)

Summary of AND/OR Search Trees (instead of 2

- Based on a backbone pseudo-tree
- A solution is a subtree
- Each node has a value– cost of the optimal solution to the subproblem (computed recursively based on the values of the descendants)
- Solving a task = finding the value of the root node
- AND/OR search tree and algorithms are
(Freuder & Quinn, 1985), (Collin, Dechter & Katz, 1991), (Bayardo & Miranker, 1995)

- Space: O(n)
- Time:O(exp(m)), where m is the depth of the pseudo-tree
- Time: O(exp(w* log n))
- BFS is time and space: O(exp(w* log n)

From AND/OR Trees to AND/OR Graphs (instead of 2

- Any two nodes that root identical subtrees or subgraphs can be merged
- Minimal AND/OR search graph:
- closure under merge of the AND/OR search tree

- Inconsistent sub-trees can be pruned too
- Some portions can be collapsed or reduced

0 (instead of 2

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

J

J

J

J

G

G

J

J

G

G

J

J

J

J

G

G

J

J

G

G

G

G

J

J

G

G

J

J

G

G

G

G

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

H

H

H

H

K

K

K

K

H

H

H

H

K

K

K

K

H

H

H

H

K

K

K

K

H

H

H

H

K

K

K

K

H

H

H

H

K

K

K

K

H

H

H

H

K

K

K

K

H

H

H

H

K

K

K

K

H

H

H

H

K

K

K

K

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

A

J

AND/OR TreeA

F

B

B

C

K

E

C

E

D

D

F

G

J

G

H

OR

A

H

K

AND

0

1

OR

B

B

AND

0

0

1

1

OR

E

C

E

C

E

C

E

C

AND

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

OR

D

F

D

F

D

F

D

F

D

F

D

F

D

F

D

F

AND

OR

AND

OR

AND

A (instead of 2

J

An AND/OR Graph:Caching GoodsA

F

B

B

C

K

E

C

E

D

D

F

G

J

G

H

OR

A

H

K

AND

0

1

OR

B

B

AND

0

0

1

1

OR

E

C

E

C

E

C

E

C

AND

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

OR

D

F

D

F

D

F

D

F

D

F

D

F

D

F

D

F

AND

0

1

0

1

OR

J

J

G

G

AND

0

1

0

1

0

1

0

1

OR

H

H

H

H

K

K

K

K

AND

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

C (instead of 2

A

F

D

B

E

A

B

C

E

D

F

AND/OR Search Graph(Context-based Caching)- Identify unifiable subtrees
- Context = parent separator set in induced pseudo-tree
= current variable + ancestors connected to subtree below

(Dechter & Mateescu, UAI’04),

(Mateescu & Dechter, IJCAI’05)

context(A) = {A}

context(B) = {B,A}

context(C) = {C,B}

context(D) = {D}

context(E) = {E,A}

context(F) = {F}

C (instead of 2

A

F

D

B

E

OR

A

AND

0

1

OR

B

B

AND

1

1

0

0

C

C

C

OR

C

E

E

E

E

AND

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

OR

D

D

D

D

D

D

D

D

F

F

F

F

F

F

F

F

AND

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

AND/OR Search Graphcontext(A) = {A}

context(B) = {B,A}

context(C) = {C,B}

context(D) = {D}

context(E) = {E,A}

context(F) = {F}

A

B

C

E

D

F

Primal graph

Pseudo-tree

C (instead of 2

A

F

D

B

E

AND/OR Search Graphcontext(A) = {A}

context(B) = {B,A}

context(C) = {C,B}

context(D) = {D}

context(E) = {E,A}

context(F) = {F}

A

B

C

E

D

F

Primal graph

Pseudo-tree

OR

A

AND

0

1

OR

B

B

AND

1

1

0

0

C

C

OR

C

C

E

E

E

E

AND

0

1

0

1

0

1

0

1

OR

D

D

D

D

F

F

F

F

AND

0

1

0

1

A (instead of 2

B

C

E

D

F

AND/OR Tree vs. GraphOR

A

AND

0

1

54 nodes

OR

B

B

AND

1

1

0

0

C

C

C

C

OR

E

E

E

E

AND

Space: O(n)

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

OR

D

D

D

D

D

D

D

D

F

F

F

F

F

F

F

F

AND

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

OR

A

AND

0

1

18 nodes

OR

B

B

AND

1

1

0

0

C

C

C

C

OR

E

E

E

E

AND

0

1

0

1

0

1

0

1

Space: O(exp(w*))

OR

D

D

D

D

F

F

F

F

AND

0

1

0

1

C (instead of 2

A

F

D

B

E

A

5

7

0

1

B

B

7

5

6

5

6

4

0

1

0

1

C

C

C

C

4

3

4

E

E

E

4

E

2

0

5

2

0

1

0

1

D

D

D

D

Context-based Cachingcontext(A) = {A}

context(B) = {B,A}

context(C) = {C,B}

context(D) = {D}

context(E) = {E,A}

context(F) = {F}

A

B

Primal graph

C

E

D

F

Cache Table (C)

Space: O(exp(2))

A (instead of 2

C

A

F

B

D

B

E

C

E

D

F

Example (graph search)5

OR

A

0

0

AND

5

7

0

1

OR

B

B

5

7

1

4

2

0

AND

6

5

6

4

1

1

0

0

C

C

OR

C

C

3

4

E

E

E

E

4

4

3

2

1

0

4

0

2

2

1

5

3

1

5

2

5

3

3

0

5

3

AND

2

0

5

2

0

2

0

1

0

1

1

0

0

1

0

1

OR

D

D

D

D

2

0

F

F

5

2

0

2

F

F

1

0

2

1

2

2

0

6

1

0

2

4

0

2

4

3

4

5

AND

0

1

0

1

0

0

0

0

A (instead of 2

0

1

0

1

B

0

1

0

1

0

1

0

1

C

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

D

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

E

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

F

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

Full OR search tree

126 nodes

Context minimal OR search graph

28 nodes

A

B

OR

A

OR

A

AND

0

1

C

AND

0

1

OR

B

B

OR

B

B

AND

AND

D

1

1

0

0

1

1

0

0

OR

C

C

C

C

OR

E

E

C

E

E

C

C

C

E

E

E

E

AND

E

0

1

0

1

0

1

0

1

AND

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

OR

D

D

D

D

F

F

F

F

OR

D

D

D

D

D

D

D

D

F

F

F

F

F

F

F

F

AND

F

0

1

0

1

AND

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

Context minimal AND/OR search graph

18 AND nodes

Full AND/OR search tree

54 AND nodes

All Four Search SpacesAND/OR vs. OR DFS Algorithms (instead of 2

- AND/OR tree
- Space: O(n)
- Time: O(n km)
O(n kw* log n)

(Freuder, 1985; Bayardo, 1995; Darwiche, 2001)

- AND/OR graph
- Space: O(n kw*)
- Time: O(n kw*)

- k = domain size
- m = pseudo-tree depth
- n = number of variables
- w*= induced width
- pw*= path width

- OR tree
- Space: O(n)
- Time: O(kn)

- OR graph
- Space: O(n kpw*)
- Time: O(n kpw*)

Searching AND/OR Graphs (instead of 2

- AO(j): searches depth-first, cache j-context
- j = the max size of a cache table
(i.e. number of variables in a context)

- j = the max size of a cache table

j=0

j=w*

Space: O(exp w*)

Time: O(exp w*)

Space: O(n)

Time: O(exp(w* log n))

AO(j) time complexity?

Pseudo-trees (I) (instead of 2

- AND/OR graph/tree search algorithms influenced by the pseudo-tree quality
- Finding the minimal context/depth pseudo-tree is a hard problem
- Heuristics
- Min-fill (min context)
- Hypergraph separation (min depth)

Pseudo-trees (II) (instead of 2

- MIN-FILL(Kjæaerulff, 1990), (Bayardo & Miranker, 1995)
- Depth-first traversal of the induced graph constructed along some elimination order
- Elimination order prefers variables with smallest “fill set”

- HYPERGRAPH(Darwiche, 2001)
- Constraints are vertices in the hypergraph and variables are hyperedges
- Recursive decomposition of the hypergraph while minimizing the separator size (i.e. number of variables) at each step
- Using state-of-the-art software package hMeTiS

Outline (instead of 2

- Introduction
- Inference
- Search (OR)
- Lower-bounds and relaxations
- Exploiting problem structure in search
- AND/OR search trees (linear space)
- AND/OR search graphs (caching)
- Searching the AND/OR spaces
- AND/OR Branch-and-Bound search
- Best-First AND/OR search

- Other hybrids of search and inference
- Software & Applications

Classic Branch-and-Bound Search (instead of 2

Upper Bound UB

Lower Bound LB

g(n)

LB(n) = g(n) + h(n)

n

Prune if LB(n) ≥ UB

h(n)

OR Search Tree

Partial Solution Tree (instead of 2

A

A

A

0

0

B

C

B

C

B

C

0

0

0

0

D

Pseudo tree

A

D

D

0

A

1

0

B

C

(A=0, B=0, C=0, D=1)

(A=0, B=1, C=0, D=0)

(A=0, B=1, C=0, D=1)

(A=0, B=0, C=0, D=0)

0

1

0

Extension(T’) – solution trees that extend T’

B

C

D

1

0

0

D

1

Exact Evaluation Function (instead of 2

A

A

C

F

B

B

D

E

C

D

F

OR

9

A

0

0

AND

0

1

E

OR

9

B

0

0

AND

9

0

1

F

F

OR

2

C

4

D

3

3

C

D

v(F)

3

5

2

5

0

0

3

5

0

AND

0

1

0

1

4

0

5

1

0

1

0

OR

tip nodes

4

E

5

E

v(D,0)

6

4

8

5

AND

0

1

0

1

f*(T’) = w(A,0) + w(B,1) + w(C,0) + w(D,0) + v(D,0) + v(F)

Heuristic Evaluation Function (instead of 2

A

A

C

F

B

B

D

E

C

D

F

OR

9

A

0

0

h(n) ≤ v(n)

AND

0

1

E

OR

9

B

0

0

AND

9

0

1

F

F

OR

2

C

4

D

3

3

C

D

h(F) = 5

3

5

2

5

0

0

3

5

0

AND

0

1

0

1

4

0

5

1

0

1

0

OR

tip nodes

4

E

5

E

h(D,0) = 4

6

4

8

5

AND

0

1

0

1

f(T’) = w(A,0) + w(B,1) + w(C,0) + w(D,0) + h(D,0) + h(F) = 12 ≤ f*(T’)

AND/OR Branch-and-Bound Search (instead of 2

UB

OR

5

A

0

0

AND

5

0

1

11

OR

5

B

B

11

0

0

0

0

AND

∞

0

5

1

11

0

1

OR

∞

C

4

D

2

C

3

D

∞

∞

1

∞

∞

2

0

2

AND

0

1

3

0

4

1

0

1

3

0

4

1

OR

3

E

4

E

3

E

4

E

f(T’) ≥ UB

∞

3

∞

4

∞

3

∞

4

AND

0

1

0

1

0

1

0

1

AND/OR Branch-and-Bound Search (instead of 2

- Associate each node n with a heuristic lower bound h(n) on v(n)
- EXPAND (top-down)
- Evaluate f(T’) of the current partial solution sub-tree T’, and prune search if f(T’) ≥ UB
- Expand the tip node n by generating its successors

- PROPAGATE (bottom-up)
- Update value of the parent p of n
- OR nodes: minimization
- AND nodes: summation

- Update value of the parent p of n

(Marinescu & Dechter, 2005)

Deep Cutoff (instead of 2

OR

9

A

0

0

h(n) ≤ v(n)

AND

0

1

OR

9

B

0

0

AND

9

0

1

F

F

OR

2

C

4

D

3

3

C

D

h(F) = 5

∞

3

5

2

5

0

0

3

5

0

AND

0

1

0

1

4

0

5

1

0

1

0

OR

Search is here

4

E

5

E

h(D,0) = 4

6

4

8

5

AND

0

1

0

1

f(T’D) = w(D,0) + h(D,0) = 4

f(T’B) = w(B,1) + w(C,0) + w(D,0) + h(D,0) + h(F) = 9

≥ v(B) = 9

f(T’A) = w(A,0) + w(B,1) + w(C,0) + w(D,0) + h(D,0) + h(F) = 12

Heuristics for AND/OR Branch-and-Bound (instead of 2

- In the AND/OR search space h(n) can be computed using any heuristic. We used:
- Static Mini-Bucket heuristics
(Kask & Dechter, AIJ’01), (Marinescu & Dechter, IJCAI’05)

- Dynamic Mini-Bucket heuristics
(Marinescu & Dechter, IJCAI’05)

- Maintaining local consistency
(Larrosa & Schiex, AAAI’03), (de Givry et al., IJCAI’05)

- LP relaxations
(Nemhauser & Wosley, 1998)

- Static Mini-Bucket heuristics

Mini-Bucket Heuristics (instead of 2

- Static Mini-Buckets
- Pre-compiled
- Reduced overhead
- Less accurate
- Static variable ordering

- Dynamic Mini-Buckets
- Computed dynamically
- Higher overhead
- High accuracy
- Dynamic variable ordering

Bucket Elimination (instead of 2

A

hB (A)

B

f(A,B)

A

hC (A,B)

hF (A,B)

B

C

f(B,C)

F

f(B,F)

hD (A,B,C)

hE (B,C)

hG (A,F)

C

F

D

f(A,D) f(B,D) f(C,D)

E

f(B,E) f(C,E)

G

f(A,G) f(F,G)

F

G

D

E

G

A

B

E

h*(a, b, c) = hD(a, b, c) + hE(b, c)

C

D

Ordering: (A, B, C, D, E, F, G)

Static Mini-Bucket Heuristics (instead of 2

MBE(3)

A

hB (A)

A

B

f(A,B)

hC (B)

hF (A,B)

hD (A)

B

C

f(B,C)

F

f(B,F)

hD (B,C)

hE (B,C)

hG (A,F)

C

F

F

D

f(A,D)

D

f(B,D) f(C,D)

E

f(B,E) f(C,E)

G

f(A,G) f(F,G)

G

D

E

G

A

B

mini-buckets

E

h(a, b, c) = hD(a) + hD(b, c) + hE(b, c)

≤ h*(a, b, c)

C

D

Ordering: (A, B, C, D, E, F, G)

Dynamic Mini-Bucket Heuristics (instead of 2

MBE(3)

A

hB ()

A

B

f(a,b)

hC ()

hF ()

B

C

f(b,C)

F

f(b,F)

hD (C)

hE (C)

hG (F)

C

F

F

D

f(a,D) f(b,D) f(C,D)

E

f(b,E) f(C,E)

G

f(a,G) f(F,G)

G

D

E

G

A

B

E

h(a, b, c) = hD(c) + hE(c)

= h*(a, b, c)

C

D

Ordering: (A, B, C, D, E, F, G)

Dynamic Variable Orderings (instead of 2(Marinescu & Dechter, ECAI’06)

- Variable ordering heuristics:
- Semantic-based
- Aim at shrinking the size of the search space based on context and current value assignments
- e.g. min-domain, min-dom/deg, min reduced cost

- Aim at shrinking the size of the search space based on context and current value assignments
- Graph-based
- Aim at maximizing the problem decomposition
- e.g. pseudo-tree

- Aim at maximizing the problem decomposition

- Semantic-based

Orthogonal forces, use one as primary and break ties based on the other

A (instead of 2

C

A

F

B

D

B

E

C

E

D

F

B

A

C

E

D

F

Partial Variable Ordering- Variable Groups/Chains:
- {A,B}
- {C,D}
- {E,F}
- Instantiate {A,B}
- before {C,D} and {E,F}
- *{A,B} is a separator/chain

Primal graph

Variables on chains

in the pseudo tree

can be instantiated

dynamically, based

on some semantic

ordering heuristic

[similar idea is exploited by BTD(Jegou & Terrioux04)]

C (instead of 2

C

F

F

D

D

Full Dynamic Variable OrderingG

E

A

F

A

H

B

C

1

0

D

E

B

domains

DA={0,1}

DB={0,1,2}

DE={0,1,2,3}

1

0

DC=DD=DF=DG=DH=DE

cost functions

B

E

G

G

1

H

H

P2

P1

P2

P1

[similar idea exploited in #SAT (Bayardo & Pehoushek00)]

A (instead of 2

separator

B

CP

C

E

I

G

F

H

D

P1

P2

Dynamic Separator OrderingG

E

A

F

H

B

I

D

C

Primal graph

Constraint Propagation may create singleton

variables in P1 and P2 (changing the problem’s

structure), which in turn may yield smaller separators

[similar idea exploited in SAT (Li & van Beek04)]

Experiments (instead of 2

- Benchmarks
- Belief Networks (BN)
- Weighted CSPs (WCSP)

- Algorithms
- AOBB
- SamIam (BN)
- Superlink (Genetic linkage analysis)
- Toolbar (WCSP)

- Heuristics
- Mini-Bucket heuristics (BN, WCSP)
- EDAC heuristics (WCSP)

L (instead of 212m

L12f

L11m

L11f

X12

X11

S15m

S13m

L13m

L13f

L14m

L14f

X14

X13

S15m

S15m

L15m

L15f

L16m

L16f

S16m

S15m

X15

X16

L22m

L22f

L21m

L21f

X22

X21

S25m

S23m

L23m

L23f

L24m

L24f

X23

X24

S25m

S25m

L25m

L25f

L26m

L26f

S26m

S25m

X25

X26

L32m

L32f

L31m

L31f

X32

X31

S35m

S33m

L33m

L33f

L34m

L34f

X33

X34

S35m

S35m

L35m

L35f

L36m

L36f

S36m

S35m

X35

X36

Pedigree: 6 people, 3 markersGenetic Linkage Analysis (BN) (instead of 2

(Fishelson&Geiger02)

Min-fill pseudo tree. Time limit 3 hours.

Impact of the Pseudo Tree (instead of 2

Runtime distribution for hypergraph pseudo trees over 20 independent runs.

ped30 and ped33 linkage networks.

ISCAS’89 Circuits (WCSP) (instead of 2

(http://graphmod.ics.uci.edu/group/Repository/)

Min-fill pseudo trees. Time limit 1 hour.

EDAC-based solvers were not able to solve any instance.

Static vs. Dynamic Mini-Bucket Heuristics (instead of 2

s1196 ISCAS’89 circuit.

Mastermind Games (WCSP) (instead of 2

(http://graphmod.ics.uci.edu/group/Repository/)

Min-fill pseudo trees. Time limit 1 hour.

EDAC-based solvers were not able to solve any instance.

Impact of the Pseudo Tree (instead of 2

Runtime distribution for hypergraph pseudo trees over 20 independent runs.

spot404 and spot503 Earth observing satellite scheduling instances.

Summary (instead of 2

- New generation of depth-first AND/OR Branch-and-Bound search
- Heuristics based on
- Mini-Bucket approximation (static, dynamic)
- Directional local consistency (EDAC)

- Dynamic variable orderings
- Superior to state-of-the-art solvers traversing the classic OR search space

Outline (instead of 2

- Introduction
- Inference
- Search (OR)
- Lower-bounds and relaxations
- Exploiting problem structure in search
- AND/OR search spaces (tree, graph)
- Searching the AND/OR tree (linear space)
- Searching the AND/OR graph (caching)
- AND/OR Branch-and-Bound search
- Best-First AND/OR search

- Other hybrids of search and inference
- Software & Applications

Graph AND/OR Branch-and-Bound - AOBB(j) (instead of 2(Marinescu & Dechter, AAAI’06)

- Associate each node n with a static heuristic estimate h(n) of v(n)
- h(n) is a lower bound on the value v(n)

- For every node n in the search tree:
- ub(n) – current best solution cost rooted at n
- lb(n) – lower bound on the minimal cost at n

- During search, cache nodes based on context
- maintain cache tables of size O(exp(j)), where j is a bound on the size of the context.

Full Context-based Caching (instead of 2

A

A

context(C) = {C,B,A}

0

1

H

H

H

B

0

1

0

1

C

E

B

B

B

B

D

0

0

0

0

1

1

1

1

F

G

Cache Table (C)

C

C

C

E

C

E

E

C

E

C

E

C

E

E

C

E

0

0

1

1

0

1

0

1

D

D

D

D

D

D

D

D

Space: O(exp(3))

Adaptive Caching (instead of 2

A

A

context(C) = {C,B,A}

1

0

H

H

H

B

0

1

0

1

C

E

B

B

B

B

D

0

0

0

0

1

1

1

1

F

G

C

C

C

E

C

E

E

C

E

C

E

C

E

E

C

E

Cache table on [C,B] only!

0

0

1

1

0

1

0

1

D

D

D

D

D

D

D

D

Reset cache table when A changes its value!

Space: O(exp(2))

A (instead of 2

C

A

F

B

D

B

E

C

E

D

F

Example (graph search)5

OR

A

0

0

AND

5

7

0

1

OR

B

B

5

7

1

4

2

0

AND

6

5

6

4

1

1

0

0

C

C

OR

C

C

3

4

E

E

E

E

4

4

3

2

1

0

4

0

2

2

1

5

3

1

5

2

5

3

3

0

5

3

AND

2

0

5

2

0

2

0

1

0

1

1

0

0

1

0

1

OR

D

D

D

D

2

0

F

F

5

2

0

2

F

F

1

0

2

1

2

2

0

6

1

0

2

4

0

2

4

3

4

5

AND

0

1

0

1

0

0

0

0

Exploiting Constraint Processing in Optimization (instead of 2

- Constraints should be recognized
- Constraint processing should be incorporated into optimization search:
- Constraint propagation in look-ahead
- Back-jumping
- No-good recording

A (instead of 2

F

B

C

E

D

A

B

A

OR

A

0

1

E

C

B

0

1

0

1

D

F

A

A

E

0

0

1

1

0

1

0

1

0

1

0

1

B

B

C

0

0

1

1

0

0

1

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

E

E

D

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

C

C

F

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

D

D

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

F

F

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

AND/OR vs. ORAND

0

1

AND/OR

OR

B

B

AND

0

0

1

1

OR

E

C

E

C

E

C

E

C

AND

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

OR

D

F

D

F

D

F

D

F

D

F

D

F

D

F

D

F

AND

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

OR

A (instead of 2

F

B

C

E

D

A

B

E

C

D

F

(A=1,B=1)

(B=0,C=0)

AND/OR vs. OROR

A

AND/OR

AND

0

1

OR

B

B

AND

0

0

1

OR

E

C

E

C

E

C

AND

0

1

1

0

1

1

0

1

0

1

OR

D

F

D

F

D

F

D

F

AND

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

A

A

A

0

0

0

1

1

1

OR

B

B

B

0

1

0

0

0

1

1

0

0

E

E

E

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

C

C

C

1

1

1

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

1

1

1

1

1

1

D

D

D

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

F

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

OR (instead of 2

A

A

AND

0

1

F

OR

B

B

B

C

AND

0

0

1

OR

E

C

E

C

E

C

E

D

AND

A

0

1

1

0

1

1

0

1

0

1

OR

D

F

D

F

D

F

D

F

B

AND

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

E

C

D

F

A

A

A

0

0

0

1

1

1

OR

B

B

B

0

1

0

0

0

1

1

0

0

E

E

E

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

C

C

C

1

1

1

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

1

1

1

1

1

1

D

D

D

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

0

0

0

1

1

1

(A=1,B=1)

(B=0,C=0)

AND/OR vs. ORAND/OR

Space: linear

Time:

O(exp(m))

O(w* log n)

Linear space,

Time:

O(exp(n))

F

A (instead of 2

>

>

B

C

A

>

>

>

A

D

E

F

B

C

1

2

3

4

>

>

>

>

B

C

B

C

B

B

2

3

4

2

3

4

3

4

3

4

4

G

H

I

K

D

E

D

D

E

F

F

F

D

D

F

F

D

D

E

F

3

4

3

4

4

3

4

4

4

4

G

H

G

I

I

G

K

K

K

G

K

4

4

4

4

G

H

I

K

A

1

2

3

B

C

B

C

B

2

3

2

3

3

3

D

E

D

F

F

D

F

3

3

3

G

H

I

K

4

4

4

4

A

1

B

C

2

2

D

E

F

3

3

3

G

H

I

K

4

4

4

4

The Effect of Constraint PropagationDomains are {1,2,3,4}

CONSTRAINTS ONLY

FORWARD CHECKING

MAINTAINING ARC CONSISTENCY

ISCAS’89 Circuits (instead of 2

Impact of constraint propagation. Min-fill pseudo trees. Time limit 30 minutes.

Outline (instead of 2

- Introduction
- Inference
- Search (OR)
- Lower-bounds and relaxations
- Exploiting problem structure in search
- AND/OR search spaces (tree, graph)
- Searching the AND/OR tree (linear space)
- Searching the AND/OR graph (caching)
- AND/OR Branch-and-Bound search
- Best-First AND/OR search

- Other hybrids of search and inference
- Software & Applications

Best-First Principle (instead of 2

- Best-first search expands first the node with the best heuristic evaluation function among all node encountered so far
- It never expands nodes whose cost is beyond the optimal one, unlike depth-first search algorithms (Dechter & Pearl, 1985)
- Superior among memory intensive algorithms employing the same heuristic function

Best-First AND/OR Search (AOBF) (instead of 2(Marinescu & Dechter, CPAIOR’07, AAAI’07, UAI’07)

- Maintains the set of best partial solution trees
- Top-down Step (EXPAND)
- Traces down marked connectors from root
- i.e., best partial solution tree

- Expands a tip node n by generating its successors n’
- Associate each successor with heuristic estimate h(n’)
- Initialize v(n’) = h(n’)

- Traces down marked connectors from root
- Bottom-up Step (REVISE)
- Updates node values v(n)
- OR nodes: minimization
- AND nodes: summation

- Marks the most promising solution tree from the root
- Label the nodes as SOLVED:
- OR is SOLVED if marked child is SOLVED
- AND is SOLVED if all children are SOLVED

- Updates node values v(n)
- Terminate when root node is SOLVED

(specializes Nilsson’s AO* to solving COP) (Nilsson, 1984)

Cost Revision (instead of 2

1. Best Partial Solution Tree: X, (X,1), A, B, C

v(5)=6

v(5)=5

2. Expand node B: generate (B,0) and (B,1)

X

0

1

v(B) = min(w(B,0) + h(B,0),

w(B,1) + h(B,1))

= min(3,2) = 2

-> mark (B,1) best successor of B

0

1

v(X,0)=8

v(X,1)=4

v(X,1)=5

A

B

C

v(A)=2

v(B)=1

v(C)=1

v(B)=2

v(X,1) = v(A) + v(B) + h(C)

= 2+2+1=5

0

1

h(B,0)=3

1

h(B,1)=1

0

v(X) = min(w(X,0) + v(x,0),

w(X,1) + v(X,1))

= min(8,6) = 6

-> mark (X,1) best successor of X

AOBF versus AOBB (instead of 2

- AOBF with the same heuristic as AOBB is likely to expand the smallest search space
- AOBB improves its heuristic function dynamically, whereas AOBF uses only h(n)
- AOBB can use far less memory by avoiding for example dead-caches, whereas AOBF keeps in memory the explicated search graph
- AOBB is any-time, whereas AOBF is not

Heuristics (instead of 2

- AOBF can be guided by:
- Static Mini-Bucket heuristics
(Kask & Dechter, AIJ’01), (Marinescu & Dechter, IJCAI’05)

- Dynamic Mini-Bucket heuristics
(Marinescu & Dechter, IJCAI’05)

- LP Relaxations
(Nemhauser & Wosley, 1988)

- Static Mini-Bucket heuristics

Experiments (instead of 2

- Benchmarks
- Belief Networks (BN)
- Weighted CSPs (WCSP)

- Algorithms
- AOBB-C – AND/OR Branch-and-Bound
- AOBF-C – Best-first AND/OR Search
- SamIam (BN)
- Superlink (linkage)
- Toolbar, Toolbar-BTD (WCSP)

- Heuristics
- Mini-Bucket heuristics

Impact of the Pseudo Trees (instead of 2

Runtime distribution for hypergraph pseudo trees over 20 independent runs.

90-24-1 grid instance.

Naïve versus Adaptive Caching (instead of 2

Genetic Linkage Analysis (BN) (instead of 2

(Fishelson & Geiger02)

Min-fill pseudo tree. Time limit 3 hours.

Impact of the Pseudo Trees (instead of 2

Runtime distribution for hypergraph pseudo trees over 20 independent runs.

ped30 linkage instance.

ISCAS’89 Benchmark (WCSP) (instead of 2

Min-fill pseudo tree. Time limit 1 hour.

Mastermind Games (WCSP) (instead of 2

Min-fill pseudo trees. Time limit 1 hour.

toolbar, toolbar-BTD were not able to solve any instance.

Summary (instead of 2

- New memory intensive AND/OR search algorithms for optimization in graphical models
- Depth-first and best-first control strategies
- Mini-bucket heuristics effective at relatively large i-bounds
- Pseudo tree quality impacts search performance dramatically
- Superior to state-of-the-art OR and AND/OR Branch-and-Bound tree search algorithms

0-1 Integer Linear Programming (instead of 2

- Applications:
- VLSI circuit design
- Scheduling
- Routing
- Combinatorial auctions
- Facility location
- …

C

A

F

D

B

E

primal graph

A (instead of 2

C

A

F

B

D

B

E

C

E

D

F

AND/OR Search TreePrimal graph

Pseudo tree

A

OR

AND

0

1

B

B

OR

AND

0

1

0

1

C

C

C

C

E

E

E

E

OR

AND

0

1

0

1

0

1

0

1

0

1

0

1

0

1

0

1

D

D

D

D

F

F

F

F

F

F

F

OR

1

0

1

0

1

0

1

0

1

0

1

1

0

0

1

0

1

0

1

AND

A (instead of 2

C

A

F

B

D

B

E

C

E

D

F

Weighted AND/OR Search TreeOR

w(A,0) = 0

w(A,1) = 7

A

AND

0

1

OR

B

AND

-1 = (5-6)

Node Value

(bottom up)

OR – minimization

AND – summation

0

1

OR

-6 = min(0,-6)

5 = min(5,)

C

E

0

0

-6

AND

5

0

0

1

0

1

OR

0 = min(0,8)

5

D

F

8

0

5

AND

1

0

1

A (instead of 2

C

A

F

B

D

B

E

C

E

D

F

AND/OR Search GraphA

OR

AND

0

1

B

B

OR

AND

1

1

0

0

C

E

C

E

C

E

C

E

OR

AND

0

0

0

1

0

1

[A]

OR

D

D

F

F

F

F

[BA]

AND

0

1

0

1

[EA]

[CB]

[D]

[F]

16 nodes (graph) vs. 54 nodes (tree)

Experiments (instead of 2

- Algorithms
- AOBB, AOBF – tree search
- AOBB+PVO, AOBF+PVO – tree search
- AOBB-C, AOBF-C – graph search
- lp_solve 5.5
- CPLEX 11.0

- Benchmarks
- Combinatorial auctions
- Uncapacitated warehouse location problems
- MAX-SAT instances

- Implementation
- LP relaxation solved by lp_solve 5.5 library
- BB (lp_solve) baseline solver

Combinatorial Auctions (instead of 2

Combinatorial auctions from regions-upv distribution with

100 goods and increasing number of bids. Time limit 1 hour.

Very large treewidth [68, 184]

Combinatorial Auctions (instead of 2

Combinatorial auctions from regions-upv distribution with

100 goods and increasing number of bids. Time limit 1 hour.

Very large treewidth [68, 184]

UWLP Instances (instead of 2

Tree search

Graph search

Tree search

UWLP instances with 50 warehouses, 200 and 400 locations. Time limit 10 hours.

MAX-SAT Instances (pret) (instead of 2

Tree search

Graph search

Tree search

pret MAX-SAT instances. Time limit 10 hours.

BB solver could not solve any instance.

MAX-SAT Instances (dubois) (instead of 2

dubois MAX-SAT instances. Time limit 3 hours. w*=6, h=20.

CPLEX, BB solvers could not solve any instance.

Summary (instead of 2

- New AND/OR search algorithms for 0-1 Integer Programming
- Dynamic variable orderings
- Superior to baseline OR Branch-and-Bound from the lp_solve library
- Competitive with state-of-the-art CPLEX in terms of search space explored
- Outperform CPLEX on selected MAX-SAT instances (e.g., pret, dubois)

Outline (instead of 2

- Introduction
- Inference
- Search (OR)
- Lower-bounds and relaxations
- Exploiting problem structure in search
- Other hybrids of search and inference
- Cutset decomposition
- Boosting search with VE
- Super-Bucket scheme

- Software & Applications

Solution Techniques (instead of 2

Time: exp(n)

Space: linear

Search: Conditioning

Incomplete

Simulated Annealing

Complete

Gradient Descent

Time: exp(w*)

Space: exp(w*)

Depth-first search

Branch-and-Bound

A* search

Incomplete

Hybrids:

Local Consistency

Complete

Unit Resolution

mini-bucket(i)

Adaptive Consistency

Tree Clustering

Dynamic Programming

Resolution

Inference: Elimination

Solution Techniques (instead of 2

AND/OR tree search

Time: exp(w* log n)

Space: linear

Search: Conditioning

Incomplete

Simulated Annealing

Complete

Gradient Descent

Time: exp(w*)

Space:exp(w*)

Depth-first search

Branch-and-Bound

A* search

Incomplete

Hybrids:

Local Consistency

Complete

Unit Resolution

mini-bucket(i)

Adaptive Consistency

Tree Clustering

Dynamic Programming

Resolution

Inference: Elimination

AND/OR Graph search

Solution Techniques (instead of 2

AND/OR tree search

Time: exp(w* log n)

Space: linear

Search: Conditioning

Incomplete

Simulated Annealing

Complete

Gradient Descent

Time: exp(w*)

Space:exp(w*)

Depth-first search

Branch-and-Bound

A* search

Hybrids:

AND-OR(j)

Incomplete

Space: exp(j)

Time: exp(mj)

Local Consistency

Complete

Unit Resolution

mini-bucket(i)

Adaptive Consistency

Tree Clustering

Dynamic Programming

Resolution

Inference: Elimination

AND/OR Graph search

Search Basic Step: Conditioning (instead of 2

X1

X2

X3

X4

X5

…...

X1 a

X1 c

X1 b

X2

X2

X2

X3

X3

X3

…...

X4

X5

X4

X5

X4

X5

Search Basic Step: (instead of 2Variable Branching by Conditioning

General principle:

Condition until tractable

Then solve sub-problems

efficiently

X1

X2

X3

X4

X5

…...

X1 a

X1 c

X1 b

X2

X2

X2

X3

X3

X3

…...

X4

X5

X4

X5

X4

X5

Search Basic Step: (instead of 2Variable Branching by Conditioning

X1

X2

Example: solve subproblem by inference, BE(i=2)

X3

X4

X5

…...

X1 a

X1 c

X1 b

X2

X2

X2

X3

X3

X3

…...

X4

X5

X4

X5

X4

X5

The Cycle-Cutset Scheme: (instead of 2Condition Until Treeness

- Cycle-cutset
- i-cutset
- C(i)-size of i-cutset

Space: exp(i), Time: O(exp(i+c(i))

Eliminate First (instead of 2

Eliminate First (instead of 2

Hybrids Variants (instead of 2

- Condition, condition, condition … and then only eliminate (w-cutset, cycle-cutset)
- Eliminate, eliminate, eliminate … and then only search
- Interleave conditioning and elimination (elim-cond(i), VE+C)

Interleaving Conditioning and Elimination (instead of 2(Larrosa & Dechter, CP’02)

Interleaving Conditioning and Elimination (instead of 2

Interleaving Conditioning and Elimination (instead of 2

Interleaving Conditioning and Elimination (instead of 2

Interleaving Conditioning and Elimination (instead of 2

Interleaving Conditioning and Elimination (instead of 2

Time-space Tradeoffs (instead of 2

- AO(j): DFS search of AO, caches j-context
- j = max number of variables in a context

- AO j-cutset
- Elimination-conditioning(j)

j=0

j=w*

j

Space: O(exp w*)

Time: O(exp w*)

Space: O(n)

Time: O(exp(w* log n))

Space: O(exp(j) )

Time: O(exp(m(j)+j )

m(j) - AO depth of w-cutset

Time vs. Space for w-cutset (instead of 2

Random Graphs (50 nodes, 200 edges, average degree 8, w*23)

60

Branch and bound

50

40

Bucket

elimination

W+c(w)

30

20

time

10

0

2

5

8

-1

11

14

17

20

23

26

29

32

space

w

E (instead of 2

E

E

E

D

D

D

D

M

M

M

M

C

C

C

A

L

L

L

L

B

B

K

K

K

H

H

H

H

F

F

F

F

G

G

G

J

J

J

J

A

A

A

A

B

K

B

K

B

K

B

K

C

G

L

C

G

L

C

G

L

C

G

L

D

F

M

D

F

M

D

F

M

D

F

M

E

H

E

H

E

H

E

H

J

J

J

J

1-cutset

3-cutset

2-cutset

AND/OR i-cutsetSummary: Hybrid Time/Space in Variable-models (instead of 2

- Cutset schemes
- i-cutset
- Condition-elim(i)
- AO(i)

- Super-bucket(i)
- AO(i) avoids some dead-caches

- Combine:
- i-cutset in an i super-bucket…

Algorithms for AND/OR Space (instead of 2

- Back-jumpingfor CSPs
(Gaschnig 1977), (Dechter 1990), (Prosser, Bayardo & Mirankar, 1995)

- Pseudo-search re-arrangement, for any CSP task
(Freuder & Quinn 1985)

- Recursive Conditioning
(Darwiche, 2001), explores the AND/OR tree or graph for any query

- BTD: Searching tree-decompositions for optimization
(Jeagou & Terrioux, 2000)

- Pseudo-tree search for soft constraints
(Larrosa, Meseguer & Sanchez, 2002)

- Valued-elimination
(Bacchus, Dalmao & Pittasi, 2003)

- Arc-consistency for soft constraints
(Larrosa & Schiex, 2003)

Conclusions (instead of 2

- Only a few principles:
- Inference and search should be combined time-space
- AND/OR search should be used
- Heuristics using approximation of inference (mini-bucket, GBP)
- Caching in search should be used

Outline (instead of 2

- Introduction
- Inference
- Search (OR)
- Lower-bounds and relaxations
- Exploiting problem structure in search
- Other hybrids of search and inference
- Software & Applications
- aolib, toulbar2 and other related software packages
- Pedigree analysis, CELAR, SPOT5
- Results from UAI-06, CP-06 and UAI-08 solver competitions

Software (instead of 2

- Reports on competitions
- UAI’06 Inference Evaluation
- 57 MPE instances

- CP’06 Competition
- 686 2-ary MAX-CSP instances
- 135 n-ary MAX-CSP instances

- UAI’06 Inference Evaluation
- How to use the software
- http://csp.ics.uci.edu/group/Software

UAI’06 Inference Evaluation (instead of 2

- MPE solver – AOMB(i, j)
- Node value v(n): most probable explanation of the sub-problem rooted by n
- Caching: identical sub-problems rooted at AND nodes (identified by their contexts) are solved once and the results cached
- j-bound (context size) controls the memory used for caching

- Heuristics: pruning is based on heuristics estimates which are pre-computed by bounded inference (i.e. mini-bucket approximation)
- i-bound (mini-bucket size) controls the accuracy of the heuristic

- No constraint propagation

UAI’06 Competitors (instead of 2

- Team 1
- UCLA
- David Allen, Mark Chavira, Arthur Choi, Adnan Darwiche

- UCLA
- Team 2
- IET
- Masami Takikawa, Hans Dettmar, Francis Fung, Rick Kissh

- IET
- Team 5 (ours)
- UCI
- Radu Marinescu, Robert Mateescu, Rina Dechter

- UCI

UAI’06 Results (instead of 2

MPE Failure Rate Results

UAI’06 Results (instead of 2

Rank Proportions (how often was each team a particular rank, rank 1 is best)

CP’06 Competition (instead of 2

- MAX-CSP solver
- AND/OR Branch-and-Bound tree search with EDAC heuristics and dynamic variable orderings
- aolibdvo v. 0.5
- AOBB + EDAC + DVO (dynamic variable ordering)

- aolibpvo v. 0.5
- AOBB + EDAC + PVO (partial variable ordering)

- aolibdvo v. 0.5
- No constraint propagation

- AND/OR Branch-and-Bound tree search with EDAC heuristics and dynamic variable orderings

CP’06 Competitors (instead of 2

- Solvers
- AbsconMax
- aolibdvo (ours)
- aolibpvo (ours)
- CSP4J-MaxCSP
- Toolbar
- Toolbar_BTD
- Toolbar_MaxSAT
- Toulbar2

CP’06 Results (instead of 2

Overall ranking on all selected competition benchmarks

4

5

2

1

3

The longest dark green bar wins

Outline/Summary (instead of 2

- Introduction
- Graphical models
- Optimization tasks for graphical models
- Fundamental operations on cost functions

- Inference
- Bucket Elimination, Bucket-Tree and Cluster-Tree Elimination
- Polynomial classes based on structure

- Search (OR)
- Branch-and-Bound and Best-First Search
- Local search and Partial search

- Lower-bounds and relaxations
- Bounded inference, local consistency and continuous relaxations

- Exploiting problem structure in search
- AND/OR search spaces (trees, graphs)

- Other hybrids of search and inference
- Cutset decomposition, boosting search with VE, super-bucket scheme

- Software & Applications

Download Presentation

Connecting to Server..