חיפוש בסביבות לא תחרותיות

חיפוש בסביבות לא תחרותיות Search in Benign Environments Most of the material is based on the lectures of Prof. Jonathan Schaeffer from the University of Alberta, Canada

קבלת החלטות בסביבה לא תחרותית • בעיות חשובות רבות הן בעיות אופטימיזציה – הסוכן צריך לקבל החלטה הממקסמת תועלת מסוימת • התועלת יכולה להיות שונה עבור בעיות שונות • דוגמאות תועלת: רווח, בטיחות, מהירות הייצור וכו' • בהרצאה זאת נדבר על סוג בעיות אופטימיזציה חשובות ביותר: למצוא דרך להגיע למטרה מסוימת עם מחיר קטן כמה שאפשר • מחיר יכול להיות במושגים של כסף, זמן או כל משאב אחר

דוגמאות של בעיות • GPS – למצוא מסלול הכי קצר ממקום A למקום B • מטרה – מקום B • מחיר– אורך המסלול (מספר קילומטרים) • למצוא פתרון הכי קצר לבעיית קובייה הונגרית: • מטרה – כל פאה עם צבע אחיד • מחיר– מספר הסיבובים

אפליקציית דוגמה • לצורך הלימוד נשתמש בבעיה של מציאת מסלול הכי קצר ברשת: • מהלכים אנכיים ואופקיים בלבד • מחיר כל מהלך הוא 1 מטרה מצב התחלתי

הסתכלות המשחק • אנו כבר יודעים כיצד לכתוב סוכן עבור משחק • נשתמש בידיעותינו עבור בעיה זאת (למרות שהיא שונה מאד): • מדובר בסוכן אחד– אין יריב! • כל המהלכים הם של הסוכן • כל מהלך מעביר אותנו למשבצת השכנה • אנחנו מנצחים כשמגיעים למטרה • אנו יודעים כיצד פותרים בעיות כאלו: • בונים עץ חיפוש ומחפשים לעומק • לאיזה עומק? משתמשים בהעמקה איטרטיבית! • האם יש ניצחון (כלומר פתרון) עם מחיר 1? מחיר 2? וכו' • הבדל (נראה שהוא הבדל קטן): יכולים להיות מחירים שונים למהלכים – מה שלא היה במשחקים

המצבים שנימצא באיטרציות 7 6 7 7 מטרה 6 5 7 6 7 5 4 5 6 4 3 2 3 4 5 3 1 2 4 מצב התחלתי 0 2 1 1 2 3

