Local Search & CSP

1. Homework 2 socket opened

2. How is project going?

3. No class on Monday

RIP Alex: http://youtube.com/watch?v=sYk-wE18BTo

Search when states are factored

• Until now, we assumed states are black-boxes.

• We will now assume that states are made up of “state-variables” and their “values”

• Two interesting problem classes– CSP & SAT (Constraint Satisfaction

Problems)– Planning

December 2, 1998 Sqalli, Tutorial on Constraint Satisfaction Problems

3

Constraint Satisfaction Problems (a brief animated overview)

ValuesValues

ConstraintsConstraints

Problem Problem StatementStatement

VariablesVariables

CSP CSP AlgorithmAlgorithm SolutionSolution

XX

ZZYY

Coloring Coloring ProblemProblem

CSP RepresentationCSP Representation

• Search Search backtracking, backtracking, variable/value variable/value heuristicsheuristics

•InferenceInference Consistency Consistency enforcement, enforcement, forward checkingforward checking

X: redX: red

Y: blueY: blue

Z: greenZ: green

Redgreenblue

Redgreenblue

Redgreenblue

ZZ

XX

YYConstraint Graph

Other examples of CSP problems..

• Most assignment problems including– Time-tabling

• Variables: Courses; Values: Rooms, times

– Jobshop Scheduling• Variables: jobs; values: machines

• Sudoku

• Cross-word puzzle

• Boolean satisfiability

General Search vs. CSP• Blackbox State• External Child-generator• State-space can be infinite• External goal test• Goals can occur at any depth• Goals can have different costs• All the search algorithms we

discussed until now are appropriate.

• Heuristics are aimed at estimating the cost to goal node..

• State is made-up of state variables• Children generation involves

assigning values to more variables• State space is finite • A state is a goal state if all

variables are assigned and no constraints are violated

• All goals occur at the same depth• In the basic formulation, all goals

have the same cost– This can be generalized

• Only the Depth-first search makes sense!

• Heuristics are aimed at picking the right variable to assign next, and deciding the right value to assign to it.

Complexity of CSP..

• Boolean Satisfiability is a special case of discrete variable CSP problem– So, CSP is NP-hard

• Specific types of CSP may be tractable.– E.g. if all the variables are boolean and all the

constraints are binary, you have 2-SAT which is tractable.

– The topology of the “constraint graph” also affects the complexity of the CSP problem

• E.g. If the constraint graph is a chain graph or a multi-tree, we can solve it polynomially

Redgreenblue

Redgreenblue

Redgreenblue

Redgreenblue

Redgreenblue

Redgreenblue

ZZ

XX

YY ZZ

XX

YY ZZ

XX

YYConstraint Graph

Redgreenblue

Redgreenblue

Redgreenblue

Redgreenblue

Redgreenblue

Redgreenblue

ZZ

XX

YY ZZ

XX

YY ZZ

XX

YYConstraint Graph

Review of CSP/SAT concepts• Constraint Satisfaction Problem (CSP)

– Given

• A set of variables– (Normally, discrete—but can be

continuous)

• Legal domains for each of the variables

• A set of constraints on values groups of variables can take

– Constraints can be “Unary”, “binary” or “multi-ary” based on how many variables they connect

– Find an assignment of values to all the variables so that none of the constraints are violated

• SAT Problem = CSP with boolean variables

x,y,u,v: {A,B,C,D,E}w: {D,E} l : {A,B}x=A wEy=B uDu=C lAv=D lB

N1: {x=A}

N2: {x=A & y =B }

N3: {x=A & y =B & v = D }

N4: {x=A & y =B & v = D & u = C }

N5: {x=A & y =B & v = D & u = C & w= E }

N6: {x=A & y =B & v = D & u = C & w= D }

x A

yB

vD

wEwD

uC

A solution:x=B, y=C, u=D, v=E, w=D, l=B

“Most Constrained Variable First”“Least-constraining Value First”

yn

nn

y

n

nn

y

Dynamic variable ordering: Pick the variable with the smallest “live” (remaining) domain next.

9/19

Just another day in the university..

“Electric Justice: US-Style”

Constraint Graphs will be hyper-graphs for non-binary CSPs

Things discussed on board• If the constraint graph is disconnected, then you essentially have independent

subproblems. – For example, suppose you mixed up a coloring problem CSP with a queens problm CSP

• You are better off solving them separately and concatenating the results• You may ask “Why should I solve them separately? Can’t my search algorithm find

the independence itself?– The answer is that normal search algorithms that do chronological backtracking are unable

to recognize and exploit problem independence dynamically. – You need “dependency directed backtracking”

• Another question is how to do constraint graphs when you have non-binary (ternary etc.) constraints

– When you have n-ary (n>2) constraints, your constraint graph is a hyper graph (with edges connecting a set rather than a pair of vertices)

– It is possible to convert every non-binary CSP into a binary CSP (by introducing new variables. If there is a constraint between X, Y, and Z, I can introduce a super variable called x-y and make a binary constraint between it and Z)

