בעיות חיפוש – informed search
description
Transcript of בעיות חיפוש – informed search
informed – בעיות חיפושsearch
בינה מלאכותית
יעל נצר
תזכורתחיפוש כדרך לפתרון בעיות:•
מצב התחלתי–מטרה או מצבי פתרון–פעולות אפשריות–
: שיטות חיפוש•– כלומר אין קשר בין אופן החיפוש לבין uninformedעיוורות –
המידע עצמו.חיפוש לרוחב•חיפוש לעומק•
– שימוש בהיוריסטיקותinformedחיפוש מיודע –מרחב החיפוש:•
מצב חיפוש–אופרטור–מצבים חדשים–
חיפוש לרוחב ולעומק
חיפוש לעומק•מבטיח מציאת פתרון, הקצר ביותר.– – במקום ובזמן.O(bn)סיבוכיות – –
חיפוש לרוחב•במרחב אינסופי – אין הבטחה למציאת פתרון–O(bn) מקום O(bn)זמן –
Uniform Cost Search
• UCS Intuition: Find shortest path in terms of sum of lengths of sub-paths.
• Agenda: priority queue ordered by path length; get shortest path in queue.
• Will it get the shortest path?
• Optimal and complete
L
A B
ZO
S F
PR
T MD
118
75
71 151
140
111 70 75
120
8099
211
97146
138101
C
Uniform Cost Search
A
AB
ZO
S F
C
PR
T L MD
118
75
71 151
140
111 70 75
120
80
99
211
97
146 138
101
Uniform Cost Search
A
Z75 T118 S140
AB
ZO
S F
C
PR
T L MD
118
75
71 151
140
111 70 75
120
80
99
211
97
146 138
101
Uniform Cost Search
A
T118 S140 O146
Z75 T118 S140
AB
ZO
S F
C
PR
T L MD
118
75
71 151
140
111 70 75
120
80
99
211
97
146 138
101
S140 O146 L229
Uniform Cost Search
A
T118 S140 O146
Z75 T118 S140
AB
ZO
S F
C
PR
T L MD
118
75
71 151
140
111 70 75
120
80
99
211
97
146 138
101
S140 O146 L229
Uniform Cost Search
A
T118 S140 O146
Z75 T118 S140
O146 R220 L229 F239 O291 AB
ZO
S F
C
PR
T L MD
118
75
71 151
140
111 70 75
120
80
99
211
97
146 138
101
S140 O146 L229
Uniform Cost Search
A
T118 S140 O146
Z75 T118 S140
O146 R220 L229 F239 O291
R220 L229 F239 O291
AB
ZO
S F
C
PR
T L MD
118
75
71 151
140
111 70 75
120
80
99
211
97
146 138
101
S140 O146 L229
Uniform Cost Search
A
T118 S140 O146
Z75 T118 S140
O146 R220 L229 F239 O291
R220 L229 F239 O291
AB
ZO
S F
C
PR
T L MD
118
75
71 151
140
111 70 75
120
80
99
211
97
146 138
101L229 F239 O291 P317 D340 C366
S140 O146 L229
Uniform Cost Search
A
T118 S140 O146
Z75 T118 S140
O146 R220 L229 F239 O291
R220 L229 F239 O291
AB
ZO
S F
C
PR
T L MD
118
75
71 151
140
111 70 75
120
80
99
211
97
146 138
101
F239 O291 P317 D340 C366 M399
…
L229 F239 O291 P317 D340 C366
חיפושים מיודעים informed search
להעריך את domain specificהוספת ידע •הקרבה לפתרון
ההערכה מתבצעת על ידי פונקצית היוריסטיקה, •h(n) שלא מבטיחה את התוצאה הטובה ביותר(
אם בכלל(
תכנון המסלול נעשה על ידי•
•h(n) = estimated cost of the cheapest path from the state at n to goal state.
Best-First-Searchחיפוש
שינוי פונקציית התור בחיפוש••Evaluation function פונקציה המשמשת להחלטה איזה קודקוד –
לפרוש בצעד החיפוש הבא: מחזירה מספר המייצג את טיב המצב הבא.הקדקודים ממויינים כך שהקדקוד בעל הציון הטוב ביותר נבחר לצעד •
הבא.שימוש במדד )מוערך( – תוך ניסיון להשיג עלות מינימלית של החיפוש.
מהיעד, בחיפוש נתיב על מפה.straight line distanceלמשל: מרחק •
מפת רומניה מעודכנת
Greedy Search Example
Greedy Search (continued)
Greedy Search Example
Greedy Search (continued)
Pimnicu Vilceaהפתרון אינו אופטימלי: דרך •and Pitesi.קצרה יותר
לא אופטימלי•
לא מבטיח פתרון•
•O(bm)סיבוכיות מקום וזמן
Using Heuristic Information
• What if h(B) is way larger than h(A)?
• Add heuristic cost to path length so far
• f(n) = g(n) + h(n)• A*
S
A B
G
150 10
2 250
Minimizing Cost
•Uniform search מנסה להקטין את עלות (g(n)מסלול החיפוש )נקרא לפונקציה
g(n) של-h(n)שילוב בין ••f(n)=g(n)+h(n)למציאת הפתרון הזול ביותר, נחפש קודקוד •
.fשנותן ערך מינימלי ל- אם complete and optimalמבטיחה פתרון •
לא מחזירה ערך גדול יותר מאשר hהפונקציה המרחק האמיתי למטרה, כלומר מדובר
.admissibleבהיוריסטיקה קבילה
Admissibility
• A* guaranteed to be optimal if h is admissible, i.e., cannot be an overestimate
• If h is not admissible, cannot guarantee optimalityg(A)+h(A) = 105g(B)+h(B) = 203
S
A B
G
3100
5 4
h(B)=200h(A)=5
h(G)=0
Heuristic for Path-Planning Problem: SLD
• Is straight-line distance (SLD) an admissible heuristic for path planning?
• Triangle inequality |AC| < |AB|+|BC|
• Admissible!
Graph Search Requires Consistency as well!
• Consistency: h(n) ≤ c(n,n') + h(n'), where n' is a successor of n
• Graph search is optimal if h(n) is consistent
• If h(n) is consistent thenf(n) is a monotonicallyincreasing function n
n'
G
h(n)
h(n')
c(n,n')
Selecting a Heuristic
• Heuristic should cut down on search space.
• Can find heuristic by relaxing the problem
• Heuristic functions can be solutions to “relaxed” version of original
• Procedure: Relax hard problem so it’s easy to solve; use solution to relaxed problem as heuristic for real problem.
8-Puzzle Heuristic Possibilities
• Relaxed problems:– Number of tiles in wrong position.– Distance from each tile to its proper place.
• Admissible.
A* Search
A* Search
A* Search
A* Search
A* Search
Norvig’s Lisp – tree search
(defun tree-search (states goal-p successors combiner)
"Find a state that satisfies goal-p. Start with states, and search according to successors and combiner." (dbg :search "~&;; Search: ~a" states) (cond ((null states) fail) ((funcall goal-p (first states)) (first states)) (t (tree-search (funcall combiner (funcall successors (first states)) (rest states)) goal-p successors combiner))))
DFS, BFS
(defun depth-first-search (start goal-p successors) "Search new states first until goal is reached." (tree-search (list start) goal-p successors #'append))
(defun binary-tree (x) (list (* 2 x) (+ 1 (* 2 x))))
(defun is (value) #'(lambda (x) (eql x value)))
(defun prepend (x y) "Prepend y to start of x" (append y x))
(defun breadth-first-search (start goal-p successors) "Search old states first until goal is reached." (tree-search (list start) goal-p successors #'prepend))
(defun finite-binary-tree (n) "Return a successor function that generates a binary tree with n nodes." #'(lambda (x) (remove-if #'(lambda (child) (> child n)) (binary-tree x))))
Best First Search
(defun diff (num) "Return the function that finds the difference from num." #'(lambda (x) (abs (- x num))))
(defun sorter (cost-fn) "Return a combiner function that sorts according to cost-fn." #'(lambda (new old) (sort (append new old) #'< :key cost-fn))) (defun best-first-search (start goal-p successors cost-fn) "Search lowest cost states first until goal is reached." (tree-search (list start) goal-p successors (sorter cost-fn)))
Beam Search(defun beam-search (start goal-p successors
cost-fn beam-width) "Search highest scoring states first until goal
is reached, but never consider more than beam-width
states at a time." (tree-search (list start) goal-p successors #'(lambda (old new) (let ((sorted (funcall (sorter cost-fn)
old new))) (if (> beam-width (length sorted)) sorted (subseq sorted 0 beam-
width))))))