book by gegeshandong

VIEWS: 0 PAGES: 40

									  ‫"אתגר" תוכנית – המחשב למדעי החוג – חיפה אוניברסיטת‬




‫בקודגורו גנטי תיכנות‬
             ‫פרוייקט חוברת‬
               ‫לייבו אמיר זיסמן דין‬
                                     ‫2‬



                                                              ‫רכז הפרוייקטים‬
                                                         ‫חננאל חזן‬        ‫שם‬
‫‪hhazan01@cs.haifa.ac.il‬‬                                                ‫אימייל‬
                                                     ‫04-828-0368‬           ‫טל‬
                                ‫אוניברסיטת חיפה – החוג למדעי המחשב‬      ‫מוסד‬
‫/10‪http://cs.haifa.ac.il/~hhazan‬‬                                         ‫אתר‬

                                                             ‫מנחה הפרוייקט‬
                                                   ‫דר. עודד מרגלית‬       ‫שם‬
‫‪odedm@il.ibm.com‬‬                                                      ‫אימייל‬
                                                    ‫0404-236-300‬          ‫טל‬
                            ‫מעבדת המחקר - חברת ‪ ,IBM‬חיפה, ישראל‬        ‫מוסד‬
‫‪http://www.haifa.il.ibm.com/dept/svt/simulation_vsml.html‬‬               ‫אתר‬

                                                          ‫מפתחי הפרוייקט‬
                                                        ‫דין זיסמן‬      ‫שם‬
                                                     ‫626500246‬         ‫ת.ז‬
‫‪ddiinn@gmail.com‬‬                                                    ‫אימייל‬
                                                  ‫5404-025-560‬          ‫טל‬
              ‫אוניברסיטת חיפה – החוג למדעי המחשב – תוכנית "אתגר"‬     ‫מוסד‬

                                                         ‫אמיר לייבו‬       ‫שם‬
                                                       ‫456004046‬          ‫ת.ז‬
‫‪amirleibu@hotmail.com‬‬                                                  ‫אימייל‬
                                                   ‫2204-386-534‬            ‫טל‬
               ‫אוניברסיטת חיפה – החוג למדעי המחשב – תוכנית "אתגר"‬       ‫מוסד‬

                                                               ‫אתר הפרוייקט‬
‫/6808‪http://code.google.com/p/darwin‬‬
                                                                                                              ‫3‬



                                                                                                                                                                        ‫תוכן עניינים‬
  ‫...........................‬
                        ‫................................................................................................‬
                          ‫5‬                                                                                                                               ‫מטרת הפרוייקט ותיאור כללי‬

       ‫................................................................................................................................‬
                   ‫..........‬
                          ‫5‬                                                                                                                                         ‫מטרת הפרוייקט‬
     ‫................................................................................................................................‬
                     ‫........‬
                          ‫5‬                                                                                                                                        ‫דרישות הפרוייקט‬
           ‫................................................................‬
               ‫..............‬
                          ‫6‬                                                                                  ‫תחרות קודגורו אקסטרים ומנוע המשחק 6808‪corewars‬‬
             ‫................................................................................................................................‬
             ‫................‬
                          ‫7‬                                                                                                                                              ‫תיכנות גנטי‬
           ‫..................‬
               ‫................................................................................................................................‬
                          ‫8‬                                                                                                                                              ‫תיאור כללי‬
         ‫....................‬
                 ‫................................................................................................................................‬
                          ‫9‬                                                                                                                                                ‫מחקר קודם‬

