הצגת המקור של הדף "חרטה (תורת ההחלטות)"

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

==חרטה של סדרות תוצאות והחלטות==

נניח שתהליך מייצר סדרת תוצאות מספריות: ביחידת הזמן ה-<math>i</math>, התוצאה היא <math>x_i</math>. [[אלגוריתם מקוון]] משתמש במספרים שהתקבלו כדי לקבל החלטה <math>b_i = b_i(x_1, \ldots, x_{i - 1})</math> בתחילת יחידת הזמן ה-<math>i</math>. לאחר שהאלגוריתם מכריז על <math>b_i</math>, מתבררת התוצאה <math>x_i</math>. נניח שישנה פונקציה 
<math>P(x, b)</math> המודדת את התועלת מהפעולה היא <math>b</math> של התוצאה <math>x</math>. 

החרטה של סדרת ההחלטות <math>b_1, b_2, \ldots, b_n</math> יחסית לסדרת החלטות אפשרית אחרת <math>\hat{b}_1, \hat{b}_2, \ldots, \hat{b}_n</math>, מוגדרת כהפרש <center><math>\sum_{i = 1}^n \left[ P(x_i, \hat{b}_i) - P(x_i, b_i) \right]</math></center>.

== דוגמאות ==

=== השקעה בתיק מניות===

בשוק המניות יש <math>m</math> מניות. הווקטור  <math>x_i</math> מציין את העלייה בערכי המניות ביום ה-<math>i</math> (למשל <math>x_{i, j} = 2</math> אם המניה ה-<math>j</math> הכפילה את ערכה ביום <math>i</math>, ואילו <math>x_{i, j} = 0</math> אם המניה ה-<math>j</math> אבדה את כל ערכה). 

השקעה בשוק זה היא וקטור שבו כל איבר <math>b_{i j}</math> הוא החלק שנוטלת המניה ה-<math>j</math> מתיק ההשקעות ביום ה- <math>i</math>. התועלת היא קצב הצטברות הרווחים, <math>\log(x_i \cdot b_i)</math>. נניח שאלגוריתם ההשקעה משקיע בכל יום לפי היסטוריית השוק, כלומר וקטור ההשקעה הוא <math>b_i = b_i(x_1, \ldots, x_{i - 1})</math>, ונשווה אותו לאלגוריתם השקעה פסיבי <math>\hat{b}_1 = \hat{b}_2 = \cdots = \hat{b}</math>, המשקיע כל יום לפי תיק קבוע <math>\hat{b}</math>. לפי הגדרות אלה, החרטה שבהשקעה לפי האלגוריתם יחסית בהשקעה הפסיבית היא <math>\sum_{i = 1}^n \left[ \log(\hat{b} \cdot x_i) - \log(b_i \cdot x_i) \right].</math>.

===חיזוי תוצאת תנאי תוכנה===

