האוניברסיטה הפתוחה • קורס 20551

סיכום קורס: מבוא לבינה מלאכותית

סיכום מקיף למבחן: תיאוריה, אלגוריתמים, נוסחאות ושיטות פתרון מעשיות

סוכנים וחיפוש (פרקים 1–4) משחקים ו-CSP (פרקים 5–6) לוגיקה ותכנון (פרקים 7–10) הסתברות, MDP ולמידה (פרקים 13, 14, 17, 18)

פרק 1: מבוא לבינה מלאכותית (Introduction)

הגדרת התחום, 4 הגישות המרכזיות, מבחן טיורינג ותחומי המחקר ב-AI.

1.1 מהי בינה מלאכותית? (4 הגישות)

בינה מלאכותית (AI) היא תחום מחקר במדעי המחשב שמטרתו פיתוח אלגוריתמים לתפישה, להסקת מסקנות וללמידה כדי לפתור בעיות מורכבות ולבנות ישויות אינטליגנטיות. נהוג לחלק את הגישות לתחום לפי שני צירים: חשיבה מול התנהגות, וחיקוי בני אדם מול רציונליות אידיאלית:

ציר הערכה דמיון לבני אדם (Human-like) רציונליות אידיאלית (Rationality)
חשיבה (Thinking) 1. חושב כמו אדם (המודל הקוגניטיבי):
חקר אופן החשיבה האנושי באמצעות: (א) התבוננות עצמית, (ב) ניסויים פסיכולוגיים, (ג) הדמיה מוחית (fMRI).
2. חושב רציונלי (חוקי החשיבה / לוגיקה):
ניסוח פסוקים וכללי היסק לוגיים. קשיים: קשה לנסח ידע לא ודאי בפורמליזם לוגי, ופער עצום בין פתרון תיאורטי לסיבוכיות החישובית בפועל.
התנהגות (Acting) 3. פועל כמו אדם (גישת מבחן טיורינג):
מכונה נחשבת אינטליגנטית אם בוחן אנושי המנהל מולה שיחה כתובה אינו יכול להבחין אם התשובות ניתנו ע"י אדם או מחשב.
4. פועל רציונלי (גישת הסוכן החכם - גישת הקורס!):
סוכן הפועל להשגת התוצאה הטובה ביותר (או תוחלת התוצאה הטובה ביותר בתנאי אי-ודאות).

🔍 מיקוד: מבחן טיורינג מול גישת הסוכן הרציונלי

  • 4 היכולות הנדרשות למבחן טיורינג הסטנדרטי: (1) עיבוד שפה טבעית (NLP), (2) ייצוג ידע (Knowledge Representation), (3) הסקה אוטומטית (Automated Reasoning), (4) למידה חישובית (Machine Learning). שימו לב: מבחן זה אינו כולל אינטראקציה פיזית!
  • מבחן טיורינג טוטאלי (Total Turing Test): מוסיף אינטראקציה פיזית באמצעות וידאו והעברת עצמים, ולכן דורש 2 יכולות נוספות: ראייה ממוחשבת (Computer Vision) ורובוטיקה (Robotics).
  • למה הקורס מתמקד ב"פועל רציונלי" ולא במבחן טיורינג? משתי סיבות: (1) כלליות – הסקה לוגית היא רק מנגנון אחד מתוך רבים להשגת רציונליות (למשל תגובה רפלקסיבית להרחקת יד מאש), (2) תאימות מדעית והנדסית – בניית מטוסים הצליחה כשלמדו חוקי אווירודינמיקה במקום לנסות לחקות נפנוף כנפי ציפורים.
  • רציונליות מוגבלת (Bounded Rationality): בסביבות מורכבות לא ניתן לחשב רציונליות מושלמת בזמן סביר, ולכן נדרש לפעול בצורה מיטבית תחת מגבלות הזמן והזיכרון (נדון בפרקים 5 ו-17).

1.2 דיסציפלינות תורמות והישגים בולטים

  • 8 הדיסציפלינות שתרמו ל-AI: פילוסופיה (לוגיקה ורציונליות), מתמטיקה (חישוביות, לוגיקה והסתברות), כלכלה (תורת התועלת, תורת המשחקים ו-MDP), חקר העצבים (רשתות נוירונים), פסיכולוגיה (מדעי הקוגניציה), הנדסת מחשבים (חומרה), תורת הבקרה וקיברנטיקה, ובלשנות (ייצוג ידע ודקדוק).
  • אבני דרך והישגים היסטוריים במדריך הלמידה: תוכנת Remote Agent של נאס"א שניהלה את החללית Deep Space 1; מחשב השחמט Deep Blue של IBM שניצח את גארי קספרוב (1997); רכבים אוטונומיים (ALVINN / DARPA); מערכות דיאגנוסטיקה רפואית ברשתות הסתברותיות; רובוט הניתוחים HipNav; מערכת התכנון הלוגיסטי DART במלחמת המפרץ (שהחזירה את כל השקעת משרד ההגנה האמריקאי ב-AI ב-30 שנה); סינון ספאם בלמידה מדוגמאות; Watson של IBM שניצח ב-Jeopardy (2010); והעוזרת האישית Siri (פרויקט CALO).

1.3 תחומי מחקר ותיאוריית הבר-למידה (Valiant)