‫................................................................................................‬
                           ‫9‬‫..‬                                                                                                 ‫הקבלה ל-‪ corewar‬המקורית ו- ‪REDCODE‬‬
         ‫................................................................................................................................‬
                 ‫............‬
                          ‫9‬                                                                                                                                           ‫ג'ון פרי)‪(Perry‬‬
    ‫.........................‬
                      ‫................................................................................................‬
                          ‫9‬                                                                                                                              ‫ג'ייסון בור ו-‪)Boar( ga_war‬‬
      ‫.......................‬
                    ‫................................................................................................‬
                          ‫9‬                                                                                                                            ‫ראיין קולמן (8991 ,‪)Colman‬‬
      ‫.........................‬
                        ‫................................................................................................‬
                          ‫01‬                                                                                                                              ‫ווילקיס בנצ'מרק (‪)Wilkies‬‬
    ‫...........................‬
                          ‫................................................................................................‬
                          ‫01‬                                                                                                                                ‫דייב היליס (8991 ,‪)Hillis‬‬
              ‫.................‬
                ‫................................................................................................‬
                          ‫01‬                                                                                                                      ‫ליינוס ת'ורסל (9991 ,‪)Thorsell‬‬
          ‫................................................................................................‬
                    ‫...........‬
                          ‫11‬                                                                                                                ‫דייויד ג. אנדרסן (1002 ,‪)Andresen‬‬
             ‫..................‬
                 ‫................................................................................................‬
                          ‫11‬                                                                                                                        ‫קבוצת ‪)μGP Group( MicroGP‬‬
       ‫........................‬
                       ‫................................................................................................................................‬
                          ‫11‬                                                                                                                                                   ‫סיכום‬
          ‫.....................‬
                    ‫................................................................................................................................‬
                          ‫31‬                                                                                                                                                 ‫טכנולוגיות‬

         ‫......................‬
                     ‫................................................................................................................................‬
                          ‫61‬                                                                                                                                                 ‫אב-טיפוס‬

        ‫.......................‬
                      ‫................................................................................................................................‬
                          ‫61‬                                                                                                                                                   ‫תיאור‬
     ‫..........................‬
                         ‫................................................................................................................................‬
                          ‫61‬                                                                                                                                                    ‫ייצוג‬
         ‫................................................................................................................................‬
                     ‫..........‬
                          ‫71‬                                                                                                                                          ‫פונקציית כושר‬
           ‫................................................................................................................................‬
                   ‫............‬
                          ‫71‬                                                                                                                                           ‫אופרטור גנטי‬
          ‫.....................‬
                    ‫................................................................................................................................‬
                          ‫71‬                                                                                                                                                 ‫תוצאות‬
           ‫....................‬
                   ‫................................................................................................................................‬
                          ‫81‬                                                                                                                                                 ‫מסקנות‬
             ‫..................‬
                 ‫................................................................................................................................‬
                          ‫02‬                                                                                                                                               ‫אלגוריתמים‬

    ‫................................................................................................................................‬
                          ‫.....‬
                          ‫02‬                                                                                                                                      ‫האלגוריתם הכללי‬
          ‫.....................‬
                    ‫................................................................................................................................‬
                          ‫02‬                                                                                                                                                 ‫מוטציה‬
       ‫................................................................................................................................‬
                       ‫........‬
                          ‫12‬                                                                                                                                        ‫פונקציית הכושר‬
                                                                                                          ‫4‬


         ‫................................................................................................................................‬
             ‫..............‬
                      ‫22‬                                                                                                                                        ‫סיכונים וקשיים‬

    ‫.......................‬
                  ‫................................................................................................................................‬
                      ‫22‬                                                                                                                                             ‫אפריל‬
‫............................‬
                       ‫22‬
                        ‫................................................................................................................................‬                ‫יוני‬
‫...........................‬
                      ‫................................................................................................................................‬
                      ‫32‬                                                                                                                                                ‫יולי‬
  ‫.........................‬
                    ‫................................................................................................................................‬
                      ‫42‬                                                                                                                                               ‫בדיקות‬

‫................................................................................................................................‬
                       ‫52‬
                        ‫....‬                                                                                                                               ‫לוח זמנים והתקדמות‬

        ‫................................................................................................................................‬
              ‫.............‬
                      ‫82‬                                                                                                                                       ‫מדריך משתמש‬

      ‫................................................................................................................................‬
                ‫...........‬
                      ‫03‬                                                                                                                                      ‫המדריך למתכנת‬

‫............................‬
                       ‫63‬
                        ‫................................................................................................................................‬                ‫סיכום‬

      ‫.....................‬
                ‫................................................................................................................................‬
                      ‫63‬                                                                                                                                            ‫ביצועים‬
      ‫.....................‬
                ‫................................................................................................................................‬
                      ‫63‬                                                                                                                                            ‫תוצאות‬
       ‫................................................................................................................................‬
               ‫............‬
                      ‫83‬                                                                                                                                       ‫עבודה לעתיד‬
        ‫...................‬
              ‫................................................................................................................................‬
                      ‫04‬                                                                                                                                           ‫ביבלוגרפיה‬
                                             ‫5‬



                       ‫מטרת הפרוייקט ותיאור כללי‬

                                                                             ‫מטרת הפרוייקט‬
      ‫מטרת הפרוייקט היא ליצור אלגוריתם יעיל שניתן לממשו במחשב על מנת לייצר תוכניות אסמבלי‬
                    ‫מארכיטקטורת 8080, כאשר תוכניות אלו יהוו "שורדים" במשחק 6808‪.corewars‬‬

 ‫המחקר המבוצע בפרוייקט הוא השימוש בתיכנות גנטי לייצור תוכניות אלו בצורה יעילה ושימושית יותר‬
‫מחיפוש ממצה. התוכניות המיוצרות ישאפו לרמה של כותבים אנושיים כאשר התוצאה האופטימלית היא‬
                                                 ‫של תוכניות העולות על רמתם של כותבים אנושיים.‬

                                                                             ‫דרישות הפרוייקט‬
                      ‫הערות‬                                                       ‫זיהוי נוסח‬

                               ‫פלט התוכנית יהיה קובצי "שורדים" אשר מסוגלים לרוץ במנוע‬      ‫1‬
                                                                      ‫המשחק המקורי.‬

                                    ‫התוכנית תייצר "אוכלוסייה" ראשונית של תוכניות בצורה‬     ‫2‬
                                                                              ‫אקראית.‬

                                     ‫התוכנית תקלוט קבצי שורדים קיימים לתוך האוכלוסייה‬      ‫3‬
                                                                            ‫הראשונית.‬

                                    ‫התוכנית תוכל לייצג כל תוכנית אפשרית על ידי מחרוזת‬      ‫4‬
                                                                ‫בינארית – הכרומוזום.‬

                                ‫התוכנית תריץ את מנוע המשחק ללא ממשק משתמש גרפי.‬            ‫5‬

                                ‫התוכנית תשתמש באסטרטגיית אבולוציה על מנת לייצר דור‬         ‫8‬
                                                    ‫חדש של תוכניות, והחלפת הדור הישן.‬

        ‫דרישה זו היא המטרה‬      ‫התוכנית תייצר כפלט מספר שורדים אשר מסוגלים לנצח את‬         ‫7‬
     ‫האופטימלית של המחקר.‬                          ‫כל שורדי התחרות הידועים עד היום.‬



                                                           ‫דרישות הפרוייקט מולאו מלבד 3 ו-7.‬

   ‫לאחר סקר מחקר קודם, הובן כי הדרישה 3 אינה ממלאת תפקיד מועיל באלגוריתם ולכן לא מומשה.‬

   ‫דרישה 7 הייתה השאיפה האופטימלית של המחקר ובעוד התקדמות גדולה נעשתה, הפרוייקט בזמן‬
                                                              ‫הגשתו לא הגיעה לרמה זו.‬
                                              ‫6‬



                                          ‫תחרות קודגורו אקסטרים ומנוע המשחק 6808‪corewars‬‬

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

‫מהלך ההתמודדות פשוט למדי: זירת המשחק היא מקטע זיכרון רציף בגודל 48 קילובייט אשר מהווה גם‬
        ‫את מקטע הזיכרון וגם את מקטע הקוד, אליו נטענות התכניות המתחרות (למיקומים אקראיים).‬
    ‫ההתמודדות מתנהלת בסיבובים, כאשר בכל סיבוב המנוע מריץ את שורת הקוד הבאה בתור של כל‬
  ‫מתחרה. מתחרה מוכרז כמפסיד אם ביצע בתורו פקודת מכונה לא חוקית, למשל כתוצאה מכך שהקוד‬
    ‫שלו נפגע ע"י תכנית יריבה. המנוע ממשיך להריץ את התכניות ששרדו עד להשארותו של יריב בודד‬
                                                                            ‫בזירה – המנצח.‬

  ‫קונספט התחרות מבוסס על משחק פופולרי בשם ‪ ,COREWARS‬שתחילתו במאמר אקדמי שפורסם‬
       ‫בשנת 4081 ע"י א.ק. דיודני. יחד עם זאת, חוקי התחרות ומנוע המשחק שונים מהותית מאלה‬
                                                                       ‫המתוארים במאמר.‬

       ‫שורד ‪ cgx‬הוא למעשה תוכנית אסמבלי מקומפלת. שם השורד המשתתף בתחרות נקבע עפ"י שם‬
‫הקובץ. על קוד השורד להכיל אך ורק אופקודים הנתמכים ע"י מעבד 8080, ולהשתמש בפקודות 81 ביט‬
    ‫בלבד. לאחר כתיבת השורד באסמבלי, יש לקמפל אותו כקובץ ‪ com‬ולהעתיק אותו לספריה ‪survivors‬‬
 ‫תחת ספרית מנוע המשחק (על מנת שהמנוע ידע לזהות אותו בתור שורד חוקי). מומלץ (אך לא חובה)‬
                                                   ‫לשנות את סיומת הקובץ מ ‪-com‬לסיומת ריקה.‬

      ‫בדומה לקובץ ‪ com‬רגיל, קובץ השורד מכיל את הקוד הסופי בדיוק כפי שיטען לזיכרון ויורץ ע"י מנוע‬
  ‫המשחק. יחד עם זאת, בשונה מקובץ ‪ com‬השורדים אינם יכולים להניח טעינה לכתובות קבועות, כיוון‬
                                               ‫שמנוע המשחק טוען אותם בכל סיבוב לכתובת אקראית .‬

   ‫כל שורד מקבל סט אוגרים (רגיסטרים) מלא משלו, שאינו נגיש לשורדים האחרים. בנוסף, לכל שורד‬
                ‫מוגדרת מחסנית "אישית" של 0482 בתים, שגם היא אינה נגישה לשורדים האחרים.‬

   ‫לפני הרצת סיבוב המשחק הראשון, מנוע המשחק מאתחל את כלל הבתים בזירה לבית ‪ .0CCh‬בית זה‬
 ‫מהווה פקודה "בלתי נתמכת" - פרטים בהמשך. לאחר מכן, המנוע טוען כל שורד למיקום אקראי בזיכרון‬
  ‫הזירה, ז"א - מעתיק לשם את תוכן קובץ השורד כמו שהוא בדיוק. המרחק בין שני שורדים, וכן המרחק‬
     ‫בין השורד לבין קצה הזירה, מובטח להיות לפחות 4281 בתים. גודל השורד המקסימלי המותר הוא‬
                                                                                 ‫215 בתים.‬

             ‫לפני הסיבוב הראשון, מנוע המשחק מאתחל את האוגרים (של כל שורד) לערכים הבאים :‬

                                                            ‫‪ - BX,CX,DX,SI,DI,BP‬מאופסים.‬   ‫‪‬‬
                                                                       ‫דגלים - מאופסים.‬    ‫‪‬‬
    ‫‪ - AX,IP‬מיקום השורד ההתחלתי, ההיסט )‪ (offset‬האקראי בזירה אליו נטען השורד ע"י מנוע‬      ‫‪‬‬
                                                                               ‫המשחק.‬
                                  ‫‪ - CS,DS‬מקטע )‪ (segment‬הזירה המשותף לכלל השורדים.‬        ‫‪‬‬
                             ‫‪ - ES‬מקטע )‪ (segment‬לזיכרון המשותף לשורדים מאותה קבוצה.‬       ‫‪‬‬
                                                   ‫7‬



                                              ‫‪ - SS‬מקטע תחילת המחסנית האישית של השורד.‬              ‫‪‬‬
                                               ‫‪ - SP‬היסט תחילת המחסנית האישית של השורד.‬             ‫‪‬‬

   ‫בשלב זה מתחילה התנהלות המשחק בסיבובים, כאשר בכל סיבוב מריץ מנוע המשחק את הפקודה‬
  ‫הבאה של כל שורד, עד לסיום המשחק: לאחר 888,882 סיבובים ,או כאשר נשאר שורד בודד בזירה.‬
    ‫הסדר בו ישחקו השורדים בכל סיבוב נקבע בתחילת המשחק באופן אקראי, ואינו משתנה במהלכו.‬

                                                                            ‫שורד נפסל במקרים הבאים :‬

        ‫הרצת פקודה בלתי חוקית (לדוגמא: הבית ‪ 060h‬שאינו מתרגם לאף פקודת אסמבלי).‬                     ‫‪‬‬
‫הרצת פקודה "בלתי נתמכת" ע"י מנוע המשחק (לדוגמא ”‪ .)”INT 21h‬מנוע המשחק מונע הרצת‬                     ‫‪‬‬
             ‫פקודות המנסות ליזום תקשורת ישירה מול מערכת ההפעלה או חומרת המחשב.‬
     ‫ניסיון גישה לזיכרון שאינו בתחומי הזירה, ואינו בתחומי המחסנית ה"אישית" של השורד.‬                ‫‪‬‬

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

                                                                                   ‫תיכנות גנטי‬
   ‫אלגוריתם אבולוציוני הינו אלגוריתם חיפוש או טכניקת אופטימיזציה המבוססת על עיקרון האבולוציה‬
                                                                                        ‫בטבע.‬

                                                       ‫כל אלגוריתם אבולוציוני בנוי מ-4 שלבים עיקריים:‬

                                                                   ‫1. בחר אוכלוסייה ראשונית של גנים‬

                                                                 ‫2. חשב את פונקציית הכושר של כל גן‬

                                                                                                ‫3. ריבוי‬

                                          ‫1.3. יצר מהגנים הטובים צאצאים על ידי מוטציה ו\או זיווג‬

                                               ‫2.3. החלף את הגנים הגרועים בצאצאים של הטובים‬

                                 ‫4. חזור לשלב 2 עד תנאי סיום (זמן, מספר דורות, איכות הפתרון וכו')‬

                                   ‫תיכנות גנטי הינו אלגוריתם אובולציוני בו הגנים הם תוכניות מחשב1.‬

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



                                                                                                        ‫1‬
  ‫בעוד במקור התוכניות היו קוד מקור של שפת תכנות פונקציונלית (‪ )LISP‬ומבנה התוכנית היה בצורה של עץ בנייה של‬
‫פעולות ומשתנים, ניתן לומר שהתוכניות שלנו שייכת לתת תחום שנקרא תיכנות גנטי ליניארי בו תוכניות המחשב הם משפת‬
                                                                             ‫סף או משפת תיכנות פרוצדורלית.‬
                                                   ‫8‬



                                                                                             ‫תיאור כללי‬
  ‫תחת מימוש של תכנות גנטי ליצירת מתחרים הגן יהיה תוכנית אשר תיוצג ע"י כרומוזום. הכרומוזום יהיה מערך‬
    ‫באורך אקראי בתחום 8 עד 215 של בתים. תוכנית 8080 מיוצגת על ידי הכרומוזום הזה בתרגום של הבתים‬
                                                                      ‫לאופקודים של פקודות שפת הסף.‬

 ‫האופרטורים הגנטיים האפשריים בפרוייקט הם: הצלבה בנק' אחת (‪ ,)one point crossover‬הצלבה בשתי נקודות‬
‫(‪ ,)two point crossover‬הצלבה מאוחדת (‪ ,)uniform crossover‬חיתוך ושילוב (‪ ,)cut and splice‬מוטציה יחסית –‬
     ‫אופטור מוטציה חדש שפותח לפרוייקט ומשולב – אופרטור שעושה שילוב בחיתוך ושילוב ומוטציה של %81.‬
  ‫בעוד רוב האופרטורים שממושו נעשו רק לשם הרשמיות כתוצאה מהיותם הסטנדרטים, ניסויים והמחקר הקודם‬
      ‫הנחו לשני כיוונים. הכיוון הראשון הוא שימוש רק באופרטור של מוטציה מכיוון שזיווג במסגרת תוכניות כאלו‬
    ‫יוצרות תוכניות לא חוקיות\לוגיות ולכיוון זה שימוש באופרטור מוטציה יחסית. האופרטור מבצע מוטציה בכמות‬
        ‫יחסית לרמת כושר הגן. הכיוון השני הוא שימוש באופרטור זיווג מכיוון שהוא טוב יותר לביצועי האלגוריתם‬
                                       ‫מבחינת גיוון ומהירות האלגוריתם ולכיוון זה שימוש באופרטור המשולב.‬

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

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

     ‫הבעיה הנותרת היא כיצד להצמיד מדד אמיתי של הצלחה לתוכנית על מנת לבצע מעקב והבנה של פעולתה‬
              ‫והתפתחות התוכניות. נוכל לעשות זאת על ידי שימוש בבנצ'מרק של בדיקה אקסוגנית של הדור.‬

    ‫הבנצ'מרק שנבנה עובד ע"י הצבה של 81 קרבות אחד על אחד כנגד אחד מחמישה מתחרים קיימים. ‪Dummy‬‬
     ‫הוא שורד אשר רץ בלולאה 315 פעמים. שום שורד ללא לולאה (או כתיבה מיקרית נדירה ביותר לזיכרון ללא‬
    ‫שימוש בלולאה) לא יכול לנצח אותו ושורד בעל לולאה תמיד ינצח כנגדו. השורד הבא הוא ‪ ,shooterA‬שורד זה‬
        ‫מפציץ את הזיכרון במרווחים של 81 בצורה טריוויאלית. השורד הבא הוא ‪ ,mpo‬אחד מהמתחרים הגרועים‬
             ‫מתחרות 88'. על פי חקירה בסיסית נראה כי הוא מפציץ בצורה לא טריוויאלית אך לא מתקדם כל כך.‬
  ‫‪ Script_kiddie‬הגיע למקום 4 בתחרות 88'. ‪ XLII‬ניצח את שלב אחד בתחרות 88'. כאשר מקיימים תחרות בין 5‬
      ‫תוכניות אלה ניתן לראות שתוצואתיהן מסתדורת על פי סדר הדירוג שצויין כאן בצורה ליניארית (ההפרש בין‬
   ‫תוכנית אחת לעוקבת שלה בדירוג נמצאת בקנה המידה של שאר ההפרשים הללו). הציון של תוכנית היא סכום‬
  ‫התוצאות של הקרבות כנגד 5 תוכניות אלו. על פי התוצאה ניתן ללמוד הרבה על התוכנית, אם הציון הוא בטווח‬
  ‫81-8 היא אינה כוללת לולאה וכנראה הצליחה במקרה נדיר לכתוב על ‪ ,18-28 .dummy‬התוכנית מסוגלת לרוץ‬
     ‫בלולאה אך היא אינה כותבת לזירה בבכלל או בצורה טובה. 83-82 התוכנית טובה יותר מאשר מפציץ בסיסי‬
  ‫ולמעשה מסוגלת לנצח תוכנית שנכתבה ע"י בני אדם. 84-83 התוכנית היא ברמה טובה ומסוגלת להתחרות עם‬
   ‫רוב התוכניות הכתובות. 85-84 התוכנית מאוד מוצלחת ותחרותית ויכולה להגיע למיקום גבוה בתחרות הבאה.‬
                                                ‫9‬



                                       ‫מחקר קודם‬
                                                     ‫הקבלה ל-‪ corewar‬המקורית ו- ‪REDCODE‬‬
     ‫‪ 2REDCOE‬היא שפת סף פשוטה, בעלת סט פקודות אחיד (מבחינת גודל פקודה), ומספר פקודות קטן אך היא‬
‫טורינג-שלמה ולכן מבחינה חישובית זהה ל-8080. היא הומצאה על מנת לשימוש בתחרות ‪ corewar‬המקורית לה‬
   ‫פורמט דומה ל-6808‪ .corewars‬כלליה קצת שונים אך דומים במידה גדולה מאוד לחוקים של התחרות "קודגורו‬
  ‫אקסטרים". בין ההבדלים נובע שהתחרות המקורית לא ממש הייתה תחרות במובן של "קודגורו אקסטרים" אלא‬
 ‫היוותה אתר אינטרנט בו ניתן במשך כל הזמן להגיש שורדים חדשים ולהתחרות על הצלחה. אתר כזה כונה בשם‬
 ‫"גבעה". בנוסף היא נערכת בקרב אחד על אחד בניגוד לקרב מרובה משתתפים בקודגורו. הבדל נוסף הוא שהיא‬
   ‫מאפשרת מספר רב של תהליכים לכל שורד וקיים אופקוד ספציפי שמאפשר לך להשתלט על תהליך נוסף בעוד‬
                                                                   ‫שבקודגורו לא קיימת אפשרות זאת.‬

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

                                                                                  ‫ג'ון פרי)‪(Perry‬‬
    ‫העבודה המחקרית הראשונה שנעשתה בנושא הייתה של ג'ון פרי. הוא חקר שימוש בתיכנות גנטי על השפה‬
    ‫‪ .REDCODE‬הציג 3 רמות של כרומוזומים לייצוג תוכנית: ביט, פקודה, ומטה-פקודה. כאשר מטה-פקודה היא‬
                       ‫מספר פקודות אשר מבצעות דבר מסויים, למשל להפציץ את הזיכרון, להשתכפל וכו'.‬

 ‫הייצוג אצלו היה ע"י מטה-פקודה, פונקציית הכושר שלו היתה אקסוגנית כנגד מתחרים מנצחים קודמים (שנכתבו‬
‫ע"י בני אדם), והוא השתמש בהצלבה מאוחדת (כאשר בוחרים פקודות ולא ביטים) עם %52 של הצלבה ו%5 של‬
                 ‫מוטציה (ניגוד ביט), ו %81 קצב מוטציה (ה%81 הטובים בדור החליפו את ה%81 הגרועים).‬

  ‫על מנת שלא תיווצר תוכנית בלתי תקינה לאחר ביצוע ההצלבה הוא השתמש בפורמט של סדר פקודות מסויים‬
 ‫שהגביל את הייצוג שלו אך גרם לכך שלא יווצרו תוכניות בלתי חוקיות. גם את הדור הראשון הוא מילא בשורדים‬
                                                                                 ‫כתובים ע"י בני אדם.‬

      ‫הוא הריץ את התוכנית של עם אוכלוסייה של 8881 במשך רק 3 דורות מכיוון שעבד על מחשב חלש מאוד‬
                                                          ‫(המאמר נכתב בשנות ה-88 המוקדמות).‬

 ‫הוא הגיש שניים מהשורדים שלו עבור טורניר מסויים והגיע לשני המקומות לפני האחרון. העובדה כי הוא הצליח‬
                                                         ‫לנצח שורד לא אבולוציוני הייתה הוכחת קונספט.‬

                                                                    ‫ג'ייסון בור ו-‪)Boar( ga_war‬‬
  ‫ג'ייסון בור השתמש ברעיונותיו של ג'ון פרי וכתב קוד משל עצמו על מנת לפתח גנטית שורדים בשם ‪ga_war.c‬‬
 ‫שבו הוא משתמש בפונקציית כושר אנדוגנית וייצוג ברמת הפקודה. לאחר ניסיונות רבים הוא הצליח ליצור שורד‬
‫שהגיע למיקום בינוני באתר תחת קטגוריית "גבעת המתחילים", מה שאומר שהתוכנית שלו הייתה מסוגלת לנצח‬
                                    ‫כמה כותבים אנושיים אך לא היה אתגר גדול לאדם ליצור שורד טוב יותר.‬

                                                                   ‫ראיין קולמן (8991 ,‪)Colman‬‬
                                             ‫בנה על הרעיונות של פרי ובור והתבסס בקוד המקור של בור.‬



                                                                                                   ‫2‬
                                        ‫מדריך שפת ‪http://vyznev.net/corewar/guide.html - REDCODE‬‬
                                                 ‫01‬


‫הוא החליט על לנסות לעבוד על תוכניות מאורך קטן, 51-5 פקודות וייצוג ברמת הפקודה. קצב מוטציה של %5-4.‬
      ‫הוסיף רעיון חדש של החייאה של גן אשר נזרק במהלך הדורות, קצב ההחייאה היה קטן מ-%81. במאמרים‬
  ‫מאוחרים יותר יקרא מושג זה בשם "פונקציית וולהלה". אוכלוסייה בגודל 881. אופרטור גנטי היה מוטציה של -5‬
   ‫%51 בביטים של הפקודות. הדגיש את החסרון בשימוש בהצלבה בכך שהיא יוצרת תוכניות לא תקניות. איתחל‬
                                                                            ‫את הדור לפקודות אקראיות.‬

   ‫לאחר הרצה של 8881 דורות הוא ראה שהשורדים שלו השתמשו באסטרטגיית הפצצה בצורה אקסקלוסיבית.‬

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

                                                                        ‫ווילקיס בנצ'מרק (‪)Wilkies‬‬
‫21 שורדים קבועים אשר כנגדם נעשים 881 קרבות. עבור ניצחון מקבלים 3 נקודות ועבור תיקו נקודה 1 ולכן הציון‬
 ‫של תוכנית בבנצ'מרק ווילקיס נעה בין 883-8. על פי הסתכלות על התוכניות וניסיון נאמר שלאדם לא קשה לכתוב‬
                                                                            ‫תוכנית המקבלת 881 נקודות.‬

                                                                        ‫דייב היליס (8991 ,‪)Hillis‬‬
 ‫התבסס על הקוד של בור. ייצוג ברמת הפקודה. זרע 4 פקודות שכפול לדור ההתחלתי. השתמש באופרטור גנטי‬
                  ‫של הצלבה בנק' אחת שנבחרת באקראי ואחריה אחוז מוטציה של %2. אוכלוסייה של 85.‬

 ‫עשה שימוש בפונק' אקסוגנית (כנגד קבוצת תוכניות אנושיות משלו) הגיע לתוכנית עם ציון 48 במבחן של ווילקיס‬
                                 ‫וקיבל תוכניות בעיקר של מפציצים המכילים מגוון קטן של אסטרטגיות אחרות.‬

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

                                                                 ‫ליינוס ת'ורסל (9991 ,‪)Thorsell‬‬
  ‫הציג את מושג "מודל הנדידה" לראשונה, טכניקה שמהווה שיפור גדול על השימוש ב"פונקציית וולהלה" ומונעת‬
                                                                       ‫הקטנה של מגוון האסטרטגיות.‬

  ‫השתמש בייצוג ברמת הפקודה. 2 אופטורים גנטיים: עבור %88 מהמקרים שימוש במוטציה (של %88 עבור כל‬
 ‫הביטים של הפקודה ואז עוד תוספת בהתאם למשמעות הביט, אם מהווה את הפקודה או הפרמטר). עבור %81‬
   ‫הנותרים שימוש בהצלבה בנקודה אחת, ללא התחשבות באורך (מבוצע רק %81 בגלל היצירה של תוכניות לא‬
  ‫תקניות\לוגיות). כאשר גן מפסיד לגן אחר הוא מוחלף ע"י הקוד שלו (לא ממש ברור מתי אך כנראה שינה זאת).‬

     ‫כאשר הוא יוצר תוכנית חדשה הוא בודק אם היא תיקנית (כנראה על ידי תחרות כנגד תוכנית קבועה ידועה)‬
                                                                             ‫ובמידה ולא זורק אותה.‬

  ‫תחת "מודל הנדידה" (במאמר עצמו מכונה "שבטים"), נוצרים כמה דורות אשר ביצוע האבולוציה עליהם נעשית‬
   ‫כפי שמתואר הנ"ל בדומה למאמרים הקודמים, אך עבור קצב מסויים, נעשות החלפות של תוכניות בין שבטים.‬
                                                   ‫11‬


                                                          ‫תוצאות כנגד תוכניות מוצלחות ידועות היו נמוכות.‬

                                                                ‫דייויד ג. אנדרסן (1002 ,‪)Andresen‬‬
‫עושה זריעה של הדור ההתחלתי או באקראיות, על ידי תוכנית ידועה, או על ידי סדרה של אופקודים של שכפולים‬
  ‫וקפיצות. משתמש בייצוג של פקודה אבל החלקים של הפקודה מזוהים ומחולקים. התרבות גם ע"י סוגים שונים‬
‫של זיווג וגם של מוטציה. פונק' אקסוגנית נתנה תוצאות טובות מהר אבל גרועות לאורך זמן. פונק' אנדוגנית נתנה‬
‫תוצאות טובות לאט אך טובות יותר לאורך זמן. הראה שמאוד קל לאמן את הדור לנצח מתחרה ספציפי. לא מעיף‬
‫תוכניות טובות במקום גרועות, פשוט מעתיק למיקומים אקראיים החל מהתוכנית הגרועה ביותר ועד לטובה ביותר‬
      ‫(הסתברותית הטובות יכתבו על הגרועות יותר פעמים ולכן יהוו יותר מהאוכלוסייה). כאשר זורעים את הדור‬
  ‫הראשוני בפקודות שכפול וקפיצה מקבלים תוצאות טובות מהר יותר אך גרועות יותר לטווח הארוך. הגיע לערך‬
                                                                             ‫של 821 במבחן של ווילקיס.‬

                                                                    ‫קבוצת ‪)μGP Group( MicroGP‬‬
        ‫השתמשו בארכיטקטורה כללית לתיכנות גנטי על מנת לפתח אובלוציונית תוכניות מתחרות למשחק המקורי.‬

                                                         ‫הראו כי מודל הנדידה מאפשר תוצאות טובות יותר.‬

                                                                                                   ‫סיכום‬
    ‫מהמחקר הקודם שנעשה על התחרות המקורית נובעות מסקנות מחזקות לגבי שימוש בתיכנות גנטי במסגרת זו.‬

    ‫בעוד העובדה שהתוצאות אינן הפיקו מתחרה בעל ביצועים טובים, וגודל שפת הסף ‪ REDCODE‬קטנה משל 8080‬
                                         ‫ניתן לראות טענות מחזקות מהמחקר שמעפילות על חולשות אלו.‬

        ‫הכוח החישובי של מחשבים בזמן המחקר הנ"ל היה חלש פי כמה מונים מאשר מחשבים כיום בעוד כמות או‬
                 ‫סיבוכיות החישוב נשארה אותו הדבר, כיום מתאפשר לבצע חיפוש נרחב ועמוק יותר מאשר קודם.‬

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

      ‫ידוע כי קיימים שורדים אבולוציונים שהגיעו לניצחון בתחרויות בפורמט של טורניר3. הם גם כן הגיעו למקומות‬
      ‫מוצלחים בגבעות "הקטנות", כלומר שגודל תוכנית בהם היה קטן. מכיוון שגודל שורד מקסימלי בקודגורו הוא‬
‫מגודל 215 בתים, לכן כמות הפקודות המקסימלית הינה 215 ולרוב פחות מזה, בעוד שתועדו שורדים אבולוציונים‬
       ‫אשר הגיעו למקומות גבוהים בגבעות בעלות גבול פקודות גדול מזה (גבעות עם 880 פקודות ואפילו מעטים‬
                                                                               ‫בגבעות של 8880 פקודות).‬

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


‫3‬
    ‫/‪http://users.erols.com/dbhillis‬‬
                                                 ‫21‬


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



                                        ‫טכנולוגיות‬
‫‪Java Development Kit‬‬




                                                                   ‫תיאור: פלטפורמת הפיתוח של ג'אווא.‬

                                                                                    ‫גרסא: 8 עדכון 81.‬

          ‫שימוש: הרצת הקוד, קימפול הקוד ל-‪ JVM‬והרצתו בעזרת מהדר ה-‪ .JIT‬אריזה של הקוד בחבילת ‪.JAR‬‬

‫‪http://java.sun.com/javase/downloads/index.jsp‬‬

‫‪IDA Pro Disassembler and Debugger‬‬




                                                      ‫תיאור: הופכת קבצים בינאריים אל קוד המכונה שלהם.‬

                                                                                   ‫גרסא: 8.4 החינמית‬

                                     ‫שימוש: הפיכת הקבצים הבינאריים שנוצרים מהאלגוריתם לשפת הסף.‬

‫/‪http://www.hex-rays.com/idapro‬‬

‫‪Eclipse‬‬




                                                                                  ‫תיאור: סביבת פיתוח.‬
                                                 ‫41‬


                                                                            ‫גרסא: 5.3 למפתחי ג'אווא.‬

                                                                       ‫שימוש: פיתוח ואריזה של הקוד.‬

‫/‪http://www.eclipse.org‬‬

‫‪Eclipse Test & Performance Tools‬‬




                                                               ‫תיאור: תוסף ניתוח הביצועים של ‪.Eclipse‬‬

                                                                                           ‫גרסא: 4.4‬

                                                                       ‫שימוש: ניתוחי ביצועים של הקוד.‬

‫/‪http://www.eclipse.org/tptp‬‬

‫‪Excel‬‬




                                   ‫תיאור: תוכנת עריכת גליונות אלקטרוניים מחבילת התוכנה של מיקרוסופט.‬

                                                                                         ‫גרסא: 7882‬

                                         ‫שימוש: קריאת קבצי ‪ – CSV‬התוצרים של האלגוריתם. יצירת גרפים.‬

‫‪http://office.microsoft.com/en-us/excel/default.aspx‬‬

‫6808‪Corewars‬‬
                                               ‫51‬




                                             ‫תיאור: משחק המבוסס על רעיון תחרות "השורד הוירטואלי".‬

                                                                                        ‫גרסא: 8.3‬

              ‫שימוש: קוד המקור הוא חלק אינטרגלי מקוד הפרוייקט. התוכנה שומשה לבדיקות והרצות ידניות.‬

‫/6808‪http://code.google.com/p/corewars‬‬
                                               ‫61‬



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

                                                                                             ‫ייצוג‬
                                        ‫במשחק ה-6808‪ corewars‬ישנו סוג ידוע של תוכנית אשר נקראת‬
                                  ‫"מפציץ" והיא תוכנית אשר עוברת על הזיכרון במרווחים וכותבת פקודה‬
  ‫בלתי חוקית במטרה לכתוב על מיקום של תוכנית מתחרה במטרה לגרום לה להריץ את הפקודה הבלתי חוקית‬
                                                      ‫ולמות. גרסא פשוטה וייצוגה בפקודות אסמבלי:‬


‫‪; initialization‬‬
‫:‪@start‬‬
‫‪mov bx, ax‬‬
‫)‪add bx, (@end - @start‬‬
‫‪mov al, 0CCh‬‬

‫‪; bombing loop‬‬
‫:‪@loop‬‬
‫‪mov [bx], al‬‬
‫8 ,‪add bx‬‬
‫‪jmp @loop‬‬
‫:‪@end‬‬


‫תוכנית זו תחילה שמה ב-‪ BX‬את מיקום הזיכרון שבו מתחילה התוכנית. לאחר מכן היא מוסיפה את גודל התוכנית‬
     ‫(ההפרש בין תווית ההתחלה והסוף) ל-‪ .BX‬פעולות אלו נעשו על מנת ש-‪ BX‬יכיל את ערך הזיכרון מיד לאחר‬
‫התוכנית. לאחר מכן היא כותבת את הערך ‪ 0CCh‬לתוך ‪ .AL‬האופקוד ‪ 0CCh‬הוא פקודה בלתי חוקית, שכל תוכנית‬
                                                                             ‫המריצה אותה מתה מיד.‬

  ‫כעת בלולאת ההפצצה, כותבים את האופקוד הבלתי חוקי למקום בזיכרון לו מצביעה ‪( BX‬בדיוק אחרי התוכנית‬
 ‫בפעם הראשונה), מוסיפים 0 לערך של ‪( BX‬מתקדמים 0 מקומות בזיכרון – "בזירה") וחוזרים לתחילת הלולאה.‬

 ‫כל זאת נעשה על מנת לכתוב על גבי התוכניות המתחרות בזירה, בעצם החלפת אופקוד שלהם באופקוד הבלתי‬
                                                                         ‫חוקי וגרימה למוות שלה.‬
                                                    ‫71‬


 ‫לא ידוע מהו המרווח הטוב ביותר בו ניתן להפציץ את הזירה ולכן נוכל להשתמש בפרמטר זה כמרחב חיפוש קטן‬
                     ‫יותר לשימוש כאב-טיפוס לאלגוריתם הכללי. כרומוזום תוכנית ייוצג ע"י בית (‪ )byte‬יחיד.‬

                                                                                         ‫פונקציית כושר‬
     ‫השתמשנו בפונקציית כושר אנדוגנית – קרב של תוכנית מול שאר תוכניות מהדור. במשחק נבחרים ‪( X‬בתחרות‬
                       ‫הרשמית ‪ )4=X‬תוכניות בכל סבב לקרב, השתמשנו באותו עיקרון עבור פונקציית הכושר:‬

                                                                  ‫1. נבחרים ‪ X‬תוכניות באקראי מהדור‬

                                                            ‫2. הן נכתבות אל קבצים בתיקיית השורדים‬

                                      ‫3. הפעלת המנוע וביצוע מספר קרבות מסויים (הנקבע ע"י פרמטר).‬

                                          ‫4. עדכון הכושר של כל אחד מ-‪ X‬התוכניות ע"פ הנוסחא הבאה:‬




      ‫כאשר ‪ score‬היא התוצאה של התוכנית בקרב, ‪ timesrun‬הוא מספר פעמים אשר התוכנית רצה (כולל‬
                                  ‫זאת ) ו-‪ previous fitness‬היא תוצאת הכושר הקודמת של התוכנית.‬

                                                                    ‫5. וחזרה על שלבים 4-1 ‪ Y‬פעמים.‬

                                                                                           ‫אופרטור גנטי‬
     ‫האופרטור הגנטי שנבחר היה ‪ ,uniform crossover‬עבור קלט של גן ‪ i‬וגן ‪ ,j‬התוצאה של ‪ uniform crossover‬של‬
      ‫שניהם הוא גן בו נבחרו באקראי (בהסתברות אחידה) האם לקחת ביט מ-‪ i‬או מ-‪ ,j‬וגן נוסף בעל בחירה הפוכה‬
                                                                    ‫עבור כל ביט מאשר הגן הראשון. לדוגמא:‬

‫=‪i‬‬        ‫00011100‬

‫=‪j‬‬        ‫01010101‬

                                   ‫והתוצאות של ביצוע ‪( uniform crossover‬כאשר הביט הנבחר מסומן באדום):‬

‫=1‪c‬‬       ‫01011101‬

‫=2‪c‬‬       ‫00010100‬

      ‫הוא נבחר מכיוון שבניגוד ל‪ one point crossover‬ו-‪( two point crossover‬זיווג ע"י החלפה בנקודת חתך אחת‬
        ‫ושתי נקודות חתך) הוא היה יכול לגרום לכל גן אפשרי להיווצר ע"י זיווג בשלב מסוים, בעוד האחרים יכולים‬
                 ‫להיתקע על פתרונות מסוימים (לפי האוכלוסייה הראשונית) ולא להגיע בשום שלב לפתרון מסויים.‬

 ‫שימוש במוטציה לא נעשה בגלל האינטואיציה ששימוש במוטציה למעשה מהווה פתרון דומה לחיפוש ממצה וזיווג‬
                                                                     ‫יהווה חיפוש ממוקד ומוצלח יותר.‬

                                                                                                 ‫תוצאות‬
     ‫לאחר מספר בדיקות עם גדלי אוכלוסייה בין 215-23, ואחוזי מוטציה בין %85-%81 התקבלו תוצאות שונות של‬
                                                                                             ‫מרווחים.‬
                                                  ‫81‬


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

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

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

                                                                                                ‫מסקנות‬
                                 ‫בחיפוש אחר הטעות, ראשית חקרנו מדוע הדורות מתכנסים אל ערך מסויים.‬

   ‫הגענו למסקנה כי מבחינה סטטיסטית זה תופעה שחייבת לקרות כאשר נעשה שימוש רק באופרטור הגנטי של‬
                         ‫הצלבה אחידה (‪ )uniform crossover‬או בכל אופרטור הצלבה ללא שימוש במוטציה.‬

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

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

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

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

 ‫מנוע המשחק היווה מכשול רציני,כתוצאה מהרצתו האיטית. בתחילה לאחר כתיבת האב טיפוס התברר כי ביצועי‬
       ‫הפרוייקט היו איטיים והייתה אפשרות להריץ כמות נמוכה של דורות לשנייה. לאחר הורדת הממשק הגרפי‬
 ‫מהמנוע השתמשנו ב-‪ profiler‬על מנת לגלות את צוואר הבקבוק לביצועים. התוצאות הראו כי הקוד אשר הוספנו‬
 ‫שהיווה את האלגוריתם האבולוציוני היווה ביקרוב %1 מזמן החישוב, בעוד הקוד של המנוע היווה %88. על מנת‬
                                              ‫91‬


   ‫לראות כי המנוע (לאחר הסרת הממשק הגרפי) לא מריץ קוד שאינו חיוני, הסתכלנו על ביצוע הקוד של המנוע‬
‫וראינו כי %58 מזמן הפעולה נמצא בפונקציה )(‪ NextOpcode‬במחלקה ‪ ,Warrior‬הפונקצייה אשר קוראת פקודה‬
  ‫של תוכנית ומבצעת אותה, ולכן ניתן לראות כי זמן הביצוע אינו "מתבזבז" על שום דבר אחר חוץ מאשר הרצת‬
                                                                                         ‫הקרבות.‬
                                               ‫02‬



                                      ‫אלגוריתמים‬
                                                                                  ‫האלגוריתם הכללי‬
                                                                                    ‫1. עבור כל דור‬
                                                              ‫1.1. עבור כל בחירת קבוצת תחרות‬
                                                                 ‫1.1.1. כתוב לקבצי שורדים‬
                                                                         ‫2.1.1. הרץ תחרות‬
                                                                 ‫3.1.1. עדכן לכל את הכושר‬
                                                                ‫2.1. אם הודלקה אופציית בנצ'מרק‬
                                                               ‫1.2.1. הרץ בנצ'מרק על הדור‬
                                                                             ‫3.1. כתוב דוח כושר‬
                                                                       ‫4.1. בצע מוטציה על הדור‬
                                                                      ‫5.1. אם עבר מרווח הנדידה‬
                                                               ‫1.5.1. בצע נדידה בין הדורות‬
                                                                                    ‫2. עבור כל דור‬
                                                                        ‫1.2. כתוב דוח כושר סופי‬
                                                               ‫2.2. כתוב את כל התוכניות לקבצים‬
                                                                    ‫3. אם הודלקה אופציית בנצ'מרק‬
                                                                                   ‫1.3. לכל דור‬
                                                      ‫1.1.3. כתוב קובץ סטטיסטיקת בנצ'מרק‬

                                                                                            ‫מוטציה‬
                                                          ‫בפרט מתאר את סעיף 4.1 באלגוריתם הכללי.‬

                                                                      ‫אם קצב המוטציה הוא אי זוגי‬   ‫1.‬
                                                                               ‫1.1. חסר ממנו אחד‬
                                                                  ‫אם מבצעים הצלבה בנקודה אחת‬       ‫2.‬
                                     ‫1.2. חשב מרחק בין הגן הראשון גן הראשון ממנו מתחילים מוטציה‬
                                                                          ‫2.2. מ-8 עד קצב מוטציה‬
 ‫1.2.2. ע בור הערך לוקחים את הגנים במיקום זה מתחילת המערך ועושים הצלבה בנקודה אחת עבור‬
                                          ‫הראשון והשני ושמים בערך של המיקום + המרחק‬
                                 ‫2.2.2. עושים אותו דבר רק הפוך (הצלבה של השני עם הראשון)‬
                                                                          ‫3.2.2. מקדמים ב-2‬
                                                                  ‫אם מבצעים הצלבה בשתי נקודות‬      ‫3.‬
                                                                           ‫1.3. מ8 עד קצב מוטציה‬
 ‫1.1.3. עבור הערך לוקחים את הגנים במיקום זה מתחילת המערך ועושים הצלבה בשתי נקודות עבור‬
                                          ‫הראשון והשני ושמים בערך של המיקום + המרחק‬
                                 ‫2.1.3. עושים אותו דבר רק הפוך (הצלבה של השני עם הראשון)‬
                                                                          ‫3.1.3. מקדמים ב-2‬
                                                                          ‫אם מבצעים חיתוך ושילוב‬   ‫4.‬
                                                                        ‫1.4. מ-8 עד קצב המוטציה‬
‫1.1.4. עבור הערך לוקחים את הגנים במיקום זה מתחילת המערך ועושים חיתוך ושילוב עבור הראשון‬
                                                 ‫והשני ושמים בערך של המיקום + המרחק‬
                                               ‫12‬


                               ‫2.1.4. עושים אותו דבר רק הפוך (חיתוך ושילוב של השני והראשון)‬
                                                                          ‫3.1.4. מקדמים ב-2‬
                                                                         ‫אם מבצעים הצלבה אחידה‬     ‫5.‬
                                                                         ‫1.5. מ-8 עד קצב המוטציה‬
      ‫1.1.5. עבור הערך לוקחים את הגנים במיקום זה מתחילת המערך ועושים הצלבה אחידה עבור‬
                                           ‫הראשון והשני ושמים בערך של המיקום + המרחק‬
                             ‫2.1.5. עושים אותו דבר רק הפוך (הצלבה אחידה של השני והראשון)‬
                                                                          ‫3.1.5. מקדמים ב-2‬
                                                                                 ‫אם מבצעים שילוב‬   ‫8.‬
                                                                         ‫1.8. מ-8 עד קצב המוטציה‬
‫1.1.8. עבור הערך לוקחים את הגנים במיקום זה מתחילת המערך ועושים חיתוך ושילוב עבור הראשון‬
                                                  ‫והשני ושמים בערך של המיקום + המרחק‬
   ‫2.1.8. מבצעים מוטציה יחסית עבור הגן במיקום + מרחק ומספר הבייטים לשינוי הוא %81 מאורכו‬
                                            ‫3.1.8. עושים הפוך (חיתוך ושילוב של השני והראשון)‬
‫4.1.8. מבצעים מוטציה יחסית עבור הגן במיקום + מרחק+1 ומספר הבייטים לשינוי הוא %81 מאורכו‬
                                                                          ‫5.1.8. מקדמים ב-2‬
                                                                     ‫אחרת (מבצעים מוטציה יחסית)‬    ‫7.‬
                                                     ‫1.7. מחלקים את קצב המוטציה ל-4 חלקים שווים‬
           ‫2.7. עבור החלק הנמוך ביותר מבצעים מוטציה יחסית כאשר מספר הבייטים לשינוי הוא %881‬
                   ‫3.7. עבור החלק השני מבצעים מוטציה יחסית כאשר מספר הבייטים לשינוי הוא %57‬
                ‫4.7. עבור החלק השלישי מבצעים מוטציה יחסית כאשר מספר הבייטים לשינוי הוא %85‬
                 ‫5.7. עבור החלק הרביעי מבצעים מוטציה יחסית כאשר מספר הבייטים לשינוי הוא %52‬
                                                                              ‫ערבב את סדר הגנים‬    ‫0.‬

                                                                                   ‫פונקציית הכושר‬
‫פונקציית הכושר שונתה מאב הטיפוס על מנת לבטל את החסרונות של האופי המונוטוני שלה ושונתה מהנוסחא:‬




                                                                                      ‫לנוסחא הבאה:‬
                                                  ‫22‬



                                      ‫סיכונים וקשיים‬

    ‫כאן מתוארים ע"פ החודשים התקשורת שהתבצעה עם המנחה אשר סבבה סביב הקשיים והסיכונים למימוש.‬

                                                                                                 ‫אפריל‬
                                                   ‫בעיה: כיצד להטעין גנים (תוכניות 8080) אל תוך המנוע?‬

  ‫פתרון 1: עבודה עם קוד בינארי וכתיבה שלו לקבצים והפעלת המנוע – קל לעבודה אבל קשה להבנה וגם דורש‬
                                            ‫שימוש בעבודה עם קבצים (שיותר איטית מעבודה בזיכרון).‬

‫פתרון 2: הגרלת פקודות בשפת סף, המרתם לקוד מכונה (בינארי) וכתיבתם לקבצים – הקל ביותר להבנה ויצירת‬
              ‫ייצוגים ייחודיים, יצרוך מימוש של אסמבלר או שימוש באחד קיים חיצוני אך עדיין בעיה של יעילות.‬

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

                                                                                ‫תוצאה: שימוש בפתרון 1.‬

                                                                                                    ‫יוני‬
                                      ‫בעיה: תוצאות האב טיפוס נראות כלא נכונות ומראות תוצאות אקראיות‬

     ‫פתרון 1: אין מספיק נפח למרחב החיפוש ותחת פרמטר זה האלגוריתם הגנטי לא פועל כהלכה – יש לעבור‬
                                                            ‫לתוכניות כלליות ומרחב חיפוש גדול יותר.‬

 ‫פתרון 2: טעות באלגוריתם הגנטי – יש לממש בדיקה כלשהיא של האלגוריתם על מנת לראות את נכונותו, הוצע‬
 ‫להשתמש באלגוריתם על מנת לפתור בעיה ידועה ולראות האם הוא מגיע אל התוצאה הנכונה. הפתרון הספציפי‬
  ‫שהוצע היה שימוש בשלוש תוכניות מתחרות שכותבות למקום בזירה, ותוכנית "גולם" שקוראת מאותו תא זיכרון‬
    ‫ומתאבדת בהסתברות בהתאם לתוכנו (ככל שגודל תוכן הכותבת כך גדלה גם ההסתברות). על פי היגיון לאחר‬
      ‫מספר מסויים של דורות הערך אשר ייכתב יהיה 8. פתרון זה היה הדומה ביותר מבחינת היבטים של שימוש‬
                                                        ‫במנוע ודימיון למרחב החיפוש לבעיית האב טיפוס.‬

‫פתרון 3:טעות בהפעלת המנוע – בדיקה האם תוצאות שמדווחות ע"י האלגוריתם טועמות את קנה המידה שלהם‬
                                                               ‫כאשר מורצות ידנית במנוע המקורי.‬

     ‫תוצאה: בהחלט נפלה טעות באלגוריתם הגנטי וזו הובנה ונפתרה לאחר המעבר חחיפוש בתוכניות כלליות.‬

 ‫בעיה: האלגוריתם פעל במהירות לא מספקת את הצרכים, עשרות קרבות בשנייה לעומת ציפיה של צורך אלפים‬
                                                                              ‫או עשרות אלפים.‬

      ‫פתרון 1: צוואר הבקבוק יושב על האלגוריתם הגנטי – לשפר את יעילות המנוע הגנטי במהירות האפשרית.‬

                                         ‫פתרון 2: צוואר הבקבוק יושב על המנוע –לשפר את מהירות המנוע.‬

     ‫פתרון 3: התאמה לשימוש במהירות הקיימת – פיתוח האלגוריתם כך שייתן את התוצאות הרצויות גם תחת‬
                                                                                 ‫מהירות הקיימת.‬
                                                  ‫32‬


     ‫תוצאה: לאחר ניתוח ביצועים (‪ )profiling‬התברר כי קוד המנוע הגנטי היווה %1 מזמן הפעולה ולכן לא היווה‬
   ‫חשיבות במהירות הביצוע. זתוך המנוע, זמן הריצה היה %58 בתוך פעולה יחידה בשם )(‪ NextOpcode‬שהיא‬
   ‫הפעולה המריצה את פקודות המתחרים בתוך קרב בתחרות ולכן לא היה גורם נוסף בתוך המנוע (למשל נטען‬
 ‫שהממשק הגרפי לא הוסר במלואו ועדיין מייצר עומס) חוץ מהקרבות אשר היוו את העומס ולכן המנוע היווה את‬
‫צוואר הבקבוק. הפתרון הנלקח היה שילוב של פתרון 2 ו-3: לבצע שינויים קטנים וטריוויאלים במנוע ((על מנת לא‬
    ‫לפגוע בהתאמה בינו לבין המקורי) על מנת להמהיר אותו וגם לפתח אלגוריתם גנטי שמבצע אבולוציה בצורה‬
                                                                                                ‫מהירה.‬

                                                                                                    ‫יולי‬
                                                                         ‫בעיה: כיצד לייצג תוכנית כללית ?‬

‫פתרון 1: ברמת הביט – זוהי הרמה הנמוכה ביותר אפשרית ויכולה לייצג כל תוכנית, אך לא מעשית ויוצרת עבודה‬
                                                                       ‫רמה ברמת חשיבות נמוכה מדי.‬

           ‫פתרון 2: ברמת הבית או ברמת הפקודה – מאפשרת ייצוג של כל תוכנית, אך יוצרת טעויות לוגיות או‬
                                          ‫פקודות\תוכניות לא תקניות בצאצאים. אופרטירים גנטיים טריוויאלים.‬

     ‫פתרון 3: ברמת המטה-פקודה – ייצוג של כרומוזום או גן כקבוצת פקודות שמבצעת פעולה כלשהיא אם זה‬
‫הפצצה של הזירה, העתקה וכו'. תלוי במימוש אך רוב הסיכויים שלא מאפשרת ייצוג של כל התוכניות, אופרטורים‬
                                                                                ‫גנטיים לא טריוויאלים.‬

                          ‫תוצאה: פתרון 2. למרות החסרון, היתרונות עולים על מצבם של האופציות האחרות.‬

                                                          ‫בעיה: כיצד לנתח את תוצאות\ביצוע האלגוריתם?‬

                                       ‫פתרון 1: הרצה ידנית על גבי פרמטרים שונים וכתיבת תוצאות סופיות.‬

   ‫פתרון 2: יצירת מבחן או באנגלית בנצ'מרק שיאפשר לבחון את האלגוריתם מול תוכניות אמיתיות בזמן ריצה‬
‫ויצירת דו"ח נתונים של הציון לאורך הדורות. לאחר מכן ניתן להשתמש בכלים רבים, הפשוט ביניהם גרף על מנת‬
                                                              ‫להבין ויזואלית את פעולת האלגוריתם.‬

                                                                                        ‫תוצאה: פתרון 2.‬
                                           ‫42‬



                                      ‫בדיקות‬


                   ‫תוצאה‬                        ‫שלבי הבדיקה‬                       ‫דרישה נבדקת‬
‫התוכנית רצה במנוע המקורי.‬    ‫1. הרצת התוכנית עבור קלט‬                  ‫פלט התוכנית יהיה קובצי‬
                                        ‫חוקי כלשהוא‬                ‫"שורדים" אשר מסוגלים לרוץ‬
                               ‫2. כניסה לתיקייה ‪results‬‬                 ‫במנוע המשחק המקורי.‬
                               ‫3. כניסה לתיקייה הנוצרה‬
                                 ‫בעלת השם המתאים‬
                                           ‫לפרמטרים‬
                            ‫4. העתקת קובץ כלשהוא בעל‬
                             ‫סיומת "‪ ".com‬אל תיקיית‬
                                  ‫השורדים של המנוע‬
                                              ‫המקורי‬
                                 ‫5. הרצת המנוע המקורי‬
‫התוכנית הוציאה פלט מתאים‬      ‫1. הרצת התוכנית עם קלט‬             ‫התוכנית תגלה קלט בלתי חוקי‬
                ‫והפסיקה.‬                   ‫בלתי חוקי‬                   ‫ותדפיס הודעה מתאימה‬


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



                     ‫לוח זמנים והתקדמות‬

                                                           ‫סטטוס הפרוייקט לחודש אוקטובר‬

                                                                     ‫88.81.41‬         ‫תאריך‬

                 ‫שונתה פונקציית הכושר על מנת להתמודד עם חסרונותיה‬       ‫1.‬            ‫סטטוס‬
                                                    ‫הוסף מודל הנדידה‬    ‫2.‬
                                     ‫הוסף תפריט ביצוע משורת הפקודה‬      ‫3.‬
                             ‫תוכנן ומומש בנצ'מרק\מבחן ביצועים חיצוני.‬   ‫4.‬

 ‫זמן ביצוע ניסוי הוא ארוך ביותר ולכן הוציא מפאת תחום הפרוייקט ניסויים מסויימים.‬       ‫בעיות‬
                                                                                    ‫מיוחדות‬

                                                                             ‫אין‬   ‫שינויי לו"ז‬

‫לאחר סקירת מחקר קודם הורדה הדרישה מס' 3 לטעינת שורדים קיימים להזרעת‬                   ‫הערות‬
                                      ‫הדור הראשוני כתוצאה מחוסר תועלת.‬

              ‫תוצאה נוספת הייתה מעבר של ריכוז המאמצאים מהייצוג לאלגוריתם.‬



                                                           ‫סטטוס הפרוייקט לחודש ספטמבר‬

                                                                      ‫88.88.5‬         ‫תאריך‬

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

                                                                             ‫אין‬      ‫בעיות‬
                                                                                    ‫מיוחדות‬

                   ‫לאחר שיחה עם חננאל, נדחתה הגשת הפרוייקט ל51 לאוקטובר‬            ‫שינויי לו"ז‬

                                                                             ‫אין‬      ‫הערות‬




                                                             ‫סטטוס הפרוייקט לחודש אוגוסט‬

                                                                      ‫88.08.0‬         ‫תאריך‬

                           ‫שונה מבנה האלגוריתם, נשאר רק מחקר בחזית הייצוג‬             ‫סטטוס‬
                                   ‫62‬


                                                                       ‫אין‬      ‫בעיות‬
                                                                              ‫מיוחדות‬

                                                                       ‫אין‬   ‫שינויי לו"ז‬

                                                                       ‫אין‬      ‫הערות‬




                                                            ‫סטטוס הפרוייקט לחודש יולי‬

                                                                ‫88.78.21‬        ‫תאריך‬

                        ‫ביצענו התקדמות בחקר לקראת הייצוג ומילוי דרישה 7‬         ‫סטטוס‬

                                                      ‫התקדמות לא מספקת‬          ‫בעיות‬
                                                                              ‫מיוחדות‬

                                        ‫דחיית הגשת הפרוייקט לחודש ספטמבר‬     ‫שינויי לו"ז‬

                                                       ‫עלינו להמשיך בחקר‬        ‫הערות‬




                                                            ‫סטטוס הפרוייקט לחודש יוני‬

                                                                ‫90.60.60‬        ‫תאריך‬

‫סיימנו לבנות את כל חלקי האלגוריתם (מלבד דרישה 3 במסמך הדרישות – היא‬             ‫סטטוס‬
                                           ‫תתווסף לדוח החודשי הבא).‬

                                                                       ‫אין‬      ‫בעיות‬
                                                                              ‫מיוחדות‬

                                                                       ‫אין‬   ‫שינויי לו"ז‬

              ‫כעת עלינו לבין את ייצוג התוכניות ומציאת אסטרטגיות אפקטיביות.‬      ‫הערות‬




                                                           ‫סטטוס הפרוייקט לחודש מאי‬

                                                                ‫90.50.50‬        ‫תאריך‬
                         ‫72‬


                      ‫התחלנו את הפרוייקט ע"י הגשת המסמכים הבאים:‬        ‫סטטוס‬

                                     ‫1. מסמך הגדרת הפרוייקט‬
                                        ‫2. מסמך תיאור ראשוני‬
                                               ‫3. טפסי רישום‬
‫הכנו את החלק הראשוני של הפרוייקט ע"פ ההגדרות במסמך התיאור הראשוני‬

                                                               ‫אין‬      ‫בעיות‬
                                                                      ‫מיוחדות‬

                                                               ‫אין‬   ‫שינויי לו"ז‬

                                                               ‫אין‬      ‫הערות‬
                                             ‫82‬



                                  ‫מדריך משתמש‬

                                                       ‫הפרוייקט מתבצע ע"י הרצה מפקודת הטרמינל.‬

                                                                            ‫פרמטרי ביצוע הפקודה:‬

        ‫‪Java –jar darwin.jar iterations numberGenerations swapInterval GenerationSize‬‬
 ‫‪BattlesPerGroup GroupSize FightsPerGen MutationRate MutationOp useBenchmark‬‬



                             ‫‪ – Iterations‬מספר האיטרציות של האלגוריתם או גיל הדורות בסוף ההרצה.‬

                                    ‫‪ -numberGenerations‬מספר הדורות לשימוש תחת "מודל הנדידה".‬

                                                  ‫‪ -swapInterval‬כל כמה דורות לבצע נדידה בין דורות.‬

                                                                         ‫‪ -GenerationSize‬גודל דור.‬

                       ‫‪ -BattlesPerGroup‬כמה קרבות המשחק יריץ עבור קבוצת תוכניות(ערך מומלץ – 5).‬

                             ‫‪ -GroupSize‬גודל קבוצת תוכניות (ערך מומלץ – 4, כך גם מתקיים בתחרות).‬

          ‫‪ -FightsPerGen‬כמה בחירות של קבוצה ועריכת תחרות לדור(ערך מומלץ – חצי מגודל האוכלוסייה).‬

‫‪ -MutationRate‬מספר התוכניות בדור בהן יש לערוך מוטציה. יש לשים לב שאין לתת ערך לקצב המוטציה אשר‬
          ‫גדול מחצי מהדור (חוץ מעבור האופרטור ‪ RMUTATION‬בו ניתן לתת גודל עד כגודל הדור לא כולל).‬

 ‫‪ -MutationOp‬אופרטור המוטציה. האפשרויות הן מספר בין 8 ל-5 כאשר כל מספר מייצג את האופרטור הגנטי‬
                                                                              ‫לפי הרשימה הבאה:‬

                                                                                  ‫‪8 = ONE POINT‬‬

                                                                                  ‫‪1 = TWOPOINT‬‬

                                                                                    ‫‪2 = UNIFORM‬‬

                                                                                   ‫‪3 = CUTSLPICE‬‬

                                                                                 ‫‪4 = RMUTATION‬‬

                                                                                       ‫‪5 = MIXED‬‬

                ‫‪ 8 -useBenchmark‬עבור לא להשתמש בבנצ'מרקינג בזמן האבולוציה ו-1 עבור כן להשתמש.‬

  ‫לאחר ההרצה תיווצר תיקייה בשם .‪ Run‬ואחריה שמות הפרמטרים (מלבד איטרציות, ודגל בנצ'מרק). לדוגמא‬
                                                                             ‫עבור הרצת הפקודה:‬
                                                 ‫92‬


‫0 4 61 61 4 5 23 5 4 0001 ‪Java –jar Darwin.jar‬‬

  ‫תיווצר התיקייה ”‪ .“Run.4.5.32.5.4.16.16.RMUTATION‬תיקייה זו תהיה תחת התיקייה ‪ .results‬בתוך התיקייה‬
 ‫שנוצרה יישבו מספר תיקיות כמספר הדורות כל אחד בשם ‪ GenerationIndexi‬כאשר ‪ i‬היא האינדקס עבור אותו‬
     ‫מספר של דור במודל הנדידה. לדוגמא אם הרצנו את הפקודה למעלה יהיו לנו התיקיות 8‪,GenerationIndex‬‬
  ‫1‪ GenerationIndex2 ,GenerationIndex‬ו-3‪ .GenerationIndex‬בתוך כל תיקייה כזו, יישבו כל תוכניות היוצאות‬
‫מהדור עם השם שלה כמספר הזיהוי של ועם סיומת ”‪ .“.com‬הקבצים הנוספים יהיו קבצים מסוג ‪ CSV‬שידווחו את‬
           ‫ביצועי הגנים ע"פ איטרציה מסויימת (‪ Generation_20.csv‬יהיה דיווח על האיטרציה ה-82). בסוף סיום‬
  ‫האיטרציות נוצר דיווח סופי בשם "‪ ."final.csv‬יש לשים לב שהפרוייקט אינו מוחק תיקיות קודמות אך אם ניתן לו‬
                                                      ‫אותו שם בשתי הרצות הוא ישכתב מעל קבצים קיימים.‬

            ‫במידה והאפשרות לביצוע בנצ'מרקינג הודלקה יווצרו קבצים ומבנה תיקיות דומה תחת התת-תיקיה‬
    ‫/‪ benchmarking/output‬דומים עם שינוי שם בהתאם. כאן יווצר קובץ סופי בשם "‪ "Run.csv‬בו יש את סכומי‬
  ‫התוצאות של התוכניות במבחן לאורך הדורות (כאשר השורות מייצגות את התוכניות בדור והעמודות הן לאורך‬
                                                                                          ‫הדורות).‬
                                     30



                        ‫המדריך למתכנת‬




Method/Member         Parameters/Type                  Description
Main()                Args – string array, the command Processes the input and operates
                      line parameters.                 the algorithm from the
                                                       command line input.
ValidInput()          Args – string array, the command checks if the given input is valid,
                      line parameters.                 if not gives appropriate
                                                       response.
NumericalErrorMsg()   Parameter – the given input.     gives out a numerical error
                      Description – the part the input output line.
                      plays.
CreateDirName()       Args - string array, the command returns a fitting directory name
                      line parameters.                 for the given parameters.




Method/Member         Parameters/Type                    Description
competition           Competition
battlesPerGroup       int                                how many battles the engine
                                                         does for each contest.
Benchmark             boolean                            use benchmarking or not.
botSize               int                                size of group/the number of bots
                                                         in the contest survivors folder.
                                     31


fightesPerGeneration   int                                how many times to select group
                                                          and run a contest.
generationSize         int                                size of the generation in genes.
id                     String
migrationInterval      int                                how many iterations between
                                                          migrations.
mutationRate           int                                how many genes to mutate.
numGenerations         int                                how many generations
                                                          participating in the migration
                                                          model.
op                     MutationOp                         Genetic operator.
Algorithm()            newID – a String that              Constructor for the algorithm
                       determines the name of             class.
                       the output folder.
                       numberGenerations - how
                       many generations
                       participating in the
                       migration model.
                       swapInterval - how many
                       iterations between
                       migrations.
                       newGenerationSize - size
                       of the generation in
                       genes.
                       newBattlesPerGroup - how
                       many battles the engine
                       does for each contest.
                       newBotSize - size of
                       group/the number of bots
                       in the contest survivors
                       folder.
                       newFightsPerGen - how
                       many times to select
                       group and run a contest.
                       newMutationRate - how
                       many genes to mutate.
                       newOp – the genetic
                       operator.
                       useBenchmark – wheter to
                       use benchmarking or not.
Run()                  Iterations – how many times to     executes the evolutionary
                       perform the algorithm loop.        algorithm a given number of
                                                          iterations.
MigrateGenerations()   Generations – a generation array   does a migration between the
                       that includes the generations      generations - randomly swaps 1
                       participating in the migration     gene between 2 generations, for
                       model.                             each generation.
CreateDir()            Dir – String, how to name the      creates a folder by the name of
                       folder.                            dir inside the results folder.
                                          32




Method/Member           Parameters/Type                   Description
subSurvivorDirs         String array                      A constant which specifies the
                                                          benchmarks warriors folder
                                                          names.
originalPath            String                            The current directory when the
                                                          benchmark is created.
numGeneration           int                               The current iteration.
BATTLES                 Constant int                      How many battles the engine
                                                          performs against each
                                                          benchmark warrior.
BENCHMARK_DIR           Constant string                   The name of the benchmark
                                                          directory.
Score                   2 dimensional double array        Saves the score for each gene for
                                                          each iteration.
Benchmark()             generationLength – int that       Benchmark constructor.
                        specifies the size of the
                        generation.
                        numGenerations – how much
                        iterations will run.
BenchmarkGeneration()   Generation – a Generation type.   benchmarks a generation and
                                                          updates the score accordingly.
StatisticsOut()         Filename – string with the        outputs the statistics of all the
                        wanted name for the statistics    genes score through the
                        file.                             iterations.
                                      33




Method/Member         Parameters/Type                      Description
Chromosome            Byte array                           the opcodes for the instruction.
Id                    int                                  identification
Fitness               double                               fitness value.
timesRun              int                                  How many times the gene has
                                                           fought with the current
                                                           chromosome.
Gene()                Id - int                             Gene constructor.
                                                           Initializes the chromosome to a
                                                           random 0-512 length byte array.
GetChromosome()                                            returns the gene's chromosome.
GetFitness()                                               returns the genes’ fitness.
GetID()                                                    returns the gene’s id.
IncrementTimesRun()                                        increments the times run.
PrintChromosome()                                          prints the choromosome as an
                                                           integer.
SetChromosome()       newChromo – byte array.              sets the gene's chromosome and
                                                           zero's the times run.
UpdateFitness()       newFitness – double, a new           updates the genes fitness based
                      score from a competition.            on the fitness function and the
                                                           new score.
WriteToFile()         filePath – string, in what path to   writes the genes as a ".com"
                      write the file.                      program file.
WriteToFile()         filePath – string, in what path to   writes the genes as a survivor
                      write the file.                      with the name "botName".
                      botName – what to call the bot
                      file.
compareTo()           otherGene- Generation                Compares 2 genes by fitness -
                                                           Used for sorting.
                                      34




Method/Member          Parameters/Type                     Description
geneMap                An arraylist of gene type           the genes.
botList                String array                        names of the bot files.
botSize                Int                                 the group size or how many bots
                                                           to write to the system.
choiceIndex            int                                 the position in the shuffled array
                                                           from which we updated last.
Op                     MutationOp                          which genetic operator to use in
                                                           the generation.
Path                   String                              directory path.
Generation()           Dir – String, the output directory. The Generation constructor.
                       genSz – int, generatin size in
                       genes.
                       botSz – int, group or bot size.
                       newOp – MutationOp, the
                       mutation operator.
WriteFitnessReport()   Filename – string, the name of      outputs a CSV file (with the
                       the report file.                    parameter as the name) with the
                                                           fitness information.
WriteAll()                                                 writes all the genes into .com
                                                           files in the path/results/ dir.
UpdateAllFitness()     Wr – WarriorRepository, the         updates the fitness of the genes
                       scores from the recent              in the generation that were not
                       competition.                        updated yet (in this cycle) from
                                                           the score in the warrior
                                                           repository.
WriteToBots()                                              writes the genes from the
                                                           shuffled array after the choice
                                    35


                                                       index chosen into survivor files.
Mutate()              mutationRate – int, the amount   uses the assigned parameters to
                      of genes to mutate.              Mutate the generation.
UniformCrossover()    B1 – bytes array. First          each byte in the returned array
                      chromosome.                      is created from a random choice
                      B2 – bytes array. Second         of bits, each choice is either the
                      chromosome.                      byte in the first parameter array
                                                       or the second.
OnePointCrossover()   B1 – bytes array. First          swaps the left half in each byte
                      chromosome.                      in the first array with the right
                      B2 – bytes array. Second         half in the byte in the second
                      chromosome.                      array.
TwoPointCrossover()   B1 – bytes array. First          swaps the quarters in each byte
                      chromosome.                      in the first array with the
                      B2 – bytes array. Second         completing quarters in the byte
                      chromosome.                      in the second array.
RelativeMutation()    B – bytes array, the             returns a new array built as
                      chromosome.                      follows: copy the array, and
                      numBytes – how many times to     change numBytes in the array
                      randomize a random byte.         into a random byte.
SwapRandomGene()      Generation – the generation to   chooses 1 gene randomly in this
                      swap with.                       generation and the input
                                                       generation and swaps the 2.
CutSplice()           B1 – bytes array. First          returns a new array from a
                      chromosome.                      random part of the first
                      B2 – bytes array. Second         parameter and the rest of the
                      chromosome.                      second parameter from that
                                                       position till the end.
                                                ‫63‬



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

 ‫1. שינוי סף סיבובים עד לקבלת תיקו מ-882 אלף סיבובים ל-85 אלף סיבובים – למעשה שורד שמנצח רק‬
 ‫אחרי 85 אלף סיבובים אינו מעניין אותנו ולמעשה מקבל ציון של תיקו במקום ניצחון כקנס על כך שלוקח‬
   ‫לו זמן רב כל כך לנצח. קיבלנו גם מהירות גדולה יותר וגם מניעה של פתרונות מסויימים לא מעניינים.‬
 ‫2. ביטול מנגנון המהירות - קביעת מהירות של הרצה של סיבובים לשנייה ולמעשה ביטולו גורם להרצה על‬
                                                               ‫המהירות המקסימלית האפשרית.‬

   ‫השינויים שבוצעו נבחרו בקפידה על מנת לא להשפיע על פעולת המנוע ולשנות את תוצאותיו מהמנוע המקורי.‬

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

                                                                                              ‫תוצאות‬
              ‫מפאת קושי הביצועים בוצעו מספר ניסויים שהדגימו את פעולת המנוע שמהם ניתן ללמוד הרבה.‬




                                      ‫גודל אוכלוסייה: 48 | אופרטור גנטי: מוטציה יחסית | קצב מוטציה: 42‬

 ‫גרף זה נוצר על פונקציית הכושר כפי שהיא נכתבה באב הטיפוס וללא מודל הנדידה. גם כן זה היה כאשר נכתב‬
                                       ‫רק לוחם אחד לכל שורד במקום 2 לוחמים לכל שורד במצב הנוכחי.‬
                                                ‫73‬


  ‫ניתן לראות מספר דברים מגרף זה. האלגוריתם לומד לאחר כמה עשרות דורות, כאן בדור 55, לפתח לולאה.‬
                   ‫לאחר מספר קטן של דורות, כאן בדור 18, הוא לומד גם להפציץ את הזירה בצורה טובה.‬

 ‫לאחר מכן נראה שיש עלייה קטנה של הביצוע המקסימלי ועלייה ליניארית של ממוצע כל התוכניות בדור. ובכלל‬
  ‫ניתן לראות שבדור יש מספר קטן של תוכניות עם ציון בתחום 83-82 ושאר התוכניות בעלות ציון 8. זוהי עדות‬
‫לעובדה שרוב התוכניות הנוצרות אינן תקניות\לוגיות. מה שניתן לשער על המשך התקדמות היא שלאחר המשך‬
                                                   ‫עלייה של ממוצע הדור, יעלה במדרגות הציון המקסימלי.‬




                                  ‫גודל אוכלוסייה: 852 | אופרטור גנטי: מוטציה יחסית | קצב מוטציה: 021‬

                      ‫כאן אנו רואים את ביצוע התוכנית עם פרמטרים שונים באותה גרסא כמו הגרף הקודם.‬

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


                             ‫גודל דור: 48 | מספר דורות: 1 | קצב מוטציה: 23 | אופרטור גנטי: מוטציה יחסית‬

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

            ‫ניתן לראות שיש שיפור קטן במהירות של גילוי לולאה וכתיבה לזיכרון והגעה לתוצאות טובות יותר .‬

      ‫ניתן לייחס את הקדמת גילוי הלולאה ולכתיבה או לרעש אקראי או לפונקציית הכושר החדשה. את השיפור‬
                                             ‫בביצועים ניתן לייחס לכתיבת 2 לוחמים בניגוד לשורד אחד.‬

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




            ‫גודל דור: 48 | מספר דורות: 4 | מרווח נדידה: 5 | קצב מוטציה: 23 | אופרטור גנטי: מוטציה יחסית.‬

     ‫עקום האדום כאן הוא מקסימום מבין המקסימומים של 4 הדורות, והכחול הוא הממוצע של הממוצעים של 4‬
                                                                                         ‫הדורות.‬

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

                                                                                          ‫עבודה לעתיד‬
                                                       ‫ניתן לראות מספר דברים אשר ישפרו את הפרוייקט.‬
                                                 ‫93‬


‫בחזית הביצועים, ניתן לחקור את מנוע המשחק ולשפרו, ידוע כי שינויים שבוצעו למנוע מהגרסא הקודמת איפשרו‬
  ‫לו לרוץ אלפי פעמים בשנייה. דבר נוסף שמאפשר מודל הנדידה היא ביזור של האלגוריתם, ניתן להקים שרת או‬
  ‫רשת כלשהיא בה מחשבים רבים מריצים דורות ומבצעים החלפות בינם לבין עצמם וכך מושג חישוב מהיר יותר.‬

   ‫בחזית שיפור האלגוריתם, ניתן לראות שהקושי הגדול ביותר באלגוריתם היא הכמות השולטת של תוכניות לא‬
  ‫חוקיות\לוגיות. על כך אפשר לעשות שני דברים. פתרון ראשון הוא פתרון עקיף לבעיה והוא להשתמש בבחירת‬
 ‫טורניר לחישוב פונקציית הכושר, וכך יש הבטחה כי תוכניות גרועות מול תוכניות גרועות לא ישיגו תוצאות טובות‬
      ‫ובכך יקטינו את דיוק פונקציית הכושר. פתרון זה גם אמור להקטין את סטיית התקן או "הרעש" שנראה על‬
       ‫הגרפים. פתרון אחר הוא להשתמש בטכניקות של אלגברה בוליאנית על מנת ליצור פונקצייה מייצרת של‬
‫אופקודים של 8080 חוקיים ולשנות את האופרטורים שייצרו צאצאים בצורה זו. לצערי אינני בעל ידע מספק לדעת‬
                                                ‫האם הדבר אפשרי אבל מאינטואציה קיימת נראה הדבר כך.‬
                                                    40



                                           ‫ביבלוגרפיה‬

Andresen, D. G. (2001, August 23). The Garden: Evolving Warriors in Core Wars. Retrieved from
http://www.angio.net/res/garden.ps

Boar, J. (n.d.). GA_WAR. Retrieved from http://www.infionline.net/~wtnewton/corewar/evol/ga_war.c

Colman, R. (1998). Learning By Simulating Evolution Using Corewars. Retrieved from
http://www.geocities.com/CapeCanaveral/Launchpad/6898/paper.html

Hillis, D. (1998). Evolving Core Warriors. Retrieved from
http://www.infionline.net/~wtnewton/corewar/evol/evolving.txt

Perry, J. (n.d.). Core Wars Genetics: The Evolution of Predation. Retrieved from
http://www.ecst.csuchico.edu/~pizza/koth/evolving_warriors.html

Thorsell, L. (1999, November 02). Evolving Warriors. Retrieved from
http://corewar.co.uk/thorsell/paper.htm

Wilkies, J. (n.d.). JKW's Beginner's Benchmark. Retrieved from http://www.koth.org/wilkies/

μGP Group. (n.d.). On The Evolution of Corewar Warriors. Retrieved from
http://www.cad.polito.it/FullDB/exact/cec2004b.html

								
To top