חיפוש לעומק עם העמקה איטרטיבית threshold = 0; done = false; while (notdone ) { done = DepthFirst(start, 0); if (done == false) threshold++; // אפשר לשפר (הוסבר בכיתה) } boolDepthFirst(state, cost) { if(cost > threshold) return false; if(state is goal) return true; foreach child ofstate { done = DepthFirst(child, cost + cost(child)); if (done == true) return true; } return( false ); }

תרגיל בכיתה • יש לבצע חיפוש לעומק עם העמקה איטרטיבית עבור Pancake Puzzle: http://www.cut-the-knot.org/SimpleGames/Flipper.shtml • עבור 4123

האם אפשר לשפר? • שימו לב כמה מצבים בדקנו כדי למצוא את המסלול הקצר ביותר: כמעט את כל המפה! 7 6 7 7 מטרה 6 5 7 6 7 5 4 5 6 4 3 2 3 4 5 3 1 2 4 מצב התחלתי 0 2 1 1 2 3

אלגוריתם חיפוש *IDA The IDA* Search Algorithm

יוריסטיקה • אנו יכולים לקבל חיתוכים מוקדם יותר בעזרת יוריסטיקה • יוריסטיקה היא פונקציית הערכה של מצב • בנושא שלנו היוריסטיקה מעריכה את המחיר כדי להגיע ממצב נתון למטרה • יש לשים לב ששימוש ביוריסטיקה כאן הוא לא כמו ב MiniMax • עבור הבעיה של מציאת מסלולים ברשת, יוריסטיקה טובה ופשוטה היא Manhattan Distance (MD) – מספר המהלכים שהיו נצרכים בהעדר חסומים. • MD = מרחק אופקי למטרה + מרחק אנכי למטרה

הערכת מחיר עם Manhattan Distance מטרה מצב התחלתי 2 + 5 = 7

כיצד היוריסטיקה עוזרת • כשאנו מגיעים למצב בחיפוש, אנחנו בעצם רוצים להעריך כמה יעלה לנו פתרון דרך מצב זה • אם הוא עולה יותר מהסף של האיטרציה הנוכחית, אזי נחתוך! • חיפוש לעומק עם העמקה איטרטיבית (שראינו מקודם) לקח בחשבון רק את המחיר ששילמנו כדי להגיע למצב • עכשיו יש לנו הערכת מחיר בת שני חלקים: • g – כמה כבר שילמנוכדי להגיע למצב • h – יוריסטיקה,הערכה של כמה עוד נצטרך לשלםכדי להגיע ממצב זה למטרה • הערכת מחיר היא f=g+h • מבנה נתונים הכולל מצב עם המחיר שלו מכנים node(קדקוד)

איטרציות של IDA* • מתחילים עם threshold=5, כי ברור שלא יהיה פתרון עם מחיר פחות מ 5! מטרה 5 + 2 = 7 7 + 0 = 7 6 + 1 = 7 4 + 3 = 7 5 + 2 = 7 3 + 4 = 7 3 + 2 = 5 4 + 3 = 7 2 + 3 = 5 1 + 4 = 5 2 + 3 = 5 מצב התחלתי 1 + 6 = 7 1 + 4 = 5 2 + 5 = 7 0 + 5 = 5

ID + יוריסטיקה = *IDA! threshold = heuristic(start); done = false; while (notdone ) { done = DepthFirst(start, 0); if (done == false) threshold++; // אפשר לשפר (הוסבר בכיתה) } boolDepthFirst(state, cost) { if(cost + heuristic(state) > threshold) return false; if(state is goal) return true; foreach child ofstate { done = DepthFirst(child, cost + cost(child)); if (done == true) return true; } return( false ); }

תרגיל בכיתה • יש לבצע חיפוש IDA* עבור Pancake Puzzle • עבור 4123 • יוריסטיקה: מספר רווחים (הוסבר בכיתה)

האם *IDA מבטיח פתרון אופטימלי? • האם *IDA מבטיח לנו פתרון אופטימלי? • כן ... בתנאי שהיוריסטיקה תהווה חסם תחתון (דרך חכם לומר "פחות מ")למחיר אופטימלי כדי להגיע ממצב למטרה • דוגמה: MD הוא תמיד פחות מהמרחק האמתי למטרה • יוריסטיקות אשר הן חסם תחתון מכנים admissible(קבילות)

חשיבותה של יוריסטיקה מדויקת • נזכור שמספר מהלכים אפשריים במצב נקרא פקטור הסתעפות • באנגלית: Branching Factor (BF) • נניח שה BFשל הבעיה הוא b (עבור כל מצבים) • אם לא משתמשים ביוריסטיקה, אזי האיטרציה המחפשת לעומק d מייצרת bd עלים • עכשיו נניח שמשתמשים ביוריסטיקה והערך שלה hבממוצע. אזי אותה האיטרציה מייצרת bd-h עלים (בקירוב) • איכות היוריסטיקה יוצרת הבדל עצום!

מה עוד יש לדעת על *IDA? • *IDA הופיע בשנת 1985 • בעזרתו פתרו לראשונה בצורה אופטימלית בעיה קלסית של תחום החיפוש, פאזל 15 • אבל ל *IDA יש שני חסרונות: • חזרה על אותם מצבים מספר פעמים • צורך בזמן של איטרציות ראשונות: • בגלל מצבים חוזרים • בגלל מחירים שונים של מצבים • נתמקד בהבנת חסרונות אלו

מצבים חוזרים • נתעלם לרגע מהיוריסטיקה • כמה פעמים האיטרציה המחפשת ממצב S לעומק 4 תייצר את המצב Eהמסומן בצבע ורוד? • SASBE • SASCE • SBEBE • SBECE • SBEDE • SBFBE • SBFDE • SCEBE • SCEDE • SCECE • SCGCE D H F B E A S C G

מה אפשר לעשות כדי למנוע מצבים חוזרים • פתרון פשוט שלפעמים פותר את רוב הבעיה: למנוע ייצור של הורה בתור בן. זה לא יאפשר SCECE, כי C הנו הורה של E ולא יכול להיות בנו. • מלבד שמירת המצבים שכבר ראינו בחיפוש • אבל... אז לא נצטרך העמקה איטרטיבית ונשתמש באלגוריתם אחר שעליו נדבר בהמשך • אבל עדיין: • SBECG • SBFDE D • קיימות גם טכניקות יותר מתוחכמות, אבל אין פתרון כללי... F E B C G A S

החסרונות של *IDA • ל *IDA יש שני חסרונות: • חזרה על אותם מצבים מספר פעמים • צורך בזמן של איטרציות ראשונות: • בגלל מצבים חוזרים • בגלל מחירים שונים של מצבים

מדוע איטרציות ראשונות לא היו בעתיות עד כה?(ב Minimaxוב פאזל 15 ב *IDA) • נחזור לאנאליזה שלנו • לצורך הפשטות נניח שאין יוריסטיקה (h=0) • נניח שה BF של הבעיה הוא b (עבור כל מצבים) • האיטרציה המחפשת לעומק d מייצרת bd עלים • נניח שהפתרון נמצא בעומק d • לפיכך כמות העבודה שעשו האיטרציות הראשונות היא: • b0+b1+…+bd-1~bd/(b-1) • לכן, אם b>2, אזי כל האיטרציות הראשונות עשו פחות עבודה מהאיטרציה האחרונה • זה נכון רק כשכמות העבדה גודלת בצורה אקספוננציאלית עם העומק

צורך זמן של איטרציות ראשונות בגלל מצבים חוזרים • לצורך הפשטות נניח ש: • אין יוריסטיקה (h=0) • הרשת ריקה (בלי חסמים) • מצב התחלתי S במרכז, מטרה Gבפינה • כמה מצבים חדשים (כלומר, שלא ראינו אותם באיטרציות קודמות) נראה באיטרציה המחפשת לעומק d? • 4d • כמה מצבים סך הכול נראה באיטרציה המחפשת לעומק d? • 4(1+2+…+d)~2d2 • זה לא אקספוננציאלי ב d! 2 1 2 2 1 2 1 2 2 1 2 2

צורך זמן של איטרציות ראשונות בגלל מצבים חוזרים • כמה מצבים סך הכול נראה באיטרציה המחפשת לעומק d? • 4(1+2+…+d)~2d2 • זה לא אקספוננציאלי ב d! • נניח שהפתרון נמצא בעומק d • אז כמות העבודה שעשו האיטרציות הראשונות היא: • 2(12+22+…+(d-1)2)~(d-1)3/3 • לדוגמה, אם d=20, אזי • באיטרציה האחרונה נראה 2x202=800מצבים • איטרציות הראשונות (עד עומק19 ) ייצרו 193/3=2286מצבים 2 1 2 2 1 2 1 2 2 1 2 2

צורך זמן של איטרציות ראשונות בשל מחירים שונים של מצבים A • נתבונן איך *IDA יחפש את המסלול הקצר ביותר מקדקוד A (מצב התחלתי) לקדקוד F (מטרה) בגרף זה • על כל צלע מסומן מחיר • אין יוריסטיקה (h=0) • בכל איטרציה יתווסף לכל היותר מצב אחד חדש • לכן, האיטרציה האחת לפני האחרונה צורכת כמעט אותו זמן כמו האיטרציה האחרונה וכו' • הבעיה כאן היא שיש מחירים שונים רבים עבור מצבים שונים וזה גורם למספר איטרציות גדול מדי 2 1 D B 3 5 3 E C 3 4 F

אלגוריתם חיפוש *A The A* Search Algorithm

כמה מילים כלליים על *A • *A הופיע בשנות 1960 (כ-15 שנה לפני *IDA) • *A לא סובל מבעיות של *IDA • אבל יש לו בעיה אחרת ש *IDAפותר • למה למדנו *IDA קודם? • כי קל להבין *IDA אחרי שראינו העמקה איטרטיבית עבור Minimax

בסיס של *A – שמירת מצבי חזית בזיכרון • *A שומרת בזיכרון את חזית הקדקודים • באנגלית: frontier • החזית מבדילה בין המצבים ש *Aבדק למצבים שהוא לא ראה • למצבים בחזית יכולים להיות שכנים ש *A עדיין לא בדק 7 6 7 7 מטרה 6 5 7 6 7 5 4 5 6 4 3 2 4 5 3 3 1 2 4 מצב התחלתי 2 1 1 2 3 0

מבנה נתונים של *A • *A שומר שתי רשימות של מצבים: • OPEN: מצבים של החזית • הם המצבים ש *A ראה אבל לא סיים איתם • יכולים להיות בנים של אותם מצבים שהמסלול הזול ביותר עובר דרכם • CLOSED: מצבים ש *A סיים איתם • כלומר הוא ראה את כל הילדים שלהם • כמו ב *IDA, לכל מצב יש מחיר בן שני חלקים: • g – מרחק ממצב (כפי ש *A ראה עד כאן) התחלתי למצב הנוכחי • h – יוריסטיקה,הערכה של מחיר כדי להגיע ממצב למטרה • *A שומר מחיר עם כל מצב של שתי הרשימות • מבנה נתונים הכולל מצב עם המחיר שלו מכנים node (קדקוד) • חשוב: רשימת OPEN הנה שמורה באופן שהמצב הזול ביותר לפי g+hתמיד מופיע ראשון ברשימה • אם יש כמה מצבים הכי זולים, אז המצב עם h קטן ביותר ראשון

אלגוריתם *A בקצרה • כש *A מתחיל, הוא מוסיף מצב התחלתי לרשימת OPEN • *A חוזר על השלבים הבאים עד שהוא מוצא פתרון או שרשימת OPEN מתרוקנת (כלומר, אין פתרון): • מוחק מצב מראש רשימת OPEN. הוא נעשה המצב הנוכחי • אם זה מצב מטרה, אזי *A מסתיים • מייצר את הבנים של המצב הנוכחי • זה נקרא לפתח את המצב הנוכחי (באנגלית: Expand) • *A הנו best-first algorithm (טוב-ביותר ראשון), כי הוא תמיד בוחר לפתח מצב הטוב ביותר מאלו שהוא כבר ראה (כלומר, המצב בראש רשימת OPEN) • מוסיף את הבנים לרשימת OPEN • מוסיף את המצב הנוכחי לרשימת CLOSED • אלא אם כן קורה משהו (שלא נכנס לזה), *A סיים עם המצב הנוכחי

דוגמה: נבצע כמה שלבי *A על בעיה זאת 6 5 מטרה 4 3 2 מצב התחלתי 1 D E F C A B

פיתוח מצב מפורט • כאשר *A מפתח את המצב הנוכחי, הוא מבצע את השלבים הבאים עבור כל אחד מבניו: • בודק האם אותו מצב (כלומר, הבן) כבר שמור באחת הרשימות (OPEN\CLOSED) עם ערך gשווה או פחות מ ערך gהנוכחי • אם כן, אזי *A זורק את המצב ולא מוסיף אותו לרשימת OPEN • ולא, אזי *Aמוסיף את המצב לרשימת OPEN

אלגוריתםA* bool A*(state s) { s.g = 0; s.h= heuristic(s); s.f= s.g + s.h; s.parent= null; s  OPEN done= false; while (OPEN is not empty) { s  OPEN if (s isgoal) { done= true; break; } foreachchild of s consider(s, child); add s to CLOSED } returndone; } consider(state from, state to) { newg = from.g + cost(from, to); if (to is in OPEN/CLOSED and to.g <= newg) return; to.g = newg; to.h = heuristic(to); to.f = to.g + to.h; to.parent = from; if (to is in CLOSED) delete to from CLOSED if (to is not in OPEN) to  OPEN }

הערות סיכום על *A • בהינתן יוריסטיקה קבילה (admissible), *A יחזיר את המסלול הזול ביותר • *A מפתח רק את המצבים שמסלול אופטימלי יכול לעבור דרכם • *A צורך זיכרון כדי לשמור את רשימת ה OPEN ואת רשימת ה CLOSED • חשוב להבין שכל מצב ש *A ראה מתחילת החיפוש שמור בזיכרון באחת משתי הרשימות • למעשה, כשמריצים *A כדי לפתור בעיות קשות, הוא גומר את הזיכרון תוך דקות ספורות • לכן, צריכים לשקול עבור כל בעיה ספציפית האם להשתמש ב *A או ב *IDA

חיפוש בסביבות לא תחרותיות

חיפוש בסביבות לא תחרותיות

Presentation Transcript