1. ראייה ממוחשבת (Computer Vision) קלט: תמונה כמטריצת פיקסלים.
פלט: תיאור האובייקטים הפיזיקליים בתמונה ומיקומם במרחב.
2. הבנת שפה טבעית (NLU) קלט: משפט או סדרת משפטים.
פלט: ייצוג משמעות המשפט בצורה פורמלית.
3. פתרון בעיות (Problem Solving) קלט: מצב העולם, מטרת הסוכן וידע על אפקט הפעולות.
פלט: פעולה או סדרת פעולות להתקדמות למטרה.
4. רובוטיקה (Robotics) קלט: פעולה שהסוכן החליט לבצע.
פלט: סדרת פקודות למנועים המפעילים את הזרוע/החומרה.
5. למידה חישובית (Machine Learning) קלט: אוסף התנסויות (דוגמאות).
פלט: תוספות או שינויים לבסיס הידע של הסוכן לשיפור ביצועיו.
6. מערכות מרובות סוכנים (MAS) אינטראקציה בין מספר סוכנים באותה סביבה: שיתוף פעולה (מטרות משותפות) או תחרות (מטרות מנוגדות).
💡 תיאוריית הבר-למידה (A Theory of the Learnable - פרופ' לסלי וליאנט, 1984): מעבר ממצה על כל האפשרויות כדי להגיע לתוצאה מדויקת ב-100% יגרום ל"התפוצצות" זמן החישוב. הפתרון של וליאנט (PAC Learning - Probably Approximately Correct) הוא שילוב חכם של חישוב מקורב וחישוב הסתברותי — הגעה לתוצאה מקורבת טובה בהסתברות גבוהה ובזמן פולינומיאלי.

פרק 2: סוכנים חכמים (Intelligent Agents)

מושג הרציונליות, אפיון סביבות משימה (PEAS), סוגי סוכנים ורמות ייצוג.

2.1 סוכנים, סביבות ופונקציית הסוכן

  • סוכן (Agent): כל ישות הבוחנת את סביבתה באמצעות חיישנים (Sensors) ופועלת עליה באמצעות אמצעי פעולה (Actuators). $$\text{Agent} = \text{Architecture (חומרה/פלטפורמה)} + \text{Program (תכנית)}$$
  • תחושה (Percept) מול היסטוריית תחושות (Percept Sequence): תחושה היא קלט החיישנים ברגע נתון; היסטוריית התחושות היא הסדרה המלאה של כל מה שהסוכן קלט מאז תחילת פעולתו.
  • פונקציית הסוכן מול תכנית הסוכן: פונקציית הסוכן היא תיאור מתמטי מופשט הממפה כל סדרת תחושות לפעולה ($f: P^* \to A$). תכנית הסוכן היא המימוש הקונקרטי שרץ על הארכיטקטורה.
    מדוע לא לממש סוכן כטבלת חיפוש (Lookup Table)? אם $P$ היא קבוצת התחושות האפשריות ו-$T$ אורך חיי הסוכן, גודל הטבלה הוא $\sum_{k=1}^T |P|^k$ — גודל אקספוננציאלי בלתי אפשרי בזיכרון!

2.2 רציונליות, ידיעת-כל ואוטונומיות

הגדרת הסוכן הרציונלי ו-4 הגורמים הקובעים רציונליות

סוכן רציונלי: לכל סדרת תחושות אפשרית, יבחר בפעולה שתמקסם את תוחלת מדד הביצועים שלו, בהינתן הידע המוקדם שלו ומה שנובע מסדרת התחושות. רציונליות ברגע נתון תלויה ב-4 גורמים:

  1. מדד הביצועים (Performance Measure) שמגדיר מהי הצלחה.
  2. הידע המוקדם (Prior Knowledge) של הסוכן על הסביבה.
  3. הפעולות (Actions) שהסוכן מסוגל לבצע.
  4. סדרת התחושות (Percept Sequence) שהסוכן קלט עד עתה.
⚠️ כלל זהב בניסוח מדד ביצועים: יש להגדיר את מדד הביצועים לפי מה שאנו רוצים שיקרה בסביבה (למשל: נקודה על כל מרצפת נקייה בכל יחידת זמן, פחות קנס על צריכת חשמל ורעש), ולא לפי איך שאנו חושבים שהסוכן צריך להתנהג (אם ניתן ציון לפי "כמות האבק שנשאבה", סוכן רציונלי ישאב אבק, ישפוך אותו חזרה על הרצפה וישאב שוב לנצח!).
  • רציונליות $\neq$ ידיעת-כל (Omniscience): סוכן יודע-כל יודע מראש את התוצאה הוודאית של פעולותיו (בלתי אפשרי במציאות). סוכן רציונלי ממקסם את תוחלת הביצועים לפי המידע שברשותו.
  • איסוף מידע (Information Gathering) ולמידה: פעולות שנועדו לשפר תצפיות עתידיות (כמו להסתכל ימינה ושמאלה לפני חציית כביש) הן חלק הכרחי מהתנהגות רציונלית.
  • אוטונומיות (Autonomy): סוכן המסתמך רק על הידע המוקדם של מתכננו ומתעלם מתחושותיו חסר אוטונומיות. סוכן אוטונומי לומד מניסיונו כדי לפצות על ידע מוקדם חלקי או שגוי.

2.3 מודל PEAS ו-7 תכונות סביבת העבודה

הצעד הראשון בתכנון סוכן הוא הגדרת סביבת המשימה באמצעות ראשי התיבות PEAS (דוגמת נהג מונית אוטונומי):

P - Performance בטיחות, הגעה מהירה, חוקיות, נוחות נוסעים, רווחיות.
E - Environment כבישים, כלי רכב אחרים, הולכי רגל, תמרורים, מזג אוויר.
A - Actuators הגה, דוושת גז, בלמים, איתות, צופר, מסך תצוגה.
S - Sensors מצלמות, רדאר/לידאר, מד מהירות, GPS, חיישני מנוע, מקלדת.
תכונת הסביבה הגדרה והשפעה על הסוכן דוגמאות קלאסיות
1. נראית במלואה מול נראית חלקית האם החיישנים חושפים את כל מצב הסביבה הרלוונטי בכל רגע? בנראות חלקית הסוכן חייב לשמור מצב פנימי (זיכרון). שחמט (מלאה) מול נהג מונית / פוקר (חלקית).
2. סוכן יחיד מול ריבוי סוכנים האם יש ישויות אחרות שפועלות לפי מדד ביצועים משלהן (תחרותית או שיתופית)? פתרון תשבץ (יחיד) מול שחמט (תחרותית) ונהיגה.
3. דטרמיניסטית מול סטוכסטית האם המצב הבא נקבע לחלוטין ע"י המצב הנוכחי ופעולת הסוכן? (אם יש אי-ודאות רק בגלל סוכנים אחרים – נקראת אסטרטגית). שחמט / 8-פאזל (דטרמיניסטית) מול שש-בש / מונית (סטוכסטית).
4. מקוטעת (אפיזודית) מול מתמשכת במקוטעת כל תחושה-פעולה היא אפיזודה בלתי תלויה בבאות אחריה. במתמשכת (סדרתית) כל החלטה משפיעה על העתיד. זיהוי חלקים פגומים בפס ייצור (מקוטעת) מול שחמט/נהיגה (מתמשכת).
5. סטטית מול דינמית האם הסביבה משתנה בזמן שהסוכן חושב? (אם הסביבה לא משתנה אך הציון יורד עם הזמן כמו שחמט עם שעון – חצי-דינמית). תשבץ (סטטית) מול נהיגה במונית (דינמית).
6. בדידה מול רציפה מתייחס למצבי הסביבה, לזמן, לתחושות ולפעולות של הסוכן. שחמט (בדידה) מול היגוי ומהירות במונית (רציפה).
7. ידועה מול לא ידועה מתייחס לידע של הסוכן על חוקי הפיזיקה/המעברים של הסביבה (תוצאות והסתברויות הפעולות). סוליטר (ידועה אך נראית חלקית!) מול משחק וידאו חדש (לא ידועה אך נראית במלואה!).

2.4 ארכיטקטורות סוכנים ו-3 רמות ייצוג מצבים

1. סוכן תגובה פשוטה (Simple Reflex Agent): בוחר פעולה רק על סמך התחושה הנוכחית באמצעות כללי תנאי-פעולה (Condition-Action Rules). מצליח רק אם הסביבה נראית במלואה (בנראות חלקית עלול להיתקע בלולאה אינסופית; בחירה אקראית עשויה לחלץ אותו).
2. סוכן מבוסס-מודל (Model-Based Reflex Agent): מתמודד עם נראות חלקית ע"י שמירת מצב פנימי (Internal State) שמתעדכן באמצעות `UPDATE-STATE` הדורשת: (א) מודל של התפתחות העולם עצמאית, (ב) מודל מעברים של השפעת פעולות הסוכן.
3. סוכן מבוסס-מטרה (Goal-Based Agent): משלב את המודל הפנימי עם מידע על מטרה (Goal) רצויה, ומשתמש בחיפוש (Search) ותכנון (Planning) כדי לבחור פעולות שיובילו למטרה.
4. סוכן מבוסס-תועלת (Utility-Based Agent): כאשר יש מספר דרכים להשיג מטרה או מטרות מתנגשות (כמו מהירות מול בטיחות) ואי-ודאות, הסוכן משתמש בפונקציית תועלת הממפה כל מצב למספר ממשי, ובוחר בפעולה שממקסמת את תוחלת התועלת.
5. סוכן לומד (Learning Agent): מורכב מ-4 רכיבים: (1) אלמנט מבצע (בוחר פעולות), (2) מבקר (Critic) (מעריך את ביצועי הסוכן ביחס למדד הביצועים ומעביר משוב), (3) אלמנט לומד (מעדכן ומשפר את האלמנט המבצע), (4) מייצר בעיות (Problem Generator) (מציע פעולות חקר להתנסויות חדשות).

📊 3 רמות לייצוג מצבי הסביבה (איור 2.16):

1. ייצוג אטומי (Atomic) כל מצב הוא "קופסה שחורה" ללא מבנה פנימי (רק שם/מזהה).
שימוש: חיפוש (פרקים 3–5), תהליכי החלטה מרקוביים MDP (פרק 17).
2. מחולק לגורמים (Factored) מצב מיוצג כווקטור קבוע של משתנים/תכונות וערכיהם.
שימוש: CSP (פרק 6), תחשיב הפסוקים (פרק 7), תכנון (פרק 10), רשתות בייסיאניות (13–14), למידה (18).
3. ייצוג מובנה (Structured) מצב כולל אובייקטים מרובים, תכונותיהם ומערכת יחסים מורכבת ביניהם.
שימוש: לוגיקה מסדר ראשון (פרקים 8–9) והבנת שפה טבעית.

פרק 3: פתרון בעיות באמצעות חיפוש (Search)

ניסוח פורמלי של בעיות, אלגוריתמי חיפוש עיוור, חיפוש מיודע ($A^*$), קבילות ועקביות.

3.1 ניסוח בעיות, הפשטה ודוגמאות

בסביבה נראית במלואה, בדידה, ידועה ודטרמיניסטית, פתרון לכל בעיה הוא סדרה קבועה של פעולות. הסוכן פועל בשלושה שלבים: נסח (Formulate) $\to$ חפש (Search) $\to$ בצע (Execute).

5 הרכיבים להגדרה פורמלית של בעיית חיפוש:

  1. מצב התחלתי ($S_0$): המצב שממנו מתחיל הסוכן.
  2. פעולות אפשריות ($\text{ACTIONS}(s)$): קבוצת הפעולות החוקיות במצב $s$.
  3. מודל המעברים ($\text{RESULT}(s,a)$): המצב המתקבל מביצוע פעולה $a$ במצב $s$ (3 הרכיבים הראשונים מגדירים את מרחב המצבים כגרף מכוון).
  4. מבחן המטרה ($\text{Goal-Test}$): פונקציה בוליאנית הבודקת אם מצב נתון הוא מצב מטרה.
  5. פונקציית מחיר מסלול ($g(n)$): סכום מחירי הצעדים $c(s,a,s')$ לאורך המסלול. פתרון אופטימלי הוא מסלול ממצב ההתחלה למצב מטרה בעל מחיר מינימלי.
  • הפשטה (Abstraction): הסרת פרטים לא רלוונטיים מייצוג המצבים והפעולות. הפשטה היא תקפה (Valid) אם ניתן להרחיב כל פתרון מופשט לפתרון בעולם המפורט, והיא מועילה (Useful) אם ביצוע כל פעולה מופשטת קל יותר מפתרון הבעיה המקורית.
  • חשיבות ניסוח הבעיה (דוגמת 8 המלכות): בניסוח נאיבי (הצבת 8 מלכות בכל משבצת בלוח) יש $\approx 1.8 \times 10^{14}$ מצבים. בניסוח חכם (הצבת מלכה בעמודה השמאלית הריקה ביותר כך שאינה מאוימת ע"י הקודמות) מרחב המצבים צונח ל-2,057 מצבים בלבד!

3.2 עץ חיפוש מול גרף ו-4 מדדי הערכה

⚠️ הבחנה קריטית למבחן – מצב (State) מול צומת (Node):
• מצב (State): קונפיגורציה של העולם הפיזי/הלוגי (למשל "הסוכן בעיר Arad").
• צומת (Node): מבנה נתונים בעץ החיפוש השומר 4 שדות: [state, parent, action, path-cost g(n)].
שני צמתים שונים בעץ החיפוש יכולים לייצג את אותו מצב אם הגענו אליו במסלולים שונים! במפת רומניה יש רק 20 מצבים, אך עץ החיפוש ללא סינון מעגלים הוא אינסופי.
  • חיפוש-עץ (`TREE-SEARCH`) מול חיפוש-גרף (`GRAPH-SEARCH`): בחיפוש-עץ שומרים רק את קבוצת העלים הפתוחים לפיתוח הנקראת החזית (`OPEN` / `frontier`). בחיפוש-גרף מוסיפים רשימה סגורה (`CLOSE` / `explored set`) (ממומשת כטבלת גיבוב ב-$O(1)$) הזוכרת כל מצב שכבר פותח כדי למנוע לולאות אינסופיות ועבודה כפולה.
  • 4 תכונות להערכת אלגוריתם חיפוש: (1) שלמות (האם מובטח שימצא פתרון כשקיים כזה?), (2) אופטימליות (האם מובטח שימצא את הפתרון הזול ביותר?), (3) סיבוכיות זמן (מספר הצמתים שנוצרים), (4) סיבוכיות מקום/זיכרון (מקסימום צמתים בזיכרון בו-זמנית).
    הפרמטרים: $b$ = מקדם הסתעפות מקסימלי, $d$ = עומק המטרה הרדודה ביותר, $m$ = אורך המסלול המקסימלי במרחב המצבים.

3.3 אסטרטגיות חיפוש חסרות ידע (עיוורות - Uninformed Search)

אלגוריתם מבנה החזית שלמות אופטימליות סיבוכיות זמן סיבוכיות מקום
BFS (לרוחב) תור FIFO כן (אם $b$ סופי) כן, אם מחיר כל צעד זהה $O(b^d)$ $O(b^d)$ (בעייתי!)
UCS (מונחה-מחיר) תור קדימויות לפי $g(n)$ כן (אם מחיר צעד $\ge \epsilon > 0$) כן (תמיד!) $O(b^{1+\lfloor C^*/\epsilon \rfloor})$ $O(b^{1+\lfloor C^*/\epsilon \rfloor})$
DFS (לעומק - עץ) מחסנית LIFO לא (לולאות/ענף אינסופי) לא $O(b^m)$ $O(b \cdot m)$ לינארי!
DLS (לעומק מוגבל $\ell$) מחסנית LIFO עד $\ell$ לא (אם $\ell < d$) לא $O(b^\ell)$ $O(b \cdot \ell)$
IDS (לעומק הולך וגדל) סדרת DLS ($\ell=0,1,2\dots$) כן (אם $b$ סופי) כן (במחיר צעד זהה) $O(b^d)$ $O(b \cdot d)$ לינארי!
דו-כיווני (Bidirectional) 2 תורי BFS מקבילים כן (אם שניהם BFS) כן (במחיר צעד זהה) $O(b^{d/2})$ $O(b^{d/2})$
📌 דגשים קריטיים לשאלות הבנה במבחן על חיפוש עיוור:
  • מתי בודקים את מבחן המטרה? ב-BFS בודקים אם צומת הוא מטרה ברגע שהוא נוצר (חוסך פיתוח רמה נוספת $O(b^{d+1})$). לעומת זאת, ב-UCS וב-$A^*$ חייבים לבדוק מבחן מטרה רק כאשר הצומת נשלף מהתור לפיתוח, כי המסלול הראשון שיוצר צומת מטרה עלול להיות יקר ולא אופטימלי!
  • למה IDS הוא החיפוש העיוור המועדף כשעומק הפתרון לא ידוע? כי הוא נהנה מסיבוכיות זיכרון לינארית $O(b \cdot d)$ כמו DFS, יחד עם שלמות ואופטימליות וזמן $O(b^d)$ כמו BFS (העלות החוזרת של פיתוח הרמות העליונות זניחה כי רוב הצמתים בעץ נמצאים ברמה האחרונה $d$: $(d)b + (d-1)b^2 + \dots + 1\cdot b^d = O(b^d)$).
  • Backtracking מול DFS רגיל: ב-Backtracking מייצרים רק בן עוקב אחד בכל פעם במקום את כל $b$ הבנים, מה שמקטין את הזיכרון מ-$O(b \cdot m)$ ל-$O(m)$ בלבד!

3.4 חיפוש מיודע (Informed Search): Greedy ו-A*

חיפוש מיודע משתמש בידע ספציפי על הבעיה באמצעות פונקציה יוריסטית $h(n)$ — אומדן (מחיר משוער) של המסלול הזול ביותר ממצב הצומת $n$ ועד למצב מטרה. תמיד מתקיים $h(n) \ge 0$ ולכל מצב מטרה $G$: $h(G) = 0$.

1. חיפוש חמדני (Greedy Best-First Search) פונקציית ההערכה מתחשבת רק בעתיד: $$f(n) = h(n)$$ מפתח תמיד את הצומת שנראה הכי קרוב למטרה.
• חסרונות: אינו אופטימלי, ואינו שלם בחיפוש-עץ (עלול להיתקע במבוי סתום/לולאה). זמן ומקום במקרה הגרוע: $O(b^m)$.
2. אלגוריתם החיפוש $A^*$ (כוכבית) משלב את העלות המדויקת מהשורש עד כה $g(n)$ (כמו UCS) עם העלות המשוערת למטרה $h(n)$ (כמו Greedy): $$f(n) = g(n) + h(n)$$ אומד את המחיר הכולל של המסלול הזול ביותר העובר דרך $n$. מפתח צמתים בסדר עולה של $f(n)$.

3.5 ★ קבילות, עקביות והוכחת האופטימליות של A*

1. קבילות (Admissibility) $\leftarrow$ חיפוש-עץ

יוריסטיקה $h(n)$ נקראת קבילה אם לכל צומת $n$ היא אינה מפריזה לעולם בהערכת המחיר האמיתי $h^*(n)$:

$$0 \le h(n) \le h^*(n)$$

דוגמה: מרחק אווירי בקו ישר הוא קביל כי הקו הישר הוא הקצר ביותר בין שתי נקודות. קבילות מבטיחה ש-$A^*$ אופטימלי בחיפוש-עץ!

2. עקביות / מונוטוניות (Consistency) $\leftarrow$ חיפוש-גרף

יוריסטיקה $h(n)$ נקראת עקבית אם לכל צומת $n$ ולכל בן עוקב $n'$ (בפעולה $a$) מתקיים אי-שוויון המשולש:

$$h(n) \le c(n, a, n') + h(n') \iff h(n) - h(n') \le c(n,a,n')$$

משמעות: ערכי $f(n)$ לאורך כל מסלול הם סדרה לא-יורדת ($f(n') \ge f(n)$). עקביות מבטיחה ש-$A^*$ אופטימלי בחיפוש-גרף ללא צורך לפתח מחדש צמתים מ-CLOSE!

🎯 טקטיקה חשובה למבחן: עקביות $\implies$ קבילות! (כל פונקציה עקבית היא בהכרח גם קבילה, בעוד ההפך לא תמיד נכון).
לכן, כשמבקשים במבחן להוכיח שיוריסטיקה היא גם עקבית וגם קבילה, תמיד התחילו מהוכחת עקביות!
דוגמה בבעיית האריחים (8-פאזל): עבור $h(n) =$ מספר האריחים שאינם במקומם, בכל צעד חוקי ($c=1$) מזיזים אריח אחד בלבד ולכן לכל היותר אריח אחד חוזר למקומו. מכאן: $h(n) - h(n') \le 1 \implies h(n) \le 1 + h(n')$. הוכחנו ש-$h$ עקבית, ומכך נובע מיידית שהיא גם קבילה!

📐 הוכחת האופטימליות של $A^*$ בחיפוש-עץ (9 שלבים):

נניח בשלילה ש-$G$ הוא מטרה אופטימלית ($f(G)=g(G)=C^*$) ו-$G_2$ הוא צומת מטרה לא-אופטימלי שמופיע בחזית ועומד להיבחר לפיתוח לפני צומת $n$ שנמצא בחזית על המסלול האופטימלי ל-$G$:
  1. f(G2) = g(G2)   [since h(G2) = 0]
  2. C* = f(G) = g(G)   [since h(G) = 0]
  3. g(G2) > g(G)   [G2 is suboptimal]
  4. f(G2) > C*   [from 1, 2, 3]
  5. h(n) ≤ h*(n)   [since h is admissible]
  6. g(n) + h(n) ≤ g(n) + h*(n)
  7. f(n) ≤ C*   [since n is on optimal path to G]
  8. f(n) ≥ f(G2)   [assumption: A* chose G2 over n]
  9. f(n) > C*   [from 4 and 8 — Contradiction to 7!]
החלשת דרישת האופטימליות ומשקלות דינמיים: כדי להאיץ את $A^*$ על חשבון אופטימליות מוחלטת, ניתן להגדיר: $$f_w(n) = (1-w)g(n) + w \cdot h(n), \quad 0 \le w \le 1$$ עבור $w=0$ נקבל UCS, עבור $w=0.5$ נקבל $A^*$ רגיל, ועבור $w=1$ נקבל Greedy Best-First. הפונקציה קבילה עבור $0 \le w \le 0.5$.
אלגוריתם $\epsilon$-קביל (מחזיר מסלול שעלותו לכל היותר $(1+\epsilon)C^*$) מתקבל ע"י משקלות דינמיים: $f_{dw}(n) = g(n) + h(n) + \epsilon\left(1 - \frac{d(n)}{N}\right)h(n)$, כאשר $N$ חסם עליון על עומק הפתרון.

3.6 חיפוש יוריסטי חסום בזיכרון (IDA*, RBFS, SMA*)

החיסרון הגדול של $A^*$ הוא צריכת הזיכרון האקספוננציאלית שלו. שלושת האלגוריתמים הבאים פותרים זאת:

1. אלגוריתם $IDA^*$ (Iterative-Deepening $A^*$): משלב את IDS עם $A^*$. במקום חסם עומק $\ell$, משתמשים בחסם על ערך $f(n)$:
• החסם ההתחלתי נקבע ל-$h(\text{start})$.
• בכל איטרציה מבצעים סריקת DFS וגוזמים כל ענף שבו $f(n) > \text{f-limit}$.
• אם לא נמצא פתרון, החסם באיטרציה הבאה מתעדכן לערך ה-$f$ המינימלי מבין הצמתים שחרגו מהחסם הקודם!
• יתרון: זיכרון לינארי! שלם ואופטימלי (כש-$h$ קבילה).
2. אלגוריתם RBFS (Recursive Best-First Search): אלגוריתם רקורסיבי בזיכרון לינארי $O(b \cdot d)$. שומר בכל שלב את ערך ה-$f$ של המסלול החלופי הטוב ביותר מכל האבות הקדמונים. אם הצומת הנוכחי חורג מהגבול החלופי, האלגוריתם נסוג לאחור (Backtrack) למסילה החלופית תוך שהוא מגבה אצל ההורה את ערך ה-$f$ הטוב ביותר בתת-העץ שננטש (למקרה שנרצה לחזור אליו בהמשך).
3. אלגוריתם $SMA^*$ (Simplified Memory-Bounded $A^*$): מנצל את כל הזיכרון הפנוי (במקום להסתפק בזיכרון לינארי קטן). מתקדם כמו $A^*$ עד שהזיכרון מתמלא. כשאין מקום: מוחק ("שוכח") את העלה הגרוע ביותר (בעל ה-$f$ הגבוה ביותר, ובמקרה של שוויון – הישן ביותר) ומגבה את ערכו אצל הוריו; ומפתח את העלה הטוב ביותר (בעל ה-$f$ הנמוך ביותר, ובשוויון – החדש ביותר). שלם ואופטימלי אם עומק הפתרון $d$ קטן מגודל הזיכרון הזמין.

3.7 בניית פונקציות יוריסטיות, שליטה ובעיות מוחלשות

  • שליטה / דומיננטיות (Dominance): בהינתן שתי יוריסטיקות קבילות $h_1, h_2$, נאמר ש-$h_2$ שולטת על $h_1$ אם לכל צומת $n$: $h_2(n) \ge h_1(n)$ (למשל ב-8-פאזל: מרחק מנהטן $h_2$ שולט על מספר האריחים שלא במקומם $h_1$).
    כלל ברזל: תמיד נעדיף יוריסטיקה קבילה עם ערכים גבוהים ככל האפשר (קרובים ל-$h^*$), כי כל צומת עם $f(n) < C^* \iff h(n) < C^* - g(n)$ מפותח ע"י $A^*$, ולכן $h$ גבוהה יותר מפתחת פחות צמתים!
  • שילוב מספר יוריסטיקות קבילות: אם $h_1, \dots, h_m$ כולן קבילות (ועקביות), אזי הפונקציה: $$h(n) = \max\{h_1(n), \dots, h_m(n)\}$$ היא בהכרח קבילה, עקבית, ושולטת על כולן! (זהירות: חיבור שלהן $h_1 + h_2$ אינו קביל באופן כללי כי הוא עלול לעבור את $h^*$).
  • דרגת הסיעוף האפקטיבית ($b^*$): מדד לאיכות היוריסטיקה. אם $A^*$ יצר $N$ צמתים למציאת פתרון בעומק $d$, אז $N+1 = 1 + b^* + (b^*)^2 + \dots + (b^*)^d$. ככל ש-$b^*$ קרוב ל-1, היוריסטיקה טובה יותר.
  • בעיות מוחלשות (Relaxed Problems): בעיה שמתקבלת מהבעיה המקורית ע"י הסרת חלק מהתנאים המקדימים (האילוצים) של הפעולות. מכיוון שרק הוספנו קשתות לגרף מרחב המצבים, המחיר של פתרון אופטימלי לבעיה המוחלשת הוא תמיד יוריסטיקה קבילה ועקבית לבעיה המקורית!
    ב-8-פאזל: (1) אם מותר להזיז אריח לכל משבצת סמוכה אפילו אם תפוסה $\leftarrow$ מקבלים את $h_2$ (מרחק מנהטן). (2) אם מותר להזיז אריח לכל מקום בלוח בצעד אחד $\leftarrow$ מקבלים את $h_1$ (מספר אריחים שלא במקומם).
  • מסדי נתונים של תבניות (Pattern Databases - PDBs): פותרים מראש בחיפוש לאחור תת-בעיות (למשל רק את האריחים 1-2-3-4) ושומרים את המרחקים בטבלת Lookup. במסדי נתונים זרים של תבניות (Disjoint PDBs) מחלקים את האריחים לקבוצות זרות וסופרים בכל תת-בעיה רק הזזות של אריחי אותה קבוצה — ואז מותר לחבר את הערכים ולקבל יוריסטיקה קבילה ומדויקת להפליא!

פרק 4: חיפוש מקומי ובעיות אופטימיזציה (Local Search)

טיפוס גבעה (Hill-Climbing), הדמיית חישול (Simulated Annealing), חיפוש קרן ואלגוריתמים גנטיים.

4.1 עקרונות החיפוש המקומי ותמונת הנוף

אלגוריתמי חיפוש מקומי מיועדים לבעיות שבהן המסלול למטרה אינו חשוב כלל, אלא רק מצב המטרה הסופי (כמו בעיית 8 המלכות, תכנון מעגלים משולבים, שיבוץ ותזמון). במקום לשמור עץ חיפוש, הם משתמשים בניסוח מצב מלא (Complete-State Formulation) (למשל ב-8 מלכות: כל 8 המלכות נמצאות על הלוח, אחת בכל עמודה, וכל צעד מזיז מלכה לשורה אחרת בעמודה שלה — $8 \times 7 = 56$ שכנים לכל מצב), ושומרים מצב נוכחי יחיד בזיכרון.

✅ שני יתרונות בולטים של חיפוש מקומי: 1. צריכת זיכרון זעירה וקבועה $O(1)$ (לא שומרים עץ ולא מסלול).
2. מוצאים פתרונות סבירים במהירות גם במרחבי מצבים עצומים או אינסופיים שבהם חיפוש שיטתי קורס.
❌ שלושת המכשולים ב"תמונת הנוף" (Landscape): 1. מקסימום מקומי (Local Maximum): פסגה נמוכה מהמקסימום הגלובלי שבה כל שכן גרוע מהמצב הנוכחי.
2. רכסים (Ridges): סדרת פסגות מקומיות שקשה לנווט בהן בצעדים בודדים.
3. שטחים מישוריים (Plateaux): אזור שטוח שבו לכל השכנים ערך זהה (עלול להיות מישור סופי או כתף - Shoulder שממנה ניתן להמשיך לעלות).

4.2 טיפוס גבעה (Hill-Climbing) ווריאנטים

  • טיפוס גבעה בסיסי (Steepest-Ascent Hill-Climbing): אלגוריתם חמדני מקומי. בכל שלב מפתח את כל השכנים של המצב הנוכחי ובוחר בשכן בעל הערך הטוב ביותר (במינימיזציה: $h(n)$ הקטן ביותר, כמו מספר זוגות המלכות המאיימות זו על זו). עוצר כאשר אין שכן שמשפר את המצב הנוכחי.
    הוספת צעדים הצידה (Sideways Moves): מתירים מעבר לשכן בעל ערך שווה למצב הנוכחי עד חסם קבוע (למשל עד 100 צעדים רצופים הצידה כדי לא להיתקע בלולאה אינסופית אם זה מקסימום מקומי שטוח ולא כתף). ב-8 מלכות זה מקפיץ את אחוז ההצלחה מ-14% ל-94%!
  • טיפוס גבעה סטוכסטי (Stochastic Hill-Climbing): בוחר באקראי מבין הצעדים המשפרים, כאשר ההסתברות לבחירת צעד פרופורציונית לתלילות השיפור שלו. מתכנס לאט יותר אך לעיתים מוצא מקסימום טוב יותר.
  • טיפוס גבעה עם בחירה ראשונה (First-Choice Hill-Climbing): כאשר מספר השכנים עצום (אלפים), במקום לחשב את כל השכנים, מגרילים שכנים אקראית בזה אחר זה ועוברים לשכן הראשון שמשפר את המצב הנוכחי.
  • טיפוס גבעה חוזר עם אתחול אקראי (Random-Restart Hill-Climbing): מריץ סדרה של חיפושי טיפוס גבעה ממצבים התחלתיים אקראיים עד למציאת מצב מטרה ("אם לא תצליח – נסה שוב").
    • האלגוריתם שלם בהסתברות ששואפת ל-1!
    • אם ההסתברות להצלחה בריצה בודדת היא $p$, תוחלת מספר הריצות היא $1/p$ (ב-8 מלכות ללא צעדים הצידה: $p \approx 0.14 \implies \approx 7$ ריצות), ותוחלת מספר הצעדים הכוללת היא: $$E[\text{steps}] = \text{Cost(success)} + \frac{1-p}{p} \cdot \text{Cost(failure)}$$

4.3 הדמיית חישול (Simulated Annealing) וחיפוש קרן (Beam Search)

1. הדמיית חישול (Simulated Annealing) משלב טיפוס גבעה (יעילות) עם הילוך אקראי (שלמות) בהשראת קירור מתכות ("ניעור כדור פינג-פונג החוצה מגומה מקומית"):
  • בכל שלב בוחרים שכן אקראי (לאו דווקא הטוב ביותר!).
  • אם הצעד משפר את המצב ($\Delta E > 0$) $\leftarrow$ מבצעים אותו תמיד (בהסתברות 1).
  • אם הצעד מרע את המצב ($\Delta E < 0$) $\leftarrow$ מבצעים אותו בהסתברות: $$P = e^{\Delta E / T}$$
  • הטמפרטורה $T$ מתחילה גבוהה ויורדת בהדרגה לפי פונקציית `SCHEDULE(t)`. אם $T$ יורדת לאט מספיק, האלגוריתם ימצא אופטימום גלובלי בהסתברות השואפת ל-1. (אם $T_0 \approx 0$, יתנהג כמו טיפוס גבעה ויתקע במינימום המקומי הראשון).
2. חיפוש קרן מקומי (Local Beam Search) שומר בזיכרון $k$ מצבים במקביל במקום מצב בודד:
  • מתחיל מ-$k$ מצבים אקראיים.
  • בכל צעד מייצר את כל העוקבים של כל $k$ המצבים יחד, ובוחר מתוך המאגר המשותף את $k$ הטובים ביותר.
  • במה הוא שונה מ-$k$ הרצות Random-Restart במקביל? בחיפוש קרן עובר מידע בין ההרצות! אם מצב אחד מגיע לאזור פורה, שאר הקרניים נוטשות אזורים גרועים ומצטרפות לאזור המוצלח.
  • חיסרון ופתרון: עלול לאבד שונות (כל $k$ המצבים מתרכזים באותו אזור). הפתרון: חיפוש קרן סטוכסטי (Stochastic Beam Search) שבוחרים $k$ עוקבים בהסתברות פרופורציונית לערכם.

4.4 אלגוריתמים גנטיים (Genetic Algorithms - GA)

וריאנט של חיפוש קרן סטוכסטי שבו מצבים חדשים נוצרים משילוב (זיווג) של שני הורים ולא משינוי של הורה יחיד.

שלבי האלגוריתם הגנטי:

  1. אוכלוסייה התחלתית: $k$ מצבים ("פרטים") המיוצגים כמחרוזות מעל אלפבית סופי (למשל ב-8 מלכות: מחרוזת של 8 ספרות מ-1 עד 8 כמו 24748552).
  2. פונקציית התאמה (Fitness Function): מדרגת כל פרט (ערכים גבוהים למצבים טובים). ב-8 מלכות: מספר זוגות המלכות שאינן מאיימות זו על זו (עבור פתרון מושלם: $\frac{8 \times 7}{2} = 28$).
  3. בחירה (Selection): בחירת זוגות הורים לרבייה בהסתברות יחסית ל-Fitness שלהם: $P(i) = \frac{\text{Fitness}(i)}{\sum_j \text{Fitness}(j)}$.
  4. הצלבה (Crossover): בחירת נקודת חיתוך אקראית במחרוזת ויצירת צאצאים המשלבים את החלק הראשון מהורה א' והחלק השני מהורה ב'. (בהתחלה עושה צעדים גדולים במרחב, ובהמשך צעדים קטנים כשהאוכלוסייה מתכנסת).
  5. מוטציה (Mutation): שינוי אקראי של ספרה במחרוזת בהסתברות קטנה מאוד. תפקיד המוטציה קריטי למניעת היתקעות במקסימום מקומי!

מושג הסכמה (Schema): תת-מחרוזת שבה חלק מהמיקומים קבועים והשאר גמישים (למשל 246*****). הצלבה יעילה כאשר ה-Schema מתאימה לרכיבים בעלי משמעות הקרובים זה לזה במחרוזת.

פרק 5: חיפוש בתנאי יריבות – משחקים (Adversarial Search)

אלגוריתם Minimax, גיזום אלפא-ביתא ($\alpha-\beta$ Pruning), פונקציות הערכה ואפקט האופק.

5.1 הגדרת משחק ואלגוריתם Minimax

בפרק זה אנו עוסקים במשחקי שני שחקנים (השחקן הפותח MAX ויריבו MIN) המשחקים לסירוגין בסביבה דטרמיניסטית, נראית במלואה (Perfect Information) ובסכום אפס (Zero-Sum) — כלומר מה שאחד מרוויח השני מפסיד.

  • הגדרה פורמלית של משחק: מצב התחלתי $S_0$, פונקציית תור $\text{Player}(s)$, מהלכים חוקיים $\text{Actions}(s)$, מודל מעברים $\text{Result}(s,a)$, מבחן סיום $\text{Terminal-Test}(s)$, ופונקציית תועלת $\text{Utility}(s,p)$ הנותנת ציון מספרי למצבי הסיום (העלים).
  • אלגוריתם Minimax: מבצע סריקת DFS מלאה של עץ המשחק ומפעפע ערכים מהעלים כלפי מעלה עד לשורש: $$\text{Minimax}(s) = \begin{cases} \text{Utility}(s) & \text{if Terminal-Test}(s) \\ \max_{a \in \text{Actions}(s)} \text{Minimax}(\text{Result}(s,a)) & \text{if Player}(s) = \text{MAX} \\ \min_{a \in \text{Actions}(s)} \text{Minimax}(\text{Result}(s,a)) & \text{if Player}(s) = \text{MIN} \end{cases}$$
  • תכונות Minimax: שלם (בעצים סופיים), אופטימלי מול יריב אופטימלי (אם MIN טועה ולא משחק אופטימלית, MAX ישיג תוצאה טובה לפחות כמו ערך המינימקס ואף יותר!). סיבוכיות מקום: $O(b \cdot m)$ (בגלל סריקת DFS), אך סיבוכיות הזמן היא $O(b^m)$ אקספוננציאלית (בשחמט $35^{100}$ – בלתי אפשרי ללא גיזום וחיתוך!).
  • הרחבה למשחקים מרובי שחקנים (Multiplayer): במקום ערך בודד, בכל צומת שומרים וקטור של ערכים $(v_A, v_B, v_C)$, ובכל תור השחקן שמשחק בוחר את המהלך שממקסם את הרכיב שלו בווקטור.

5.2 ★ גיזום אלפא-ביתא ($\alpha-\beta$ Pruning) ושיטת המעקב

גיזום אלפא-ביתא מוותר על פיתוח תת-עצים שלמים שאינם יכולים בשום אופן להשפיע על ההחלטה הסופית בשורש. הגיזום מחזיר תמיד בדיוק את אותו מהלך וערך כמו Minimax המלא!

משמעות הפרמטרים $\alpha$ ו-$\beta$ ותנאי הגיזום:

  • $\alpha$ (חסם תחתון של MAX): הערך הטוב ביותר (הגבוה ביותר) שנמצא עד כה בנקודת בחירה כלשהי של MAX לאורך המסלול מהשורש. מאותחל בשורש ל-$\alpha = -\infty$. רק צומת MAX רשאי לעדכן את $\alpha$!
  • $\beta$ (חסם עליון של MIN): הערך הטוב ביותר (הנמוך ביותר) שנמצא עד כה בנקודת בחירה כלשהי של MIN לאורך המסלול מהשורש. מאותחל בשורש ל-$\beta = +\infty$. רק צומת MIN רשאי לעדכן את $\beta$!
✂️ חוק הגיזום: ברגע שבצומת כלשהו מתקיים $\alpha \ge \beta$ (או בצומת MAX: $v \ge \beta$, ובצומת MIN: $v \le \alpha$) $\leftarrow$ מפסיקים מיד לפתח את שאר הבנים של הצומת הנוכחי (גוזמים אותם) וחוזרים להורה!

✍️ מתכון עבודה לפתרון תרגיל גיזום $\alpha-\beta$ במבחן:

  1. ירידה בעץ (שכפול חסמים): מתחילים בשורש עם $\alpha = -\infty, \beta = +\infty$. בכל פעם שיורדים מצומת הורה לבן שלו (בסדר DFS משמאל לימין), הבן יורש את ערכי $\alpha$ ו-$\beta$ הנוכחיים של אביו.
  2. בצומת מינימום ($\nabla$ MIN): כשחוזר ערך $v$ מבן, מעדכנים את ערך הצומת אם $v$ קטן יותר. בודקים: האם $v \le \alpha$?
    • אם כן $\leftarrow$ גוזמים את שאר הבנים הימניים של צומת זה! (כי האב MAX כבר מובטח לו לפחות $\alpha$ בענף אחר, ו-MIN כאן ייתן לו לכל היותר $v \le \alpha$).
    • אם לא $\leftarrow$ מעדכנים $\beta = \min(\beta, v)$ וממשיכים לבן הבא מימין.
  3. בצומת מקסימום ($\triangle$ MAX): כשחוזר ערך $v$ מבן, מעדכנים את ערך הצומת אם $v$ גדול יותר. בודקים: האם $v \ge \beta$?
    • אם כן $\leftarrow$ גוזמים את שאר הבנים הימניים של צומת זה! (כי האב MIN כבר מובטח לו לכל היותר $\beta$ בענף אחר, ו-MAX כאן ידרוש לפחות $v \ge \beta$).
    • אם לא $\leftarrow$ מעדכנים $\alpha = \max(\alpha, v)$ וממשיכים לבן הבא מימין.
function ALPHA-BETA-SEARCH(state) returns an action
    v := MAX-VALUE(state, -∞, +∞)
    return the action in ACTIONS(state) with value v

function MAX-VALUE(state, α, β) returns a utility value
    if TERMINAL-TEST(state) then return UTILITY(state)
    v := -∞
    for each a in ACTIONS(state) do
        v := MAX(v, MIN-VALUE(RESULT(state, a), α, β))
        if v ≥ β then return v   // Beta cutoff (pruning!)
        α := MAX(α, v)
    return v

function MIN-VALUE(state, α, β) returns a utility value
    if TERMINAL-TEST(state) then return UTILITY(state)
    v := +∞
    for each a in ACTIONS(state) do
        v := MIN(v, MAX-VALUE(RESULT(state, a), α, β))
        if v ≤ α then return v   // Alpha cutoff (pruning!)
        β := MIN(β, v)
    return v
  • השפעת סדר פיתוח הבנים על סיבוכיות $\alpha-\beta$:
    • בסידור אופטימלי ("סידור מושלם" – המהלך הטוב ביותר לכל שחקן נבחן ראשון): סיבוכיות הזמן צונחת מ-$O(b^m)$ ל-$O(b^{m/2})$! משמעות הדבר היא שדרגת הסיעוף האפקטיבית יורדת מ-$b$ ל-$\sqrt{b}$, ולכן ניתן להכפיל את עומק החיפוש באותו זמן חישוב!
    • בסידור אקראי: סיבוכיות הזמן היא $O(b^{3m/4})$.
    • בסידור הגרוע ביותר (אין גיזומים כלל): סיבוכיות הזמן נשארת $O(b^m)$.
    • כיצד מסדרים בנים בפועל (סידור יוריסטי)? בוחנים בשחמט קודם לקיחות/הכאות, אח"כ איומים (שח), אח"כ מהלכים קדימה ולבסוף אחורה; או נעזרים בתוצאות האיטרציה הקודמת של Iterative Deepening ובטבלאות טרנספוזיציה (Transposition Tables) השומרות הערכות של מצבים חוזרים.

5.3 החלטות זמן-אמת: פונקציית הערכה, אפקט האופק ו-Quiescence

מכיוון שלא ניתן לרדת עד העלים במשחקים אמיתיים, קלוד שאנון (Shannon) הציע שני שינויים באלגוריתם אלפא-ביתא: (1) החלפת `TERMINAL-TEST` במבחן חיתוך (`CUTOFF-TEST`) הקובע מתי לעצור את העמקת החיפוש, (2) החלפת `UTILITY` בפונקציית הערכה יוריסטית (`EVAL(s)`) האומדת את סיכויי הניצחון ממצב ביניים.

תכנון פונקציית הערכה (`EVAL`): לרוב מנוסחת כסכום לינארי ממושקל של תכונות (Features): $$\text{EVAL}(s) = w_1 f_1(s) + w_2 f_2(s) + \dots + w_n f_n(s)$$ (למשל בשחמט: חייל=1, פרש/רץ=3, צריח=5, מלכה=9; או ב-Tic-Tac-Toe: מספר השורות/עמודות/אלכסונים הפתוחים ל-MAX פחות אלו הפתוחים ל-MIN).
חיפוש עד רגיעה (Quiescence Search): אם נעצור בעומק קבוע באמצע סדרת הכאות של כלים, `EVAL` תיתן הערכה שגויה לחלוטין. לכן מפעילים את `EVAL` רק במצבים שקטים/יציבים (Quiescent), ובמצבים סוערים ממשיכים לפתח לעומק עד שהמצב מתייצב.
אפקט האופק (The Horizon Effect - "תופעת בת היענה"): מצב שבו נזק חמור ובלתי נמנע (כמו אובדן מלכה) עומד להתרחש, והמחשב מבצע מהלכי השהיה חסרי תועלת (כמו הקרבת חיילים לשח רגעי) רק כדי לדחות את האסון מעבר לאופק עומק החיפוש $d$, מתוך אשליה שאם הנזק מעבר לאופק – הוא נעלם!
גיזום קדימה (Forward Pruning) ו-ProbCut: גיזום ענפים שנראים חלשים עוד לפני פיתוחם (חיפוש קרן של $n$ המהלכים הטובים ביותר, או `ProbCut` שגוזם ענפים שבהסתברות גבוהה לפי סטטיסטיקות עבר ייפלו מחוץ לחלון $(\alpha, \beta)$).

פרק 6: בעיות סיפוק אילוצים (CSPs)

ניסוח פורמלי, הפצת אילוצים ואלגוריתם AC-3, חיפוש Backtracking ויוריסטיקות MRV, Degree ו-LCV.

6.1 הגדרת CSP וסוגי אילוצים

בניגוד לחיפוש בפרקים 3–5 שהתייחס לכל מצב כ"קופסה שחורה" אטומית, בבעיות סיפוק אילוצים (CSP) אנו מנצלים את הייצוג המחולק לגורמים (Factored) כדי לפסול חלקים עצומים ממרחב החיפוש מיד כשמזהים הפרת אילוץ, באמצעות יוריסטיקות כלליות שאינן תלויות בבעיה ספציפית.

ניסוח פורמלי של CSP כשלשה $\{X, D, C\}$:

  • $X = \{X_1, X_2, \dots, X_n\}$: קבוצת המשתנים (למשל שמות האזורים במפת אוסטרליה, או 8 עמודות המלכות $Q_1\dots Q_8$).
  • $D = \{D_1, D_2, \dots, D_n\}$: קבוצת תחומי הערכים (Domains) האפשריים לכל משתנה (למשל $\{\text{Red, Green, Blue}\}$).
  • $C = \{C_1, C_2, \dots, C_m\}$: קבוצת האילוצים המגדירה אילו צירופי ערכים מותרים לתתי-קבוצות של משתנים.

• השמה עקבית (חוקית): השמה שאינה מפרה אף אילוץ.  |  השמה שלמה: השמה שבה כל המשתנים קיבלו ערך.  |  פתרון ל-CSP: השמה שהיא גם שלמה וגם עקבית.

  • סוגי אילוצים:
    • אילוץ אונרי (Unary): מגביל משתנה יחיד (למשל $SA \neq \text{Green}$). מטופל מיד ע"י מחיקת הערך מה-Domain של אותו משתנה (עקביות צומת - Node Consistency).
    • אילוץ בינארי (Binary): מתייחס לזוג משתנים (למשל $SA \neq NSW$, או ב-8 מלכות $Q_i \neq Q_j \land |Q_i - Q_j| \neq |i - j|$). ניתן לייצוג כגרף אילוצים.
    • אילוץ גלובלי ($n$-ary): מערב מספר שרירותי של משתנים, והנפוץ ביותר הוא Alldiff (כל המשתנים בקבוצה חייבים לקבל ערכים שונים זה מזה, כמו בשורה/עמודה/ריבוע בסודוקו). הערה: כל אילוץ מסדר גבוה מעל תחומים סופיים ניתן להמרה לאילוצים בינאריים בעזרת משתני עזר!
    • אילוצי קדימות (Preference Constraints): אילוצים "רכים" המגדירים אילו פתרונות עדיפים (בעיות אופטימיזציה תחת אילוצים - COP).

6.2 ★ עקביות קשת ואלגוריתם AC-3

הגדרת עקביות קשת (Arc Consistency - AC):

קשת מכוונת $X_i \to X_j$ היא עקבית-קשת אם ורק אם לכל ערך $x \in D_i$ קיים לפחות ערך חוקי אחד $y \in D_j$ שמקיים את האילוץ הבינארי בין $X_i$ ל-$X_j$.
אם קיים ערך $x \in D_i$ שאין לו אף "בן זוג" חוקי ב-$D_j$, מוחקים את $x$ מהתחום $D_i$!

✍️ איך מריצים את אלגוריתם AC-3 במבחן (שלב-אחר-שלב):

  1. שלב 1 – טיפול באילוצים אונריים (עקביות צומת): עוברים על כל האילוצים של משתנה יחיד ומצמצמים מיד את ה-Domains ההתחלתיים ($D_A, D_B, \dots$).
  2. שלב 2 – רישום האילוצים הבינאריים והכנסת כל הקשתות לתור: לכל קשר בין שני משתנים (למשל $A$ ו-$B$) מכניסים לתור שתי קשתות מכוונות: גם $A \to B$ וגם $B \to A$!
  3. שלב 3 – לולאת AC-3: שולפים מראש התור קשת $X_i \to X_j$ ובודקים רק את הערכים ב-$D_i$:
    • אם לא נמחק אף ערך מ-$D_i$ $\leftarrow$ ממשיכים לקשת הבאה בתור.
    • אם נמחק ערך אחד או יותר מ-$D_i$ $\leftarrow$ חובה להוסיף לסוף התור את כל הקשתות ההפוכות $(X_k \to X_i)$ של כל השכנים $X_k$ שקשורים ל-$X_i$ (כי ייתכן שערכים ב-$X_k$ שהסתמכו על הערך שנמחק מ-$D_i$ איבדו כעת את תמיכתם!).
    • אם תחום $D_i$ התרוקן לחלוטין ($D_i = \emptyset$) $\leftarrow$ האלגוריתם עוצר מיד ומכריז שאין פתרון לבעיה!
  4. שלב 4 – סיבוכיות AC-3: אם יש $c$ קשתות (אילוצים בינאריים) וגודל התחום המקסימלי הוא $d$, בדיקת קשת בודדת לוקחת $O(d^2)$, וכל קשת יכולה להיכנס לתור לכל היותר $d$ פעמים, ולכן סה"כ סיבוכיות הזמן היא: $$O(c \cdot d^3)$$
  • מתי AC-3 אינו מספיק? (עקביות מסלול ו-$k$-עקביות): במשולש של 3 מדינות סמוכות (כמו $WA, NT, SA$) עם 2 צבעים בלבד $\{R, B\}$, כל הקשתות עקביות לפי AC-3 למרות שאין פתרון!
    • עקביות מסלול (Path Consistency / 3-consistency): בודקת שלכל זוג ערכים עקבי ב-$\{X_i, X_j\}$ קיים ערך מתאים במשתנה שלישי $X_m$.
    • גרף $k$-עקבי חזק (Strongly $k$-consistent): אם הוא $k$-עקבי, $(k-1)$-עקבי וכו' עד $1$-עקבי. אם גרף בעל $n$ משתנים הוא $n$-עקבי חזק, ניתן לפתור אותו ללא נסיגות כלל (Backtrack-free) בזמן $O(n^2 d)$, אך אכיפת $n$-עקביות דורשת זמן ומקום אקספוננציאליים ב-$n$.

6.3 חיפוש Backtracking ויוריסטיקות כלליות (MRV, Degree, LCV)

כאשר הפצת אילוצים (AC-3) מסתיימת ועדיין נותרו משתנים עם יותר מערך אחד ב-Domain שלהם, אנו מפעילים חיפוש לעומק עם נסיגה (Backtracking Search). בגלל ש-CSP היא קומוטטיבית (סדר הצבת המשתנים אינו משנה את התוצאה), בכל רמה בעץ בוחרים משתנה אחד בלבד להשמה, מה שמקטין את מספר העלים מ-$n! \cdot d^n$ ל-$d^n$.

1. יוריסטיקת MRV (בחירת משתנה) Minimum Remaining Values (נקראת גם Most Constrained Variable):
בוחרים להציב במשתנה שנותרו לו הכי מעט ערכים חוקיים ב-Domain שלו.
היגיון: "Fail-First" – אם יש משתנה שיוביל לכישלון, כדאי לגלות זאת מיד ולגזום את תת-העץ!
2. יוריסטיקת הדרגה (Degree Heuristic) משמשת כשובר שוויון עבור MRV (במיוחד בתחילת הריצה כשכל ה-Domains באותו גודל):
בוחרים במשתנה שמעורב בהכי הרבה אילוצים עם משתנים אחרים שטרם הושמו (דרגה מקסימלית בגרף האילוצים).
3. יוריסטיקת LCV (בחירת ערך) Least Constraining Value (הערך הכי פחות מאלץ):
לאחר שבחרנו משתנה, נבחר לנסות קודם את הערך שפוסל הכי מעט ערכים מה-Domains של השכנים שלו.
היגיון: להשאיר מקסימום גמישות להשמות הבאות כדי להצליח מהר!

6.4 בדיקה קדימה (Forward Checking) וחיפוש מקומי (Min-Conflicts)

  • בדיקה קדימה (Forward Checking - FC) מול AC-3 (MAC):
    • ב-Forward Checking, בכל פעם שמציבים ערך במשתנה $X$, עוברים רק על השכנים הישירים של $X$ שטרם הושמו ומוחקים מה-Domains שלהם ערכים שסותרים את ההשמה של $X$. זוהי בדיקה מהירה שמספקת את המידע הדרוש ליוריסטיקת MRV, אך היא לא מסתכלת מעבר לשכנים הישירים (ולכן לא תזהה ששני שכנים של $X$ נותרו שניהם עם אותו צבע יחיד בלבד!).
    • ב-MAC (Maintaining Arc Consistency) מריצים את אלגוריתם AC-3 המלא אחרי כל השמה בחיפוש, וכך מזהים חוסר עקביות מוקדם הרבה יותר.
  • חיפוש מקומי ל-CSP – יוריסטיקת מינימום סתירות (Min-Conflicts): מתחילים מהשמה שלמה לכל המשתנים (אפילו שהיא מפרה אילוצים). בכל צעד בוחרים אקראית משתנה שמעורב בסתירה, ומשנים את ערכו לערך שיוצר הכי מעט התנגשויות (סתירות) עם שאר המשתנים.
    • ביצועים מדהימים: פותר את בעיית $n$-המלכות (אפילו עבור $n = 1,000,000$ מלכות!) בזמן ריצה שהוא כמעט קבוע ובלתי תלוי ב-$n$! בנוסף, מצוין לבעיות דינמיות כמו שיבוץ טיסות שהשתבש ודורש תיקון מינימלי מהלוח הקיים.

פרק 7: סוכנים לוגיים ותחשיב הפסוקים (Logical Agents)

בסיס ידע (KB), נביעה לוגית ($\models$), הוכחה ברזולוציה, פסוקיות Horn, שרשור קדימה/אחורה, DPLL ו-WalkSAT.

7.1 בסיס ידע, נביעה לוגית, נאותות ושלמות

  • סוכן מבוסס-ידע (Knowledge-Based Agent): מורכב מבסיס ידע (KB - Knowledge Base) המאחסן פסוקים בשפה פורמלית, וממנגנון היסק (Inference Engine). ממשק הסוכן מבוסס על שתי פעולות: TELL (הוספת עובדה/פסוק ל-KB) ו-ASK (שליפת מסקנה/פעולה הנובעת מה-KB).
  • תחביר (Syntax) מול סמנטיקה (Semantics): התחביר מגדיר אילו רצפי סימנים הם פסוקים חוקיים בשפה; הסמנטיקה מגדירה את ערך האמת (True/False) של כל פסוק ביחס לכל מודל (Model - עולם אפשרי $m$).
  • נביעה לוגית (Entailment — $\text{KB} \models \alpha$): פסוק $\alpha$ נובע לוגית מ-$\text{KB}$ אם ורק אם בכל מודל שבו $\text{KB}$ אמיתי, גם $\alpha$ אמיתי (כלומר $M(\text{KB}) \subseteq M(\alpha)$).

היסק לוגי ($\text{KB} \vdash_i \alpha$): נאותות מול שלמות (הגדרות חובה למבחן!)

1. נאותות (Soundness / משמר אמת) אלגוריתם היסק הוא נאות אם כל פסוק שהוא מוכיח אכן נובע לוגית מבסיס הידע ("אינו ממציא שקרים"): $$\text{If } \text{KB} \vdash \alpha \text{ then } \text{KB} \models \alpha$$
2. שלמות (Completeness) אלגוריתם היסק הוא שלם אם הוא מסוגל להוכיח כל פסוק שנובע לוגית מבסיס הידע ("לא מפספס אף אמת"): $$\text{If } \text{KB} \models \alpha \text{ then } \text{KB} \vdash \alpha$$

7.2 תחשיב הפסוקים, CNF והוכחה ברזולוציה

  • בדיקת מודלים באמצעות טבלת אמת (`TT-ENTAILS?`): עוברת על כל $2^n$ השורות בטבלת האמת (עבור $n$ סימבולים) ובודקת שבכל שורה שבה $\text{KB}=\text{True}$, גם $\alpha=\text{True}$. האלגוריתם נאות ושלם, סיבוכיות מקום $O(n)$, אך סיבוכיות זמן $O(2^n)$.
  • תקפות (Validity) מול ספיקות (Satisfiability - SAT):
    • פסוק הוא תקף (Valid / טאוטולוגיה) אם הוא אמיתי בכל המודלים. (משפט הדדוקציה: $\alpha \models \beta \iff (\alpha \Rightarrow \beta)$ תקף).
    • פסוק הוא ספיק (Satisfiable) אם קיים לפחות מודל אחד שבו הוא אמיתי.
    • הקשר הדואלי והוכחה בדרך השלילה (Refutation): $\alpha$ תקף $\iff \neg \alpha$ אינו ספיק. לכן: $$\text{KB} \models \alpha \iff (\text{KB} \land \neg \alpha) \text{ is Unsatisfiable (סתירה!)}$$
  • צורה קוניונקטיבית נורמלית (CNF - Conjunctive Normal Form): פסוק הכתוב כקוניונקציה ($\land$) של פסוקיות (Clauses), כאשר כל פסוקית היא דיסיונקציה ($\lor$) של ליטרלים: $(L_{1,1} \lor L_{1,2}) \land (L_{2,1} \lor \neg L_{2,2})$.
  • כלל הרזולוציה ואלגוריתם הרזולוציה (`PL-RESOLUTION`): בהינתן שתי פסוקיות המכילות ליטרל משלים (אחת עם $\ell$ והשנייה עם $\neg \ell$), ניתן לגזור פסוקית חדשה (Resolvant) המכילה את איחוד כל שאר הליטרלים משתי הפסוקיות ללא הזוג המשלים: $$\frac{(\alpha \lor \ell), \quad (\beta \lor \neg \ell)}{\alpha \lor \beta}$$ כדי להוכיח $\text{KB} \models \alpha$, ממירים את $(\text{KB} \land \neg \alpha)$ ל-CNF ומפעילים רזולוציה עד שמתקבלת הפסוקית הריקה ($\emptyset$ / $\{\}$) המעידה על סתירה (ולכן המשפט הוכח!), או עד שלא ניתן לגזור פסוקיות חדשות (ואז $\alpha$ אינו נובע). אלגוריתם הרזולוציה הוא נאות ושלם!

7.3 פסוקיות Horn, שרשור קדימה (FC) ושרשור אחורה (BC)

פסוקית Horn: דיסיונקציה של ליטרלים שלכל היותר אחד מהם הוא חיובי (למשל $\neg A \lor \neg B \lor C$, השקול לגרירה $A \land B \Rightarrow C$).
פסוקית מוחלטת (Definite Clause): פסוקית Horn עם בדיוק ליטרל חיובי אחד. היא מהווה או עובדה (ליטרל יחיד $A$) או כלל ($A_1 \land A_2 \Rightarrow B$).

יתרון עצום: היסק עם פסוקיות Horn באמצעות שרשור קדימה או אחורה רץ בזמן לינארי $O(n)$ בגודל בסיס הידע!

1. שרשור קדימה (Forward Chaining - FC) • הנמקה מונחית-מידע (Data-Driven): מתחילים מהעובדות הידועות ב-KB.
• בכל פעם שכל ההנחות באגף שמאל של כלל מתקיימות, מוסיפים את המסקנה שבאגף ימין לרשימת העובדות הידועות, עד שמגיעים לשאילתה $q$ או שאין עובדות חדשות.
• חיסרון: עלול לגזור עובדות רבות שאינן רלוונטיות למטרה.
2. שרשור אחורה (Backward Chaining - BC) • הנמקה מונחית-מטרה (Goal-Directed): מתחילים מהשאילתה $q$ שאנו רוצים להוכיח.
• אם $q$ אינה עובדה ידועה, מחפשים כללים שמסקנתם היא $q$ ומנסים להוכיח רקורסיבית את תתי-המטרות שבאגף שמאל שלהם.
• יתרון: בוחן רק עובדות רלוונטיות למטרה, ולכן לרוב מהיר בהרבה מלינארי!

7.4 בדיקת מודלים יעילה (DPLL, WalkSAT) ובעיית המסגרת

1. אלגוריתם DPLL (שלם, מבוסס Backtracking) בודק ספיקות של נוסחת CNF באמצעות חיפוש לעומק עם 3 שיפורים מכריעים:
  • עצירה מוקדמת (Early Termination): פסוקית אמיתית ברגע שליטרל אחד בה אמיתי; הפסוק כולו שקרי ברגע שפסוקית אחת התרוקנה.
  • יוריסטיקת הליטרל הטהור (Pure Symbol): סימבול שמופיע בכל הפסוקיות שנותרו באותו סימן בלבד (רק חיובי או רק שלילי) מקבל מיד את הערך שהופך אותו ל-True!
  • פסוקית היחידה (Unit Clause) והפצת יחידה: פסוקית שנותר בה ליטרל יחיד שלא הושם מחייבת להציב בליטרל זה True, ומפיצה זאת לשאר הפסוקיות.
2. אלגוריתם WalkSAT (חיפוש מקומי, לא שלם) אלגוריתם חיפוש מקומי מהיר מאוד לבדיקת ספיקות (דומה ל-Min-Conflicts):
  • מתחיל מהשמת אמת/שקר אקראית לכל המשתנים.
  • בכל צעד בוחר אקראית פסוקית שעדיין אינה מסופקת.
  • בוחר ליטרל מתוך הפסוקית והופך את ערכו (Flip) באחת משתי דרכים (לפי הסתברות $p$): או צעד אקראי (רעש לשחרור ממינימום מקומי), או צעד חמדני הבוחר בליטרל שהיפוכו ימקסם את מספר הפסוקיות המסופקות.
🔄 בעיית המסגרת (The Frame Problem) ואקסיומות מצב עוקב: כאשר סוכן לוגי מתאר עולם המשתנה לאורך זמן באמצעות משתנים תלויי-זמן (Fluents, כגון $L_{1,1}^t$), כתיבת אקסיומות תוצאה מתארת רק מה שהשתנה, ושוכחת את כל מה שנשאר כשהיה. הוספת אקסיומות מסגרת לכל דבר שלא השתנה יוצרת פיצוץ במספר הפסוקים.
הפתרון (אקסיומות מצב עוקב - Successor-State Axioms): כותבים אקסיומה אחת לכל Fluent (במקום לכל פעולה): $$\text{Fluent is True at } t+1 \iff [\text{Action at } t \text{ caused it}] \lor [\text{It was True at } t \land \text{Action at } t \text{ did not undo it}]$$

פרקים 8–9: לוגיקה מסדר ראשון (FOL) והיסק לוגי

הצרנה ב-FOL, האחדה (Unification / MGU), 6 שלבי המרה ל-CNF, סקולמיזציה ורזולוציה עם Set of Support.

8.1 תחביר, סמנטיקה והצרנה בלוגיקה מסדר ראשון (FOL)

בעוד תחשיב הפסוקים מניח שהעולם מורכב מעובדות אטומיות בלבד, לוגיקה מסדר ראשון (FOL) מניחה שהעולם מורכב מ-3 אלמנטים: אובייקטים (עצמים), יחסים/פרדיקטים (מחזירים True/False), ופונקציות (מחזירות אובייקט!).

כללי ברזל להצרנה ב-FOL:

  • 1. כמת כולל ($\forall$ - "לכל") הולך תמיד עם גרירה ($\Rightarrow$):
    "כל ספניאל הוא כלב טוב": $\forall x \, (\text{Spaniel}(x) \Rightarrow \text{GoodDog}(x))$.
    מלכודת: לעולם אל תכתבו $\forall x (\text{Spaniel}(x) \land \text{GoodDog}(x))$ כי משמעותו שכל איבר ביקום הוא גם ספניאל וגם כלב טוב!
  • 2. כמת ישי ($\exists$ - "קיים") הולך תמיד עם קוניונקציה ($\land$):
    "ליעל יש כלב": $\exists x \, (\text{Dog}(x) \land \text{Has}(\text{Yael}, x))$.
    מלכודת: אל תכתבו $\exists x (\text{Dog}(x) \Rightarrow \text{Has}(\text{Yael}, x))$ כי גרירה זו תצא אמיתית באופן ריק עבור כל עצם בעולם שאינו כלב (כמו כיסא)!
  • 3. חוקי דה-מורגן לכמתים (היפוך כמתים בשלילה): $$\neg \forall x \, P(x) \equiv \exists x \, \neg P(x) \qquad \text{וגם} \qquad \neg \exists x \, P(x) \equiv \forall x \, \neg P(x)$$
  • 4. סמנטיקה של בסיסי נתונים (Database Semantics): כדי להימנע מכתיבת פסוקים מסורבלים עם אי-שוויונים, מערכות מסדי נתונים מניחות 3 הנחות: (א) הנחת שמות ייחודיים (כל קבוע מתייחס לאובייקט אחר), (ב) הנחת העולם הסגור (כל פסוק אטומי שלא ידוע כאמת נחשב לשקר), (ג) סגירות התחום (אין אובייקטים בעולם מלבד הקבועים הנתונים).

9.1 כללי הצבה לכמתים (UI, EI), האחדה ו-MGU

  • כלל ההצבה לכמת כולל (UI - Universal Instantiation): מ-$\forall v \, \alpha$ מותר להסיק את $\text{SUBST}(\{v/g\}, \alpha)$ לכל ביטוי קרקעי (ללא משתנים) $g$. ניתן להפעילו פעמים רבות.
  • כלל ההצבה לכמת ישי (EI - Existential Instantiation): מ-$\exists v \, \alpha$ מותר להסיק את $\text{SUBST}(\{v/k\}, \alpha)$ כאשר $k$ הוא קבוע Skolem חדש לחלוטין שלא הופיע עד כה בבסיס הידע. מופעל פעם אחת בלבד.
  • משפט הרברנד (Herbrand): אם פסוק נובע לוגית מ-KB ב-FOL, אז יש לו הוכחה סופית לאחר הצבת קבועים ומופעי פונקציות עד עומק סופי. אולם אם הפסוק אינו נובע, חיפוש ההוכחה עלול לרוץ לנצח — לכן הנביעה ב-FOL היא כריעה למחצה (Semidecidable)!

האחדה (Unification) והמאחד הכללי ביותר (MGU):

הפונקציה $\text{UNIFY}(p, q) = \theta$ מוצאת הצבת משתנים $\theta$ שהופכת את שני הביטויים $p$ ו-$q$ לזהים: $\text{SUBST}(\theta, p) = \text{SUBST}(\theta, q)$.
• MGU (Most General Unifier): המאחד שמטיל הכי פחות הגבלות על המשתנים. למשל עבור $\text{Knows}(\text{John}, x)$ ו-$\text{Knows}(y, z)$, ההצבה $\{y/\text{John}, x/z\}$ היא ה-MGU (היא כללית יותר מ-$\{y/\text{John}, x/\text{John}, z/\text{John}\}$).
• בדיקת הופעה (Occurs Check): לא ניתן לאחד משתנה $x$ עם ביטוי שמכיל את $x$ בתוכו! למשל, ניסיון לאחד את $P(x, x)$ עם $P(y, f(y))$ מוביל ל-$x = f(x)$, ולכן נכשל (FAIL).

9.2 ★ 6 שלבי ההמרה ל-CNF וסקולמיזציה

📋 מתכון 6 השלבים להמרת כל משפט ב-FOL לצורת CNF (חובה למבחן!):

  1. שלב 1 – סילוק גרירות ושקילויות: מחליפים כל $\alpha \Rightarrow \beta$ ב-$(\neg \alpha \lor \beta)$, וכל $\alpha \Leftrightarrow \beta$ ב-$((\neg \alpha \lor \beta) \land (\neg \beta \lor \alpha))$.
  2. שלב 2 – דחיפת סימני השלילה ($\neg$) פנימה עד לאטומים: משתמשים בכללי דה-מורגן: $\neg(A \land B) \equiv (\neg A \lor \neg B)$, $\neg(A \lor B) \equiv (\neg A \land \neg B)$, $\neg\neg A \equiv A$, ובהיפוך כמתים: $\neg \forall x P \equiv \exists x \neg P$ ו-$\neg \exists x P \equiv \forall x \neg P$.
  3. שלב 3 – סטנדרטיזציה של שמות משתנים (Standardize Variables): אם אותו שם משתנה מופיע תחת שני כמתים שונים באותו משפט, משנים את שמו באחד מהם (למשל $\forall x P(x) \lor \exists x Q(x)$ הופך ל-$\forall x P(x) \lor \exists y Q(y)$).
  4. שלב 4 – סקולמיזציה (Skolemization – סילוק כמתים ישיים $\exists$):
    • אם הכמת הישי $\exists y$ אינו נמצא בתוך הטווח של אף כמת כולל $\forall$ $\leftarrow$ מחליפים את $y$ בקבוע סקולם חדש (למשל $A$ או $SK_1$).
    • אם הכמת הישי $\exists y$ נמצא מימין לכמתים כוללים (למשל $\forall x \, \exists y \, \text{Loves}(x, y)$) $\leftarrow$ ה-$y$ תלוי ב-$x$! לכן חובה להחליף את $y$ בפונקציית סקולם חדשה של המשתנים הכוללים שלפניו: $\forall x \, \text{Loves}(x, F(x))$!
  5. שלב 5 – השמטת כמתים כוללים ($\forall$): מוחקים את כל הכמתים הכוללים $\forall$ (כל משתנה שנותר מובן כעת כמכומת בכמת כולל).
  6. שלב 6 – פילוג $\lor$ מעל $\land$ ופירוק לפסוקיות: מפעילים את חוק הפילוג $A \lor (B \land C) \equiv (A \lor B) \land (A \lor C)$ עד שהפסוק הוא קוניונקציה של פסוקיות. כל מחובר $\land$ הופך לשורה (פסוקית) נפרדת בבסיס הידע, ובתוך כל שורה נותנים שמות משתנים חדשים ($x_1, x_2, \dots$).

9.3 ★ הוכחה ברזולוציה ב-FOL ואסטרטגיות ייעול (Set of Support)

דוגמה מלאה לתרגיל רזולוציה (פרד הכלב ובעליו סם):

נתון בבסיס הידע ב-CNF: 1. collie(Fred), 2. master(Fred, Sam), 3. day(Sat), 4. ¬warm(Sat), 5. trained(Fred), 6. ¬spaniel(a) ∨ gooddog(a), 7. ¬collie(b) ∨ ¬trained(b) ∨ gooddog(b), 8. ¬gooddog(c) ∨ ¬master(c,d) ∨ ¬loc(d,e) ∨ loc(c,e), 9. ¬day(Sat) ∨ ¬warm(Sat) ∨ loc(Sam, Park), 10. ¬day(Sat) ∨ warm(Sat) ∨ loc(Sam, Museum).

שאילתה א': האם פרד במוזיאון? $\text{loc}(\text{Fred}, \text{Museum})$

מוסיפים את שלילת השאילתה כקבוצת התמיכה (Set of Support): 11. ¬loc(Fred, Museum) ומבצעים רזולוציה:

11. ¬loc(Fred, Museum)                                 [Negated Goal - Set of Support]
12. ¬gooddog(Fred) ∨ ¬master(Fred, d) ∨ ¬loc(d, Museum) [Res 11 & 8 with {c/Fred, e/Museum}]
13. ¬collie(Fred) ∨ ¬trained(Fred) ∨ ¬master(Fred, d) ∨ ¬loc(d, Museum) [Res 12 & 7 {b/Fred}]
14. ¬trained(Fred) ∨ ¬master(Fred, d) ∨ ¬loc(d, Museum) [Res 13 & 1]
15. ¬master(Fred, d) ∨ ¬loc(d, Museum)                  [Res 14 & 5]
16. ¬loc(Sam, Museum)                                   [Res 15 & 2 with {d/Sam}]
17. ¬day(Sat) ∨ warm(Sat)                               [Res 16 & 10]
18. ¬day(Sat)                                           [Res 17 & 4]
19. {} (Empty Clause - Contradiction!)                  [Res 18 & 3 -> Proven!]

שאילתה ב' (עם סקולמיזציה בשלילת המטרה): "האם יש מקום שכולם נמצאים בו?" $\exists x \forall y \, \text{loc}(y, x)$.
• שלילת השאילתה: $\neg \exists x \forall y \, \text{loc}(y,x) \equiv \forall x \exists y \, \neg \text{loc}(y,x)$.
• סקולמיזציה: מכיוון ש-$\exists y$ נמצא תחת $\forall x$, מחליפים את $y$ בפונקציית סקולם $\text{sk}(x)$ ומקבלים את הפסוקית: ¬loc(sk(x), x)!

אסטרטגיית רזולוציה כלל הפעולה האם שלמה?
רזולוציית יחידה (Unit Resolution) לפחות אחת משתי הפסוקיות בכל צעד חייבת להיות פסוקית יחידה (ליטרל בודד). מקצרת פסוקיות! לא כללית (שלמה רק עבור בסיסי ידע מטיפוס Horn).
קבוצת תמיכה (Set of Support - SoS) לפחות אחת משתי הפסוקיות נלקחת מקבוצת התמיכה $S$ (שלילת המטרה וצאצאיה), והתוצר מתווסף ל-$S$. כן! בתנאי שיתר הפסוקיות ($\text{KB} - S$) הן ספיקות (עקביות).
רזולוציית קלט (Input Resolution) לפחות אחת משתי הפסוקיות חייבת להיות מתוך הקלט המקורי ($\text{KB}$ או $\neg\text{Goal}$). לא כללית (שלמה רק עבור פסוקיות Horn).
רזולוציה לינארית (Linear Resolution) הרחבה של קלט: הפסוקית האחרונה שנגזרה מתאחדת עם פסוקית מהקלט המקורי או עם אב קדמון שלה. כן! שלמה תמיד.
סילוק הכלות (Subsumption) מחיקת פסוקיות שהן מקרה פרטי של פסוקית קיימת (אם קיים $P(x)$, נמחק את $P(A)$ ואת $P(A) \lor Q(B)$). משמרת שלמות ומקטינה את ה-KB.

פרק 10: תכנון קלאסי (Classical Planning)

שפת PDDL, תכנון כחיפוש קדימה ואחורה (Regression), גרפי תכנון (Planning Graphs), קשרי Mutex ואלגוריתם GRAPHPLAN.

10.1 הגדרת תכנון קלאסי ושפת PDDL

תכנון קלאסי עוסק במציאת סדרת פעולות (Plan) בסביבה דטרמיניסטית, סופית, סטטית ונראית במלואה. כדי להתמודד עם מרחבי מצבים עצומים שבהם חיפוש אטומי נכשל, משתמשים בשפת הייצוג PDDL (Planning Domain Definition Language):

  • ייצוג מצב והנחת העולם הסגור: כל מצב מיוצג כקוניונקציה של אטומים קרקעיים חיוביים בלבד (ללא משתנים, ללא שלילות וללא פונקציות!). לפי הנחת העולם הסגור (Closed-World Assumption), כל אטום שאינו מצוין במפורש במצב נחשב ל-False.
  • מצב מטרה: קוניונקציה של ליטרלים (חיוביים או שליליים) שאנו דורשים שיתקיימו (למשל $\text{At}(p_1, \text{JFK}) \land \neg \text{CleanHands}$).
  • סכימת פעולה (Action Schema): מגדירה משפחת פעולות באמצעות 3 חלקים:
    1. כותרת הפעולה והפרמטרים: למשל Fly(p, from, to).
    2. התנאי המקדים (PRECOND): קוניונקציה של ליטרלים שחייבים להתקיים במצב $s$ כדי שהפעולה תהיה חוקית לביצוע (Applicable).
    3. התוצאה (EFFECT): קוניונקציה של ליטרלים המתארת מה השתנה במצב. הליטרלים החיוביים מרכיבים את רשימת ההוספה (ADD list) והליטרלים השליליים מרכיבים את רשימת המחיקה (DEL list): $$\text{RESULT}(s, a) = (s - \text{DEL}(a)) \cup \text{ADD}(a)$$
// דוגמה לסכימת פעולה ב-PDDL (עולם הקוביות):
Action( Stack(x, y),
    PRECOND: Holding(x) ∧ Clear(y) ∧ Block(x) ∧ Block(y) ∧ (x ≠ y)
    EFFECT:  On(x, y) ∧ Handempty ∧ ¬Holding(x) ∧ ¬Clear(y) )
    // ADD(Stack) = {On(x,y), Handempty},  DEL(Stack) = {Holding(x), Clear(y)}

10.2 תכנון כחיפוש: קדימה (Progression) מול אחורה (Regression) ויוריסטיקות

1. חיפוש קדימה (Forward / Progression) מתחיל במצב ההתחלתי $S_0$ ומפעיל פעולות ישימות קדימה עד למטרה.
• חיסרון: דרגת הסתעפות עצומה כי בוחן גם פעולות שאינן רלוונטיות למטרה.
• יתרון: עם יוריסטיקות אוטומטיות חזקות מ-PDDL הוא יעיל מאוד!
2. חיפוש אחורה (Backward / Regression) מתחיל מתיאור המטרה $g$ ונסוג אחורה רק באמצעות פעולות רלוונטיות (פעולה שמוסיפה לפחות ליטרל אחד מ-$g$, ואינה מוחקת אף ליטרל מ-$g$: $\text{DEL}(a) \cap g = \emptyset$).
נוסחת הרגרסיה של מטרה $g$ דרך פעולה $a$: $$g' = \text{Regress}(g, a) = (g - \text{ADD}(a)) \cup \text{PRECOND}(a)$$
  • יצירת יוריסטיקות אוטומטיות ב-PDDL (בעיות מוחלשות):
    1. התעלמות מתנאים מקדימים (Ignore Preconditions): כל פעולה ניתנת לביצוע מיד.
    2. התעלמות מרשימות המחיקה (Ignore Delete Lists): מוחקים את כל הליטרלים השליליים מכל ה-EFFECT של הפעולות. כך שום פעולה אינה מקלקלת התקדמות של פעולות אחרות! מציאת הפתרון האופטימלי לבעיה מוחלשת זו נותנת יוריסטיקה קבילה (ואת הקירוב שלה מוצאים במהירות באמצעות טיפוס גבעה).

10.3 ★ גרפי תכנון (Planning Graphs), יחסי Mutex ואלגוריתם GRAPHPLAN

גרף תכנון הוא גרף מכוון בשכבות המתחלפות בין שכבת ליטרלים $S_i$ לשכבת פעולות $A_i$: $S_0 \to A_0 \to S_1 \to A_1 \dots$.
• $S_0$ מכילה את הליטרלים של המצב ההתחלתי.
• $A_i$ מכילה את כל הפעולות שהתנאים המקדימים שלהן מופיעים ב-$S_i$ (ללא Mutex ביניהם), ובנוסף פעולות התמדה (`No-Op` / Persistence) לכל ליטרל $C \in S_i$ המעבירות אותו ללא שינוי ל-$S_{i+1}$!
• הגרף נבנה בזמן ומקום פולינומיאליים: $O(n(a + l)^2)$.

⚡ יחסי מניעה הדדית (Mutex - Mutual Exclusion) בגרף התכנון (חובה למבחן!):

א. מתי שתי פעולות ב-$A_i$ הן Mutex? (3 מקרים):
  1. תוצאות סותרות (Inconsistent Effects): פעולה אחת מוסיפה ליטרל שהשנייה מוחקת (למשל $\text{Eat(Cake)}$ מוחקת $\text{Have(Cake)}$ בעוד $\text{No-Op}$ משמרת אותו).
  2. הפרעה (Interference): תוצאה (Effect) של פעולה אחת היא השלילה של תנאי מקדים (Precondition) של השנייה.
  3. צרכים מתחרים (Competing Needs): קיים תנאי מקדים של הפעולה הראשונה שהוא Mutex (בשכבה $S_i$) עם תנאי מקדים של הפעולה השנייה.
ב. מתי שני ליטרלים ב-$S_i$ הם Mutex? (2 מקרים):
  1. שלילה הדדית (Negated Literals): ליטרל אחד הוא השלילה המפורשת של השני ($P$ ו-$\neg P$).
  2. תמיכה לא עקבית (Inconsistent Support): כל זוג אפשרי של פעולות בשכבה הקודמת $A_{i-1}$ שמסוגל לייצר את שני הליטרלים הללו הוא Mutex! (מספיק שיש זוג פעולות אחד שאינו Mutex או פעולה אחת שמייצרת את שניהם – ואז הליטרלים אינם Mutex).

3 יוריסטיקות מגרף התכנון ואלגוריתם GRAPHPLAN:

עלות הרמה (level cost) של ליטרל מטרה $g_i$ היא מספר השכבה הראשונה $S_k$ שבה הוא מופיע. עבור קוניונקציית מטרות:

  • max-level: לוקחת את המקסימום מבין עלויות הרמה של ליטרלי המטרה. קבילה אך לא מדויקת (נמוכה מדי).
  • level-sum: מחברת את עלויות הרמה של ליטרלי המטרה. אינה קבילה אך עובדת מצוין בפועל כשמטרות בלתי תלויות.
  • set-level: מספר השכבה הראשונה $S_k$ שבה כל ליטרלי המטרה מופיעים יחד ואף זוג מהם אינו Mutex! קבילה ומדויקת הרבה יותר מ-max-level.

אלגוריתם GRAPHPLAN: מפתח את הגרף שכבה אחר שכבה. ברגע שכל ליטרלי המטרה מופיעים ב-$S_i$ ללא Mutex ביניהם, הוא מפעיל את `EXTRACT-SOLUTION` (חיפוש לאחור או CSP על הגרף). האלגוריתם מובטח לעצור כי כמות הליטרלים והפעולות עולה מונוטונית, וכמות ה-Mutexes וה-no-goods יורדת מונוטונית עד שהגרף מתייצב (Level-off).

פרקים 13–14: אי-ודאות ורשתות בייסיאניות (Bayesian Networks)

הסתברות ותועלת (MEU), תחביר וסמנטיקה של רשת בייסיאנית, אלגוריתם d-separation (מורליזציה) וחישוב הסתברויות.

13.1 לפעול בתנאי אי-ודאות, אי-תלות מותנה ועקרון MEU

  • מקורות אי-ודאות בעולם האמיתי: נראות חלקית, חיישנים רועשים, חוסר הבנה מלאה של חוקי העולם (כמו ברפואה), ומורכבות חישובית שלא מאפשרת מעקב מדויק אחר כל גורם. בניגוד ללוגיקה שבה פסוק הוא True/False, בהסתברות משייכים לכל עובדה מידת אמונה (Degree of Belief) מספרית ב-$[0,1]$ ביחס לידע של הסוכן.
  • תורת קבלת ההחלטות ועקרון MEU: $$\text{Decision Theory} = \text{Probability Theory (מהם הסיכויים?)} + \text{Utility Theory (מהן ההעדפות?)}$$ לפי עקרון מקסימום תוחלת התועלת (MEU - Maximum Expected Utility), סוכן הוא רציונלי אם ורק אם הוא בוחר בפעולה המניבה את תוחלת התועלת הגבוהה ביותר על פני כל התוצאות האפשריות.
  • התפלגות משותפת מלאה מול אי-תלות מותנה: טבלת ההתפלגות המשותפת המלאה עבור $n$ משתנים בוליאניים דורשת $2^n$ שורות (עבור $n=30$ מעל מיליארד מספרים!). הפתרון הוא ניצול אי-תלות מותנה (Conditional Independence):
    • אי-תלות מוחלטת: $P(X, Y) = P(X) \cdot P(Y) \iff P(X \mid Y) = P(X)$.
    • אי-תלות מותנה ($X$ ו-$Y$ בלתי תלויים בהינתן $Z$): $$P(X, Y \mid Z) = P(X \mid Z) \cdot P(Y \mid Z) \iff P(X \mid Y, Z) = P(X \mid Z)$$ (למשל: כאב שיניים `Toothache` ותפיסת מכשיר הרופא `Catch` תלויים זה בזה, אך בהינתן שאנו יודעים אם יש או אין חור בשן `Cavity`, הם הופכים לבלתי תלויים!).

14.1 מבנה רשת בייסיאנית, CPTs וקומפקטיות

תחביר וסמנטיקה של רשת בייסיאנית (נושא שמופיע בכל בחינה!):

  • תחביר (Syntax): גרף מכוון חסר מעגלים (DAG) שבו:
    1. כל צומת $X_i$ מייצג משתנה מקרי.
    2. קשת מכוונת $X \to Y$ מייצגת השפעה ישירה ("סיבתיות"): $X$ הוא הורה של $Y$.
    3. לכל צומת $X_i$ משויכת טבלת הסתברות מותנה (CPT - Conditional Probability Table) המגדירה את $P(X_i \mid \text{Parents}(X_i))$. אם לצומת בוליאני יש $k$ הורים בוליאניים, ה-CPT שלו מכילה $2^k$ שורות (ושורש ללא הורים מכיל שורה $2^0=1$ של ההסתברות הא-פריורית $P(X_i)$).
  • סמנטיקה – נוסחת המכפלה להתפלגות המשותפת (Chain Rule ברשת בייסיאנית): כל איבר בהתפלגות המשותפת המלאה מחושב כמכפלת הכניסות המתאימות בטבלאות ה-CPT של כל צמתי הרשת: $$P(x_1, x_2, \dots, x_n) = \prod_{i=1}^n P(x_i \mid \text{Parents}(X_i))$$
  • קומפקטיות (Compactness): אם לכל צומת ברשת בת $n$ צמתים יש לכל היותר $k$ הורים, גודל הרשת כולה חסום ע"י $O(n \cdot 2^k)$ (לינארי ב-$n$!) לעומת $\Omega(2^n)$ בטבלה המשותפת המלאה (למשל בדוגמת אבחון תקלות הרכב עם 6 משתנים: 28 מספרים במקום $2^6=64$, ובדוגמת הפריצה עם 5 משתנים: 10 מספרים במקום $2^5=32$).
  • חשיבות סדר הוספת הצמתים בבניית הרשת: כדי שהרשת תהיה דלילה וקומפקטית ככל האפשר, חובה להוסיף צמתים בסדר סיבתי (מהסיבות הראשוניות אל התוצאות). בחירת סדר הפוך יוצרת רשת חוקית אמנם, אך מסורבלת ועמוסה בקשתות מיותרות!

14.2 ★ אלגוריתם d-separation ומורליזציה לבדיקת אי-תלות מותנה

שאלה קלאסית במבחן: בהינתן גרף של רשת בייסיאנית, "האם המשתנים $X$ ו-$Y$ בלתי תלויים מותנה בהינתן קבוצת המשתנים הידועים $Z$ (ה-givens)?" (כלומר האם $P(X \mid Y, Z) = P(X \mid Z)$?).
להלן אלגוריתם 5 השלבים (המבוסס על גרף אנצסטרלי ומורליזציה) שפותר כל שאלת d-separation במבחן בצורה מכנית ונטולת טעויות:

🛠️ אלגוריתם 5 השלבים לבדיקת אי-תלות מותנה (d-separation) במבחן:

  1. שלב 1 – סרטוט הגרף האנצסטרלי (Draw ancestral graph): משאירים בגרף אך ורק את המשתנים הנשאלים ($X$ ו-$Y$), את המשתנים הנתונים ב-$Z$ (ה-givens), ואת כל האבות הקדמונים שלהם (Ancestors) (כל מי שיש ממנו מסלול מכוון אל $X, Y$ או $Z$). מוחקים את כל שאר הצמתים והקשתות מהגרף!
  2. שלב 2 – מורליזציה (Moralize – "נישואי הורים"): בגרף האנצסטרלי שנותר, לכל שני צמתים שהם הורים משותפים של אותו צומת בן, מותחים קשת חדשה ביניהם ("מחתנים את ההורים") אם הם עדיין אינם מחוברים.
  3. שלב 3 – ביטול כיווניות הקשתות (Disorient): מוחקים את ראשי החצים מכל הקשתות בגרף, כך שהגרף הופך לגרף לא-מכוון רגיל.
  4. שלב 4 – מחיקת הנתונים הידועים (Delete givens): מוחקים מהגרף את כל הצמתים השייכים לקבוצת הנתונים $Z$, ומוחקים יחד איתם את כל הקשתות שנוגעות בהם! (אם $Z = \emptyset$, לא מוחקים כלום בשלב זה).
  5. שלב 5 – קריאת התשובה מהגרף (Read the answer): בודקים האם נותר מסלול כלשהו שמחבר בין $X$ ל-$Y$ בגרף הסופי:
    • אם $X$ ו-$Y$ מנותקים (אין מסלול ביניהם) $\leftarrow$ הם מופרדים (d-separated) ובלתי תלויים מותנה בוודאות! (Yes).
    • אם $X$ ו-$Y$ מחוברים (יש מסלול ביניהם) $\leftarrow$ הם אינם מובטחים להיות בלתי תלויים (No – תלויים).
הגדרה שקולה באמצעות מסלולים: קבוצת צמתים $Z$ מפרידה (d-separates) בין $X$ ל-$Y$ אם ורק אם בכל מסלול לא-מכוון בין $X$ ל-$Y$ מתקיים לפחות אחד משני התנאים:
1. קיים במסלול צומת $v \in Z$ שלא שתי קשתות המסלול נכנסות אליו (כלומר שרשרת $A \to v \to B$ או פיצול $A \leftarrow v \to B$).
2. קיים במסלול צומת $v$ ששתי קשתות המסלול נכנסות אליו ($A \to v \leftarrow B$, נקרא תופעת Explaining Away / V-structure), כך שהצומת $v$ אינו ב-$Z$ וגם אף אחד מצאצאיו אינו ב-$Z$!

14.3 ★ חישוב הסתברויות ברשת בייסיאנית

1. כאשר כל משתני הרשת מופיעים בביטוי (הסתברות משותפת מלאה): פשוט כופלים את ההסתברויות המתאימות מתוך טבלאות ה-CPT!
למשל ברשת שבה $A, B$ הורים של $C$, ו-$C$ הורה של $D$, ו-$A, D$ הורים של $E$: $$P(\neg a, b, c, d, e) = P(\neg a) \cdot P(b) \cdot P(c \mid \neg a, b) \cdot P(d \mid c) \cdot P(e \mid d, \neg a)$$
2. כאשר חסרים חלק מהמשתנים (הסתברות שולית - Marginalization): משלימים את המשתנים החסרים על ידי פיצול לסכום של כל הצירופים הבוליאניים האפשריים שלהם: $$P(b, c, d, e) = P(a, b, c, d, e) + P(\neg a, b, c, d, e)$$
3. חישוב הסתברות מותנה $P(X \mid E)$: משתמשים בנוסחת ההסתברות המותנה (ובצמצום גורמים משותפים במונה ובמכנה לפני הצבת המספרים!): $$P(e \mid d, \neg a) = \frac{P(e, d, \neg a)}{P(d, \neg a)} = \frac{P(e, d, \neg a)}{P(e, d, \neg a) + P(\neg e, d, \neg a)}$$

פרק 17: קבלת החלטות מורכבות (MDPs)

תהליך החלטה מרקובי (MDP), מדיניות אופטימלית ($\pi^*$), נוסחת בלמן, Value Iteration ו-Policy Iteration.

17.1 הגדרת MDP, מדיניות ($\pi$) והפליית העתיד ($\gamma$)

בעיית קבלת סדרת החלטות בסביבה סטוכסטית ונראית במלואה עם מודל מעברים מרקובי ותגמולים מצטברים ממודלת כ-MDP (Markov Decision Process) המורכב מ-4 רכיבים:

  • $S$: קבוצת מצבים סופית (עם מצב התחלתי $s_0$ ומצבים סופיים Terminal states).
  • $\text{ACTIONS}(s)$: קבוצת הפעולות האפשריות במצב $s$ (למשל $\{\text{Up, Down, Left, Right}\}$).
  • מודל המעברים $P(s' \mid s, a)$: ההסתברות להגיע למצב $s'$ אם מבצעים פעולה $a$ במצב $s$. ההנחה המרקובית: ההסתברות תלויה אך ורק במצב הנוכחי $s$ ולא בהיסטוריית המצבים הקודמים! (למשל בעולם הרשת $4 \times 3$: סיכוי 0.8 לנוע לכיוון הרצוי, ו-0.1 לכל צד מאונך).
  • פונקציית התגמול $R(s)$: התגמול המיידי שהסוכן מקבל מעצם הימצאותו במצב $s$ (למשל $+1$ או $-1$ במצבי הסיום, ו-$-0.04$ בשאר המשבצות כדי לתמרץ הגעה מהירה למטרה).
  • מהו פתרון של MDP? מדיניות (Policy — $\pi$): בסביבה סטוכסטית סדרת פעולות קבועה מראש תיכשל ברגע שהסוכן יחליק למשבצת לא צפויה. לכן הפתרון ל-MDP הוא מדיניות $\pi(s)$ — פונקציה המתאימה לכל מצב $s$ את הפעולה המומלצת לביצוע בו. המדיניות שממקסמת את תוחלת התועלת נקראת המדיניות האופטימלית $\pi^*(s)$.
  • אופק סופי מול אופק אינסופי: באופק סופי (יש Deadline קבוע $N$) המדיניות האופטימלית היא תלוית-זמן (Nonstationary). באופק אינסופי (אין הגבלת זמן מראש) המדיניות האופטימלית היא קבועה (Stationary).
  • תגמולים מהוונים ומקדם הפליית העתיד (Discount Factor — $\gamma \in [0,1)$): כדי שהתועלת של סדרת מצבים אינסופית תהיה סופית ומוגדרת היטב (ולשקף העדפה של רווח מיידי על פני רווח עתידי), מגדירים את התועלת כסכום מהוון: $$U_h([s_0, s_1, s_2, \dots]) = R(s_0) + \gamma R(s_1) + \gamma^2 R(s_2) + \dots = \sum_{t=0}^\infty \gamma^t R(s_t) \le \frac{R_{\max}}{1 - \gamma}$$

17.2 ★ נוסחת בלמן ואלגוריתם Value Iteration (VI)

נוסחת בלמן (Bellman Equation) – הנוסחה המרכזית בפרק 17:

התועלת $U(s)$ של מצב (בהנחה שהסוכן פועל לפי המדיניות האופטימלית) שווה לתגמול המיידי של המצב ועוד תוחלת התועלת המהוונת של המצב הבא תחת הפעולה הטובה ביותר:

$$U(s) = R(s) + \gamma \max_{a \in \text{Actions}(s)} \sum_{s'} P(s' \mid s, a) U(s')$$

ובהינתן התועלות $U(s)$, המדיניות האופטימלית $\pi^*(s)$ מתקבלת על ידי:

$$\pi^*(s) = \arg\max_{a \in \text{Actions}(s)} \sum_{s'} P(s' \mid s, a) U(s')$$

✍️ איך פותרים תרגיל Value Iteration (VI) במבחן:

מכיוון שבנוסחת בלמן מופיע האופרטור הלא-לינארי $\max$, לא ניתן לפתור את מערכת $n$ משוואות בלמן אלגברית ישירות. אלגוריתם Value Iteration פותר אותן איטרטיבית:

  1. אתחול (איטרציה 0): מאתחלים את התועלת של כל המצבים הלא-סופיים ל-$U_0(s) = 0$ (ומצבים סופיים לערך התגמול שלהם, למשל $\pm 1$).
  2. עדכון בלמן סימולטני (Bellman Update): בכל איטרציה $i+1$, מחשבים לכל מצב את $U_{i+1}(s)$ על סמך הערכים $U_i(s')$ מהאיטרציה הקודמת: $$U_{i+1}(s) \leftarrow R(s) + \gamma \max_{a} \sum_{s'} P(s' \mid s, a) U_i(s')$$
  3. התכנסות: המידע "מפעפע" החוצה מהמצבים הסופיים/המתגמלים לשאר המרחב, ומובטח להתכנס לפתרון היחיד של משוואות בלמן!
דוגמה להרכבת משוואת בלמן: נתונים 4 מצבים $A, B, C, D$ ומקדם $\gamma = 0.8$. במצב $B$ אפשר או לחזור ל-$A$ ברווח מיידי של $\$10$, או להמשיך (בהסתברות $0.8$ נשאר ב-$B$ ובהסתברות $0.2$ עובר ל-$C$ ללא רווח מיידי). משוואת בלמן עבור $B$ תהיה: $$U(B) = \max\Big\{ 10 + \gamma \cdot U(A), \;\; 0 + \gamma \cdot [0.8 U(B) + 0.2 U(C)] \Big\}$$

17.3 אלגוריתם Policy Iteration (PI) והשוואה מול VI

אלגוריתם Policy Iteration (PI) מנצל את העובדה שהמדיניות $\pi$ הופכת לאופטימלית הרבה לפני שערכי ה-$U(s)$ מתכנסים לערכם המדויק. הוא מתחיל ממדיניות אקראית $\pi_0$ ומבצע לסירוגין שני צעדים:

  1. צעד 1 – הערכת מדיניות (Policy Evaluation): בהינתן המדיניות הקבועה הנוכחית $\pi_i$, הפעולה בכל מצב ידועה וקבועה, ולכן אין אופרטור $\max$! פותרים מערכת של $n$ משוואות לינאריות ב-$n$ נעלמים: $$U_i(s) = R(s) + \gamma \sum_{s'} P(s' \mid s, \pi_i(s)) U_i(s')$$
  2. צעד 2 – שיפור מדיניות (Policy Improvement): לכל מצב $s$, בודקים האם קיימת פעולה $a$ שנותנת תוחלת תועלת גבוהה יותר לפי $U_i$ מהפעולה הנוכחית $\pi_i(s)$. אם כן – מעדכנים את $\pi_{i+1}(s)$ לפעולה הטובה ביותר.
    • אם המדיניות לא השתנתה באף מצב ($\pi_{i+1} = \pi_i$) $\leftarrow$ עוצרים! הגענו למדיניות האופטימלית $\pi^*$!
קריטריון השוואה Value Iteration (VI) Policy Iteration (PI)
עלות איטרציה בודדת זולה ומהירה (רק חישוב $\max$ מקומי לכל מצב). יקרה ($O(n^3)$ לפתרון מערכת של $n$ משוואות לינאריות).
מספר איטרציות עד התכנסות רב (מתכנס אסימפטוטית לערכי $U$). מועט מאוד! מתכנס במספר קטן של צעדים.
מתי עדיף להשתמש? כאשר מספר המצבים $|S|$ גדול מאוד. כאשר $|S|$ קטן, או כאשר יש המון פעולות אפשריות בכל מצב.

פרק 18: למידה מדוגמאות (Learning from Examples)

סוגי למידה, עצי החלטה (DTL / ID3), חישוב אנטרופיה ו-Information Gain, התאמת יתר (Overfitting) ושכן קרוב (NN / IB3).

18.1 אופני למידה, סיווג מול רגרסיה והתער של אוקם

  • 3 סוגי הלמידה העיקריים (לפי סוג המשוב):
    1. למידה לא מפוקחת (Unsupervised Learning): הסוכן מקבל קלטים ללא תוויות פלט נכונות כלל, ומגלה תבניות ואשכולות בנתונים (כמו Clustering).
    2. למידה מחיזוקים (Reinforcement Learning): הסוכן לומד מסדרת תגמולים (חיזוקים חיוביים) ועונשים (חיזוקים שליליים) בעקבות פעולותיו בסביבה.
    3. למידה מפוקחת (Supervised Learning / למידה אינדוקטיבית): הסוכן מקבל קבוצת אימון (Training Set) של זוגות קלט-פלט מתויגים $(x, f(x))$, ומחפש פונקציית השערה $h \approx f$ שתכליל היטב על דוגמאות חדשות בקבוצת הבדיקה (Test Set).
  • סיווג (Classification) מול רגרסיה (Regression): כאשר טווח ערכי הפלט $f(x)$ הוא בדיד/סופי (למשל כן/לא, ספאם/תקין) – הבעיה נקראת סיווג. כאשר הפלט הוא רציף (למשל חיזוי טמפרטורה או מחיר מניה) – הבעיה נקראת רגרסיה.
  • התער של אוקם (Ockham's Razor): כאשר יש מספר השערות שעקביות עם קבוצת האימון (למשל קו ישר מול פולינום ממעלה 7 שעובר בכל הנקודות), נעדיף תמיד את ההשערה הפשוטה ביותר (למשל עץ ההחלטה הקטן ביותר), כי היא צפויה להכליל טוב יותר על נתונים חדשים.

18.2 ★ למידת עצי החלטה (DTL / ID3), אנטרופיה ו-Information Gain

עץ החלטה (Decision Tree) מייצג פונקציה המקבלת וקטור של ערכי תכונות ומחזירה החלטת סיווג: כל צומת פנימי בודק תכונה $A_i$, כל קשת מייצגת ערך אפשרי של התכונה, וכל עלה מכיל את סיווג הפלט.
• כושר ביטוי: עצי החלטה יכולים לבטא כל פונקציה בוליאנית! עבור $n$ תכונות בוליאניות יש $2^n$ שורות בטבלת האמת ולכן $2^{2^n}$ פונקציות/עצים שונים. מסיבה זו חיפוש העץ הקטן ביותר הוא NP-קשה, ואנו משתמשים באלגוריתם חמדני של הפרד-ומשול (DTL / ID3) הבוחר בכל שלב לפצל לפי התכונה הכי אינפורמטיבית.

📐 נוסחאות האנטרופיה ותוספת האינפורמציה (חובה בכל מבחן!):

  • 1. אנטרופיה (Entropy – מידת ההפתעה / אי-הוודאות בצומת): $$H(V) = \text{Entropy}(S) = -\sum_{i=1}^k P(v_i) \log_2 P(v_i) = \sum_{i=1}^k P(v_i) \log_2 \left(\frac{1}{P(v_i)}\right)$$ עבור סיווג בינארי עם $p$ דוגמאות חיוביות ו-$n$ דוגמאות שליליות: $$B\left(\frac{p}{p+n}\right) = -\frac{p}{p+n}\log_2\left(\frac{p}{p+n}\right) - \frac{n}{p+n}\log_2\left(\frac{n}{p+n}\right)$$ • כאשר הצומת הומוגני לחלוטין (כולם חיוביים או כולם שליליים) $\leftarrow$ אין אי-ודאות: $\text{Entropy} = 0$ (עלה!).
    • כאשר הצומת חצוי בדיוק $50\% / 50\%$ ($p=n$) $\leftarrow$ אי-ודאות מקסימלית: $\text{Entropy} = 1$.
  • 2. שארית האנטרופיה המשוקללת ($\text{Remainder}(A)$) לאחר פיצול לפי תכונה $A$: אם תכונה $A$ מפצלת את המדגם ל-$d$ תתי-קבוצות (ובכל תת-קבוצה $k$ יש $p_k$ חיוביים ו-$n_k$ שליליים): $$\text{Remainder}(A) = \sum_{k=1}^d \frac{p_k + n_k}{p + n} \cdot B\left(\frac{p_k}{p_k + n_k}\right)$$
  • 3. תוספת האינפורמציה (Information Gain): $$\text{Gain}(A) = \text{Entropy}(S) - \text{Remainder}(A)$$ האלגוריתם בוחר בשורש (ובכל תת-עץ) את התכונה $A$ בעלת ה-$\text{Gain}(A)$ המקסימלי, שזה שקול לחלוטין לבחירת התכונה בעלת ה-$\text{Remainder}(A)$ (האנטרופיה המשוקללת) המינימלי!

🍦 דוגמה חישובית לבניית עץ החלטה (סיווג מעדני חלב):

נתונות 14 דוגמאות של מעדני חלב. מתבוננים בתכונה "שומן" שמחלקת את 14 הדוגמאות ל-3 ענפים:
• גבוה (6 דוגמאות): 4 אוהב, 2 לא אוהב $\implies H(\text{גבוה}) = -\frac{2}{6}\log_2\frac{2}{6} - \frac{4}{6}\log_2\frac{4}{6}$.
• בינוני (4 דוגמאות): 2 אוהב, 2 לא אוהב (חצי-חצי!) $\implies H(\text{בינוני}) = 1$.
• נמוך (4 דוגמאות): 2 אוהב, 2 לא אוהב (חצי-חצי!) $\implies H(\text{נמוך}) = 1$.
האנטרופיה המשוקללת של התכונה "שומן": $$\text{Remainder(שומן)} = \frac{6}{14}\left(-\frac{1}{3}\log_2\frac{1}{3} - \frac{2}{3}\log_2\frac{2}{3}\right) + \frac{4}{14}(1) + \frac{4}{14}(1) = 0.965$$ מחשבים כך עבור כל התכונות ("טעם", "קצפת", "סוכר", "תוספות"). התכונה "טעם" מקבלת את האנטרופיה המשוקללת הנמוכה ביותר (ה-Gain הגבוה ביותר), ולכן נבחרת להיות שורש עץ ההחלטה, והטבלה מתפצלת ל-4 תתי-טבלאות לפי הטעמים (וניל, שוקו, פירות, אחר) שעליהן חוזרים רקורסיבית!

18.3 התאמת יתר (Overfitting), גיזום ואימות צולב (Cross-Validation)

  • בעיית התכונות מרובות הערכים ו-Overfitting: מדד תוספת האינפורמציה (Gain) נוטה להעדיף באופן מוטה תכונות שיש להן המון ערכים אפשריים שונים (למשל תכונת "תאריך" או "מספר סידורי" שבה לכל דוגמה יש ערך ייחודי – ה-Remainder שלה יהיה 0 וה-Gain מקסימלי, אך העץ שייווצר לא יכליל כלל!).
    התאמת יתר (Overfitting): מצב שבו העץ לומד את ה"רעש" הספציפי של קבוצת האימון — ככל שמספר הצמתים בעץ גדל, הדיוק על קבוצת האימון עולה ל-100%, אך הדיוק על קבוצת הבדיקה (Test Set) יורד!
  • כיצד מונעים Overfitting? גיזום עץ ההחלטה (Pruning): בונים את העץ המלא בעזרת DTL, ואז עוברים מלמטה למעלה על צמתי בדיקה שכל צאצאיהם הם עלים. אם הפיצול בצומת אינו מובהק סטטיסטית (תוספת האינפורמציה שלו קרובה ל-0 והיחס $\frac{p}{p+n}$ בתתי-הקבוצות זהה ליחס בצומת האב) — גוזמים את הצומת ומחליפים אותו בעלה עם סיווג הרוב!
  • מקרי קצה בעצי החלטה:
    • רעש בנתונים (שתי דוגמאות עם אותן תכונות בדיוק אך סיווג שונה): כשנגמרו התכונות לפיצול, העלה מחזיר את ערך הרוב (Majority Value) של הדוגמאות שנפלו אליו.
    • עלה ריק (אין בדוגמאות האימון אף מופע לערך מסוים של התכונה): העלה מחזיר כברירת מחדל את סיווג הרוב של צומת האב שלו.
    • תכונות רציפות: ביצוע דיסקרטיזציה (נקודות חתך, למשל $\text{Temp} > 25$).
  • הערכת ביצועי השערה (Holdout ו-$k$-Fold Cross-Validation): תחת הנחת i.i.d (דוגמאות בלתי תלויות ובעלות התפלגות זהה), מודדים את שיעור השגיאה על קבוצת בדיקה נפרדת (Holdout Cross-Validation). כדי לנצל את כל הנתונים בצורה מיטבית משתמשים ב-$k$-Fold Cross-Validation (בדרך כלל $k=5$ או $k=10$): מחלקים את המדגם ל-$k$ תתי-קבוצות שוות, מריצים $k$ פעמים כשבכל פעם $\frac{1}{k}$ משמש כקבוצת בדיקה ו-$\frac{k-1}{k}$ כקבוצת אימון, וממצעים את הציון.

18.4 סיווג מבוסס דוגמאות: השכן הקרוב (Nearest Neighbor) ו-IB3

בניגוד לעצי החלטה שבונים מראש ייצוג מופשט מכל הדוגמאות, בלמידה מבוססת דוגמאות (Instance-Based Learning) שומרים את דוגמאות האימון עצמן ומשתמשים בהן לסיווג דוגמאות חדשות:

  • 1. סיווג השכן הקרוב ביותר (Nearest Neighbor - NN): בהינתן דוגמה חדשה $x$ שאינה מסווגת, מחשבים את המרחק שלה מכל דוגמה מתויגת $y$ במאגר במרחב התכונות: $$d(x, y) = \sqrt{\sum_{i=1}^n h(a_i(x), a_i(y))^2}$$ (כאשר לתכונות מספריות $h = a_i(x) - a_i(y)$, ולתכונות בדידות/סמליות $h=0$ אם הן שוות ו-$h=1$ אם הן שונות). הדוגמה החדשה מקבלת את הסיווג של הדוגמה הקרובה אליה ביותר!
  • 2. אלגוריתם IB3 (למידה הדרגתית וחיסכון בזיכרון): כדי לא לשמור את כל הדוגמאות בזיכרון וכדי לסנן רעש, אלגוריתם IB3 שומר במאגר רק דוגמאות שעליהן המסווג הנוכחי טועה, ומנהל לכל דוגמה שמורה היסטוריית הצלחה סטטיסטית: דוגמאות שדיוקן גבוה מובהק מסומנות כקבילות ומשתתפות בסיווג, ודוגמאות שדיוקן נמוך מובהק (רעש) נמחקות מהמאגר.

בהצלחה רבה במבחן במבוא לבינה מלאכותית (20551)! 🎓🚀

סיכום מקיף של כל פרקי הקורס, האלגוריתמים ושיטות הפתרון למבחן.