ב[[מדעי המחשב]] המעשיים ישנה בעיה של [[עיבוד מקבילי#"צינור" (pipeline)|חיזוי תנאי תוכנה]]. כאשר בתוכנה כתוב תנאי כלשהו, הפקודה הבאה שתתבצע עשויה להיות תלויה בתוצאת התנאי. מחשבים מודרניים מנסים לנחש מראש את תוצאת התנאי, כדי לטעון את הפקודות הבאות מהזיכרון. נוכל למדל זאת באופן הבא.

כל תוצאת תנאי היא <math>x_i \in \{0, 1\}</math>. אלגוריתם חוזה את התוצאה הבאה
<math>b_i = b_i(x_1, \ldots, x_{i - 1}) \in \{0, 1\}</math>. 

במקרה זה, נגדיר את תועלת הנחוש כ-<math>p(x, b) = 1 - |b - x|</math>, כלומר 1 אם הניחוש הצליח, ו-0 אם לא.

החרטה בהשוואה לסדרת ניחושים 
<math>\hat{b}_1, \dots, \hat{b}_4 = 1</math> היא <math>\sum_{i = 1}^n \left[ |b_i - x_i| - |\hat{b}_i - x_i|  \right].</math>.

==הגדרות נוספות==

חרטה אפשר למדוד בהשוואה לתוחלת של סדרת התוצאות (אם לתהליך <math>X</math> יש התפלגות המייצרת את סדרת התוצאות, החרטה היא <math>E\left[ \sum_{i = 1}^n \left[ P(x_i, \hat{b}_i) - P(x_i, b_i) \right] \right].</math>). אפשרות אחרת היא מדידה של התוצאה בהשוואה לסדרת התוצאות הגרועה ביותר:
<math>\max_{x_1, \ldots, x_n}\left[ \sum_{i = 1}^n \left[ P(x_i, \hat{b}_i) - P(x_i, b_i) \right] \right]</math>.

אפשרות נוספת היא להגדיר את החרטה כממוצע (בזמן) של אחד הביטויים הקודמים, דהיינו תוחלת או מקסימום של
<math>\frac{ \sum_{i = 1}^n \left[ P(x_i, \hat{b}_i) - P(x_i, b_i) \right]}{n}</math>.

==חרטה פנימית וחיצונית ==

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

אם יש אלגוריתם לבעיית החרטה החיצונית ניתן להמירו, על ידי רדוקציה, לאלגוריתם מקוון ויעיל לבעיית החרטה הפנימית. הרדוקציה היא ממצב של '''מידע מלא''', בו פעולה שנבחרה על ידי היריב נחשפת אחרי כל מקטע זמן, למצב של '''מידע חלקי''', בו אחרי כל מקטע זמן ניתן לדעת רק עד כמה משתלמת הפעולה הנבחרת. רדוקציה זו אינה כרוכה בהגדלת החרטה החיצונית.

בהינתן רצף החלטות
<math>b_1, \ldots, b_n</math>
אשר כל אחת מהן יכולה לקבל <math>m</math> ערכים שונים, ה'''חרטה הפנימית''' מוגדרת כמקודם, אלא ששוקלים רק חרטה יחסית לסדרה
<math>\hat{b}_1, \ldots, \hat{b}_n</math>
הנקבעת באופן הבא. בוחרים שני סוגי פעולות 
<math>i', j' \in \{1, \ldots, m\}</math>,
ומחליפים כל פעולה מסוג <math>i'</math> בסדרה המקורית בפעולה מסוג <math>j'</math>.

===דוגמה: חרטה פנימית במירוץ סוסים===

באופן דומה ל[[#דוגמה: השקעה בתיק מניות|דוגמה בהשקעה בתיק מניות]], נניח סדרת מרוצי סוסים שבכל אחד מהם יש (אותם) <math>m</math> סוסים. בכל מרוץ 
<math>i</math>,
הווקטור <math>x_i</math> מציין את הניצחון: זהו וקטור שבו כל האיברים הם 0, למעט איבר יחיד שהוא 1 (האיבר המתאים לסוס הזוכה). 

גם כאן נניח שהימור הוא וקטור שבו האיבר ה-<math>j</math>, כלומר 
<math>b_{i j}</math>,
מציין את חלק ההשקעה של התיק ביום <math>i</math> בסוס <math>j</math> (כל רכיב כזה הוא לא-שלילי, וסכום הרכיבים בכל יום שווה ל-1), ונגדיר את תועלת ההימור כקצב הכפלת הכסף, או <math>\log(x_i \cdot b_i)</math> (גם כאן זו אינה האפשרות היחידה).

החרטה הפנימית היא 
<math display="block">\sum_{i = 1}^n \left[ \log(\hat{b}_i \cdot x_i) - \log(b_i \cdot x_i) \right].</math>
כאשר הסדרה
<math>\hat{b}_1, \ldots, \hat{b}_n</math>
מושגת על ידי החלפת כל הימור על סוס <math>i'</math> בהימור על סוס <math>j'</math>.

== חרטה חיצונית ==

בהינתן <math>N</math> פעולות, נתון אלגוריתם הבוחר באופן הסתברותי פעולה יחידה כל מקטע זמן. לאחר כל מקטע זמן מוצג מה הוא ההפסד בעקבות הבחירה הנ"ל. ננסה למצוא אלגוריתם אדפטיבי היכול ללמוד את דינמיקת המערכת רבת-המשתמשים.

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

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

קטגוריה שנייה למדיניות חלופית היא זו המציעה שינוי פשוט לסדרת הפעולות המקוונות לפי חוק התאמה. '''החרטה החלופית''' מאפשרת לשנות את סדרת הפעולות המקוונת על ידי החלפת פעולה <math>i</math> לפעולה <math>j</math>. ההבדל בין החרטה החלופית לחרטה הפנימית היא שמדיניות החרטה הפנימית היא שניתן להחליף פעולה אחת בפעולה אחרת בעוד חרטה חלופית מאפשרת להחליף אוסף של <math>N</math> פעולות ב-<math>N</math> פעולות אחרות.
החרטה החלופית חסומה על ידי <math>O(\sqrt T \cdot N \cdot log(N)) </math> כאשר T הוא מספר מקטעי הזמן.

'''שו"מ מתואם''' הוא התפלגות <math>Q</math> על פני מרחב הפעולות כך שלכל שחקן אין חרטות פנימיות.

====מזעור חרטה חיצונית====
למזעור החרטה החיצונית יש השלכה חשובה בתחום בעיות הניתוב: אם כל שחקן ממזער את החרטה החיצונית שלו, מובטח כי התנועה הכוללת תתכנס בקירוב ל[[שיווי משקל נאש]]. במצבים רבים יש צורך לקבל החלטות חוזרות בתנאי [[סביבה (פסיכולוגיה)|סביבה]] של אי־ודאות כמו, למשל, בבחירת הדרך לנסיעה לעבודה או בביצוע משחק חוזר נגד יריב שהאסטרטגיה שלו אינה ידועה. בהקשר זה יש אלגוריתמים לומדים, המסגלים את עצמם למצב ומניבים תוצאה טובה כמעט באותה מידה בהשוואה למצב בו ההחלטות מבוצעות בדיעבד, וזאת על ידי מזעור החרטה החיצונית.{{הערה|ב[[משחק סכום אפס]] אלגוריתם מעין זה מניב את ערך המינימקס של המשחק}}

== מודל ==

נניח מודל מקוון  בו <math>N</math> פעולות אפשריות: 
{X = {1,…,N. בכל מקטע זמן <math>t</math> אלגוריתם מקוון <math>H</math> בוחר התפלגות <math>p^t</math> מעל <math>N</math> הפעולות, לאחר-מכן היריב בוחר וקטור הפסד <math>l^t \in [0,1]^N</math> כאשר 
<math>l^t_i \in [0,1]</math> הוא ההפסד בפעולה ה-<math>i</math>-ית במקטע ה-<math>t</math>. ב'''מודל האינפורמציה המלאה''' האלגוריתם <math>H</math> מקבל את וקטור ההפסד <math>l^t</math> ומחשב את 
<math>(l^t)_H = \sum_{i=1}^N p^t_i  \cdot l^t_i</math>. במודל '''האינפורמציה החלקית''' האלגוריתם המקון מקבל <math>(l^t, k^t)</math> כאשר <math>k^t</math> מפולג לפי <math>p^t</math> ו-<math>l^t_H = l^t_(k^t_)</math> הוא  ההפסד. ההפסד של הפעולה ה-<math>i</math>-ית במקטע הזמן <math>T</math> הוא <math>L^T_i = \sum_{i=1}^T l^t_i</math> וההפסד של האלגוריתם ה-<math>H</math> הוא <math>L^T_H = \sum_{i=1}^T l^t_H</math>. נגדיר את החרטה החיצונית באופן שתהיה האפשרות לבחור מבין אוסף אלגוריתמים <math>A</math>, הנקראת קבוצת הכיווץ, את האלגוריתם עם הביצועים הטובים ביותר כך שההפסד יהיה: 
<math>L^T_A,min = \min L^T_a </math> כאשר <math>a \in A</math>.
 

נרצה למזער את החרטה החיצונית <math>R_A = L^T_H - L^T_A,min</math>. בהינתן <math>A = X</math> וגם 
<math>R = L^T_H - L^T,min</math>, נחפש את האלגוריתם המקוון שהפסדו קרוב ל- <math>L^T,min = \min _i L^T_i</math>.

חרטה חיצונית משתמשת בקבוצת כיווץ <math>A</math> קבועה.
נתייחס ל'''חוקי ההתאמה''' כפעולות המשנות את הפעולות שנבחרו על ידי האלגוריתם המקוון. על ידי השינוי הנ"ל מתקבלת אסטרטגיה חלופית בה נרצה להשתמש כנגד היריב.

ל'''חוק ההתאמה''' <math>F</math>  מקבל כקלט את היסטוריית הבחירות ואת הבחירה הנוכחית שבוצעה על ידי האלגוריתם המקוון ומחזיר כפלט פעולה אופציונלית. נסמן ב- <math>F^T</math> את הפונקציה <math>F</math> בזמן <math>t</math>, כולל תלות בהיסטוריה.

בהינתן אוסף התפלגויות הסתברותיות <math>p^t</math> (בהן נעשה שימוש באלגוריתם המקוון <math>H</math>) וחוק ההתאמה <math>F</math> נגדיר סדרה חדשה של התפלגויות הסתברותיות <math>f^t = F^t(p^t)</math> כאשר <math>f^t_i = \sum _i p^t_i</math> כאשר <math>j:F^t(j)=i</math>. ההפסד של הסדרה המתואמת הוא <math>L_H,_F = \sum _t \sum _i f^t_i \cdot l^t_i</math>. חוק ההתאמה <math>F</math> מניב התפלגויות שונות. 

בהינתן קבוצת חוקים סופית וחסרת זיכרון (=שאינה תלויה בהיסטוריה) Ғ ואוסף וקטורי הפסד, החרטה של האלגוריתם המקוון <math>H</math> היא: <math>R_F = \max L^T_H - L^T_h,_F</math> כאשר Ғ<math>F \in </math>.

== ראו גם == 
* '''[[ניתוח תחרותיות]]''' (competitive analysis) - חקר איכות החלטות של אלגוריתמים מקוונים.

==הערות שוליים==
{{הערות שוליים}}

[[קטגוריה:תורת המשחקים]]
[[קטגוריה:קבלת החלטות]]