CMU-Q Lecture 8: Optimization I: Optimization for CSP Local Search. Teacher: Gianni A. Di Caro

Transcription

1 CMU-Q Lecture 8: Optimization I: Optimization for CSP Local Search Teacher: Gianni A. Di Caro

2 LOCAL SEARCH FOR CSP Real-life CSPs can be very large and hard to solve Methods so far: construct a solution by assigning one variable at-atime, if an assignment fails because of constraint violation, backtrack, and keep doing until all variables have been assigned feasible values At any point of the construction process we have one partial solution (partial assignment of values to variables) The states of the process are partial states of the problem 2

3 LOCAL SEARCH FOR CSP Local search methods: work with complete states (i.e., all variables assigned, it can be an unfeasible assignment) 1. Start with some unfeasible assignment (i.e., featuring n constraint violations) 2. LS operators reassign variable values (one or more at each search step) A. Variable selection (e.g., randomly select any variable involved in constraints violation) B. Values selection (e.g., min-conflicts heuristic h, to choose a value such that the new CSP assignment violates the fewest constraints) 3. Iterate 2 (A-B) until a feasible solution is found or only a few constraint violations survive or 3

4 LOCAL SEARCH FOR CSP Neighbor states (one color change) 4

5 EXAMPLE N-QUEENS States: 4 queens in 4 columns (44 = 256 states) LS Operator: move queen in column Goal test: no attacks Evaluation: h = number of attacks 5

6 LOCAL SEARCH Local search algorithms at each step consider a single current state, and try to improve it by moving to one of its neighbors Iterative improvement algorithms Pros and cons o No complete (no optimal), except with random restarts o Space complexity O(b) o Time complexity O(d), d can be! o Can perform well also in large (infinite, continuous) spaces o Relatively easy to implement 6

7 HILL-CLIMBING SEARCH Like climbing Everest in thick fog with amnesia Move in the direction of strictly increasing value (up to the hill) Steepest ascent / Steepest descent Terminate when no neighbor has higher value Greedy (myopic) local search We necessarily end into a local optimum or a plateau Which optimum: depends on the starting point 7

8 HILL-CLIMBING SEARCH State with 17 conflicts, showing the #conflicts by moving a queen within its column, with best moves in red Local optimum: state that has only one conflict, but every move leads to larger #conflicts 8

9 HILL-CLIMBING SEARCH Hill-climbing can solve large instances of n-queens (n = 10 6 ) in a few seconds 8 queens statistics: o State space of size 17 million o Starting from random state, steepest-ascent hill climbing solves 14% of problem instances o It takes 4 steps on average when it succeeds, 3 when it gets stuck o When sideways moves are allowed, things change o When multiple restarts are allowed, things change even more 9

10 HILL-CLIMBING CAN GET STUCK! Objective function global maximum Plateaux shoulder Local optima flat local maximum current state neighborhood state space 10

11 VARIANTS OF HILL-CLIMBING Sideways moves: if no uphill moves, allow moving to a state with the same value as the current one (escape shoulders) Objective function global maximum shoulder Plateaux Local optima sideways moves (M): M=100 94% solved instances for the 8-queens! 21 steps avg. on success 64 steps avg. on failure flat local maximum current state neighborhood state space 11

12 VARIANTS OF HILL-CLIMBING Sideways moves: if no uphill moves, allow moving to a state with the same value as the current one (escape shoulders) Stochastic hill-climbing: selection among the available uphill moves is done randomly (uniform, proportional, soft-max, ε- greedy, ) to be less greedy First-choice hill-climbing: successors are generated randomly, one at a time, until one that is better than the current state is found (deal with large neighborhoods) Random-restart hill climbing: probabilistically complete (how do we select the next restart configuration?) In general, these variants apply to all Local Search algorithms 12

13 HILL-CLIMBING CAN GET STUCK! Diagonal ridges: From each local maximum all the available actions point downhill, but there is an uphill path! Zig-zag motion, very long ascent time! Gradient ascent doesn t have this issue: all state vector components are (potentially) changed when moving to a successor state, climbing can follow the direction of the ridge 13

14 LOCAL SEARCH + MIN-CONFLICTS HEURISTIC min-conflicts heuristic h chooses a value such that the new CSP assignment violates the fewest constraints Given a random initial state, can solve n-queens in almost constant time for very large n The same appears to be true for any randomly-generated CSP except in a narrow range of the ratio: 14

15 WALKSAT: LS FOR SAT Binary literals (true / false) Clause: disjunction of literals Conjunctive Normal Form (CNF) for a logical Formula: Conjunction of clauses 3-SAT (all clauses have 3 literals) 15

16 WALKSAT: LS FOR SAT Random 3-SAT o sample uniformly from space of all possible 3- clauses o n variables, C clauses Which are the hard instances? o around ' ( =

17 WALKSAT: LS FOR SAT n Complexity peak is very stable q q across problem sizes across solver types n n systematic stochastic 17

18 WALKSAT: LS FOR MAX-SAT At each step, the randomly chosen clause is satisfied, but other clauses may become unsatisfied The parameter p is called the "mixing probability" and determined approximately by experiment for a given class of CNF formulas For random, hard 3-SAT problems (those with the ratio of clauses to variables around 4.25) p = 0.5 works well For 3-SAT formulas with more structure, as generated in many applications, slightly more greediness, i.e. p < 0.5, is often better Empirically, restarting after O(n 4 ) flips, n = number of variables, works well 18

19 GENERAL LOCAL SEARCH OPTIMIZER Function Search by Iterative Solution Modification() = instance of optimization problem of class S = {set of all feasible solutions of } N = neighborhood structure for, can be variable in,t,m eval() = evaluation function for candidate solutions in N t = iteration, time t = search state at time t, current feasible solution m t = memory structure of search states and values t 0 0 m 0 ; 0 initial feasible solution(,s) while terminate( t,, N( t, ), t,...) ( 0,m t ) step(n( t, ), m t, eval()) if accept( 0, t,t,m t ) t+1 0 m t+1 update solution best value(, t+1,t) t t +1 if at least one feasible solution has been generated(m t,s) return best solution found(m) else return No feasible solution found! We only need to be able to compute the function No derivatives, analytical properties are needed 19