Scribd Logo
Upload

Welcome to Scribd!

  • 62 views

    Sp14 Cs188 Lecture 5 - Csps II

    Uploaded by

    imoptra143
    This document summarizes a lecture on constraint satisfaction problems (CSPs) given by professors Dan Klein and Pieter Abbeel at UC Berkeley. It discusses efficient solution methods for CSPs like backtracking search, filtering techniques like arc consistency to detect failures earlier, and exploiting problem structure. It also covers local search methods like hill climbing, simulated annealing, and genetic algorithms as incomplete but often faster alternatives to backtracking search.

    Copyright:

    © All Rights Reserved
    Download as PPTX, PDF, TXT or read online from Scribd

    Sp14 Cs188 Lecture 5 - Csps II

    Uploaded by

    imoptra143
    62 views38 pages
    This document summarizes a lecture on constraint satisfaction problems (CSPs) given by professors Dan Klein and Pieter Abbeel at UC Berkeley. It discusses efficient solution methods for CSPs like backtracking search, filtering techniques like arc consistency to detect failures earlier, and exploiting problem structure. It also covers local search methods like hill climbing, simulated annealing, and genetic algorithms as incomplete but often faster alternatives to backtracking search.

    Original Description:

    Sp14 Cs188 Lecture 5 -- Csps II

    Original Title

    Sp14 Cs188 Lecture 5 -- Csps II

    Copyright

    © © All Rights Reserved

    Available Formats

    PPTX, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    This document summarizes a lecture on constraint satisfaction problems (CSPs) given by professors Dan Klein and Pieter Abbeel at UC Berkeley. It discusses efficient solution methods for CSPs like backtracking search, filtering techniques like arc consistency to detect failures earlier, and exploiting problem structure. It also covers local search methods like hill climbing, simulated annealing, and genetic algorithms as incomplete but often faster alternatives to backtracking search.

    Copyright:

    © All Rights Reserved
    Download as PPTX, PDF, TXT or read online from Scribd
    Download as pptx, pdf, or txt
    62 views38 pages

    Sp14 Cs188 Lecture 5 - Csps II

    Uploaded by

    imoptra143
    This document summarizes a lecture on constraint satisfaction problems (CSPs) given by professors Dan Klein and Pieter Abbeel at UC Berkeley. It discusses efficient solution methods for CSPs like backtracking search, filtering techniques like arc consistency to detect failures earlier, and exploiting problem structure. It also covers local search methods like hill climbing, simulated annealing, and genetic algorithms as incomplete but often faster alternatives to backtracking search.

    Copyright:

    © All Rights Reserved
    Download as PPTX, PDF, TXT or read online from Scribd
    Download as pptx, pdf, or txt
    of 38

    CS 188: Artificial Intelligence

    Constraint Satisfaction Problems II


    Instructors: Dan Klein and Pieter Abbeel
    University of California, Berkeley

    [These slides were created by Dan Klein and Pieter Abbeel for CS188 Intro to AI at UC Berkeley. All CS188 materials are available at

    Today
    Efficient Solution of CSPs
    Local Search

    Reminder: CSPs
    CSPs:

    Variables
    Domains
    Constraints

    Implicit (provide code to


    compute)
    Explicit (provide a list of the legal
    tuples)
    Unary / Binary / N-ary

    Goals:

    Here: find any solution


    Also: find all, find best, etc.

    Backtracking Search

    Improving Backtracking
    General-purpose ideas give huge gains in speed
    but its all still NP-hard

    Filtering: Can we detect inevitable failure early?


    Ordering:
    Which variable should be assigned next? (MRV)
    In what order should its values be tried? (LCV)

    Structure: Can we exploit the problem structure?

    Arc Consistency and Beyond

    Arc Consistency of an Entire CSP


    A simple form of propagation makes sure all arcs are simultaneously
    consistent:
    NT
    WA

    SA

    Q
    NSW

    Remember:
    Arc consistency detects failure earlier than forward checking
    Delete from
    the tail!
    Important: If X loses a value, neighbors of X need to be rechecked!

    Must rerun after each assignment!

    Limitations of Arc Consistency


    After enforcing arc
    consistency:
    Can have one solution
    left
    Can have multiple
    solutions left
    Can have no solutions left
    (and not know it)

    Arc consistency still

    What went
    wrong here?

    K-Consistency

    K-Consistency
    Increasing degrees of consistency
    1-Consistency (Node Consistency): Each single nodes
    domain has a value which meets that nodes unary
    constraints
    2-Consistency (Arc Consistency): For each pair of nodes,
    any consistent assignment to one can be extended to
    the other
    K-Consistency: For each k nodes, any consistent
    assignment to k-1 can be extended to the kth node.

    Higher k more expensive to compute

    Strong K-Consistency
    Strong k-consistency: also k-1, k-2, 1 consistent
    Claim: strong n-consistency means we can solve without
    backtracking!
    Why?

    Choose any assignment to any variable


    Choose a new variable
    By 2-consistency, there is a choice consistent with the first
    Choose a new variable
    By 3-consistency, there is a choice consistent with the first 2

    Lots of middle ground between arc consistency and n-consistency!


    (e.g. k=3, called path consistency)

    Structure

    Problem Structure
    Extreme case: independent subproblems

    Example: Tasmania and mainland do not interact

    Independent subproblems are identifiable


    as connected components of constraint
    graph
    Suppose a graph of n variables can be
    broken into subproblems of only c
    variables:

    Worst-case solution cost is O((n/c)(dc)), linear in


    n
    E.g., n = 80, d = 2, c =20
    280 = 4 billion years at 10 million nodes/sec
    (4)(220) = 0.4 seconds at 10 million nodes/sec

    Tree-Structured CSPs

    Theorem: if the constraint graph has no loops, the CSP can be solved
    in O(n d2) time
    Compare to general CSPs, where worst-case time is O(d n)

    This property also applies to probabilistic reasoning (later): an


    example of the relation between syntactic restrictions and the
    complexity of reasoning

    Tree-Structured CSPs
    Algorithm for tree-structured CSPs:

    Order: Choose a root variable, order variables so that parents


    precede children

    Remove backward: For i = n : 2, apply


    RemoveInconsistent(Parent(Xi),Xi)
    Assign forward: For i = 1 : n, assign Xi consistently with Parent(Xi)

    Runtime: O(n d2) (why?)

    Tree-Structured CSPs
    Claim 1: After backward pass, all root-to-leaf arcs are consistent
    Proof: Each XY was made consistent at one point and Ys domain
    could not have been reduced thereafter (because Ys children were
    processed before Y)

    Claim 2: If root-to-leaf arcs are consistent, forward assignment will not


    backtrack
    Proof: Induction on position
    Why doesnt this algorithm work with cycles in the constraint graph?

    Improving Structure

    Nearly Tree-Structured CSPs

    Conditioning: instantiate a variable, prune its neighbors'


    domains
    Cutset conditioning: instantiate (in all ways) a set of
    variables such that the remaining constraint graph is a tree

    Cutset Conditioning
    Choose a cutset
    SA

    Instantiate the
    cutset (all possible
    ways)
    SA

    Compute residual
    CSP for each
    assignment
    Solve the residual
    CSPs (tree
    structured)

    SA

    SA

    Cutset Quiz
    Find the smallest cutset for the graph below.

    Tree Decomposition*
    Idea: create a tree-structured graph of mega-variables
    Each mega-variable encodes part of the original CSP
    Subproblems overlap to ensure consistent solutions

    M1

    SA

    {(NT=r,SA=g,Q=b),
    (NT=b,SA=g,Q=r),
    }

    NS
    W

    SA

    shared vars

    {(WA=r,SA=g,NT=b),
    (WA=b,SA=r,NT=g),
    }

    M4
    Agree on

    SA

    NT

    shared vars

    shared vars

    NT

    M3
    Agree on

    Agree on

    WA

    M2

    NS
    W

    SA

    Agree: (M1,M2)
    {((WA=g,SA=g,NT=g), (NT=g,SA=g,Q=g)), }

    Iterative Improvement

    Iterative Algorithms for CSPs


    Local search methods typically work with complete states, i.e., all
    variables assigned
    To apply to CSPs:
    Take an assignment with unsatisfied constraints
    Operators reassign variable values
    No fringe! Live on the edge.
    Algorithm: While not solved,
    Variable selection: randomly select any conflicted variable
    Value selection: min-conflicts heuristic:
    Choose a value that violates the fewest constraints
    I.e., hill climb with h(n) = total number of violated constraints

    Example: 4-Queens

    States: 4 queens in 4 columns (44 =


    256 states)
    Operators: move queen in column
    Goal test: no attacks
    Evaluation: c(n) = number of attacks
    [Demo: n-queens iterative
    improvement (L5D1)]

    Video of Demo Iterative Improvement n


    Queens

    Video of Demo Iterative Improvement


    Coloring

    Performance of Min-Conflicts
    Given random initial state, can solve n-queens in almost constant
    time for arbitrary n with high probability (e.g., n = 10,000,000)!
    The same appears to be true for any randomly-generated CSP
    except in a narrow range of the ratio

    Summary: CSPs
    CSPs are a special kind of search problem:
    States are partial assignments
    Goal test defined by constraints
    Basic solution: backtracking search
    Speed-ups:
    Ordering
    Filtering
    Structure

    Iterative min-conflicts is often effective in


    practice

    Local Search

    Local Search
    Tree search keeps unexplored alternatives on the fringe (ensures
    completeness)
    Local search: improve a single option until you cant make it better (no
    fringe!)
    New successor function: local changes

    Generally much faster and more memory efficient (but incomplete and

    Hill Climbing
    Simple, general idea:
    Start wherever
    Repeat: move to the best neighboring state
    If no neighbors better than current, quit

    Whats bad about this approach?


    Complete?
    Optimal?

    Whats good about it?

    Hill Climbing Diagram

    Hill Climbing Quiz

    Starting from X, where do you end up ?


    Starting from Y, where do you end up ?
    Starting from Z, where do you end up ?

    Simulated Annealing
    Idea: Escape local maxima by allowing downhill
    moves
    But make them rarer as time goes on

    38

    Simulated Annealing
    Theoretical guarantee:
    Stationary distribution:

    If T decreased slowly enough,


    will converge to optimal state!

    Is this an interesting guarantee?


    Sounds like magic, but reality is reality:

    The more downhill steps you need to escape a


    local optimum, the less likely you are to ever
    make them all in a row
    People think hard about ridge operators which
    let you jump around the space in better ways

    Genetic Algorithms

    Genetic algorithms use a natural selection metaphor


    Keep best N hypotheses at each step (selection) based on a fitness function
    Also have pairwise crossover operators, with optional mutation to give variety

    Possibly the most misunderstood, misapplied (and even maligned)


    technique around

    Example: N-Queens

    Why does crossover make sense


    here?
    When wouldnt it make sense?
    What would mutation be?
    What would a good fitness
    function be?

    Next Time: Adversarial Search!

    You might also like