• Of course, when you do this, the resulting constraints may not be natural for someone who knows the domain

– Just as an assembly language program may not make as much sense to a domain expert as does a high-level language program

• Binary CSPs and Boolean CSPs are canonical classes of CSP in that any arbitrary CSP can be “compiled down” to an equivalent binary or boolean CSP

Not enough to show the correct configuration of the 18-puzzle problem or rubik’s cube.. (although by including the list of actions as part of the state, you can support hill-climbing)

What is needed: --A neighborhood function The larger the neighborhood you consider, the less myopic the search (but the more costly each iteration) --A “goodness” function needs to give a value to non-solution configurations too for 8 queens: (-ve) of number of pair-wise conflicts

A greedier version of the above: For each variable v, let l(v) be the value that it can take so that the number of conflicts are minimized. Let n(v) be the number of conflicts with this value. --Pick the variable v with the lowest n(v) value. --Assign it the value l(v)

I pointed out thatThe neighborhood1 is subsumed byNeighborhood 2

2

1

This one basically searches the 1-neighborhood of the current assignment(where k-neighborhood is all assignments that differ from the current assignment in atmostk-variable values)

Applying min-conflicts based hill-climbing to 8-puzzle

Local Minima

Understand the tradeoffs in defining smaller vs. larger neighborhood

Problematic scenarios for hill-climbing

When the state-space landscape has local minima, any search that moves only in the greedy direction cannot be (asymptotically) complete

Random walk, on the other hand, is asymptotically complete

Idea: Put random walk into greedy hill-climbing

Ridges

Solution(s): Random restart hill-climbing Do the non-greedy thing with some probability p>0 Use simulated annealing

Ideas for improving convergence: -- Random restart hill-climbing After every N iterations, start with a completely random assignment --Probabilistic greedy -with probability p do what the greedy strategy suggests -with probability (1-p) pick a random variable and change its value randomly -- p can increase as the search progresses

A greedier version of the above: For each variable v, let l(v) be the value that it can take so that the number of conflicts are minimized. Let n(v) be the number of conflicts with this value. --Pick the variable v with the lowest n(v) value. --Assign it the value l(v)

I pointed out thatThe neighborhood1 is subsumed byNeighborhood 2

2

1

This one basically searches the 1-neighborhood of the current assignment(where k-neighborhood is all assignments that differ from the current assignment in atmostk-variable values)

Making Hill-Climbing Asymptotically Complete

• Random restart hill-climbing– Keep some bound B. When you made more than B moves, reset

the search with a new random initial seed. Start again. • Getting random new seed in an implicit search space is non-trivial!

– In 8-puzzle, if you generate a random state by making random moves from current state, you are still not truly random (as you will continue to be in one of the two components)

• “biased random walk”: Avoid being greedy when choosing the seed for next iteration – With probability p, choose the best child; but with probability (1-

p) choose one of the children randomly• Use simulated annealing

– Similar to the previous idea—the probability p itself is increased asymptotically to one (so you are more likely to tolerate a non-greedy move in the beginning than towards the end)

With random restart or the biased random walk strategies, we can solve very large problems million queen problems in under minutes!

#clauses / # Variables

3-SAT P

hase T

ransit

ion

~4.3

--didn’t discuss the remaining slides--

The middle ground between hill-climbing and systematic search

• Hill-climbing has a lot of freedom in deciding which node to expand next. But it is incomplete even for finite search spaces.– Good for problems which have solutions, but the solutions are

non-uniformly clustered. • Systematic search is complete (because its search tree keeps

track of the parts of the space that have been visited). – Good for problems where solutions may not exist,

• Or the whole point is to show that there are no solutions (e.g. propositional entailment problem to be discussed later).

– or the state-space is densely connected (making repeated exploration of states a big issue). Smart idea: Try the middle ground between the two?

Between Hill-climbing and systematic search

• You can reduce the freedom of hill-climbing search to make it more complete– Tabu search

• You can increase the freedom of systematic search to make it more flexible in following local gradients– Random restart search

Random restart search

Variant of depth-first search where

• When a node is expanded, its children are first randomly permuted before being introduced into the open list– The permutation may

well be a “biased” random permutation

• Search is “restarted” from scratch anytime a “cutoff” parameter is exceeded– There is a “Cutoff”

(which may be in terms of # of backtracks, #of nodes expanded or amount of time elapsed)

•Because of the “random” permutation, every time the search is restarted, you are likely to follow different paths through the search tree. This allows you to recover from the bad initial moves.

•The higher the cutoff value the lower the amount of restarts (and thus the lower the “freedom” to explore different paths).

•When cutoff is infinity, random restart search is just normal depth-first search—it will be systematic and complete•For smaller values of cutoffs, the search has higher freedom, but no guarantee of completeness

•A strategy to guarantee asymptotic completeness:

•Start with a low cutoff value, but keep increasing it as time goes on.

•Random restart search has been shown to be very good for problems that have a reasonable percentage of “easy to find” solutions (such problems are said to exhibit “heavy-tail” phenomenon). Many real-world problems have this property.