Embed Size (px)
Citation preview
1
בס"ד
67842קורס
מבוא לבינה מלאכותית
פרויקט מסכם
MasterMind -בול פגיעה
השוואה בין אלגוריתם חיפוש רנדומלי גנטיחיפוש לבין אלגוריתם
פרופ' ג'ף רוזנשיין מרצה:
לירון כהן מתרגל:
מגישים:
2
תוכן העניינים
o 3 . . . . . . . . . רקע
o GUI . . . . . . . . . 3
o AutoPlayer . . . . . . . 5
o 5 . . . . . . . . יעדים
o 6 . . . . . . . . גישות
o 7 . . . . . . . האלגוריתמים
פונקציית הfitness . . . . . 7
9 . . . . . האלגוריתם הגנטי
11 . . . . . האלגוריתם הרנדומלי
o 11 . . . . . . . . תוצאות
o 15 . . . . . . . סיכום ומסקנות
o 17 . . . . . . . . נספחים
17 . . . . . . רשימת הקבצים
18 . . . . . תוצאות סטטיסטיות
12 . . . . הקוד של האלגוריתמים
3
רקע
(MasterMindפגיעה )-בולהמשחק
הינו משחק לשני שחקנים, אחד בתפקיד המקודד והשני בתפקיד המפענח. 'פגיעה-בול'משחק ה
חזרה על צבעים מותרת(.כאשר ) צבעים Cמתוך מאגר נתון של Pבתחילת המשחק המקודד בוחר קוד באורך
הנדרשים לשם כך. הוא מבצע זאת על ידי יםמטרת המפענח הינה לפצח את הקוד הסודי, תוך מזעור מספר התור
המפענח מקבל משוב מהמקודד אודות 'טיב' ,סדרת ניחושים, כאשר כל ניחוש הוא תור במשחק. על כל ניחוש
המשוב משמש את המפענח לצורך מציאת הניחוש הבא שלו. הניחוש.
.לקוד הסודי המקורי של המקודדה'פגיעות' בניחוש, ביחס המשוב מוגדר כזוג סדור של מספר ה'בולים' ומספר
גם בקוד הסודי. iמופיע במיקום xוכמו כן אותו צבע ,בניחוש iהמופיע במיקום xקיים צבע -'בול'
בקוד הסודי. j<>iמופיע במיקום xבניחוש, אולם אותו הצבע iהמופיע במיקום xקיים צבע -'פגיעה'
הצבעים המשותפים הנמצאים במיקום הנכון, ואילו מספר מספר ה'בולים' מייצג את מספר במילים פשוטות,
ה'פגיעות' מייצג את מספר הצבעים המשותפים שאינם נמצאים במיקום הנכון.
'בולים' מיוצגים ע"י פינים שחורים, 'פגיעות' מיוצגות ע"י פינים לבנים.
ם במקום הנכון.כלומר, כל הצבעים נמצאי –'בולים' Pהמשחק מסתיים כאשר המקודד נותן משוב של
(.C=6,P=4) צבעים 6מתוך מאגר של 4משחק ה"בול פגיעה" הקלאסי מוגדר ע"י קוד באורך
Super MasterMindגרסת בשלהן. לדוגמא, C -ו Pערכי בהנבדלות זו מזו ת של המשחק, ונוספ אותת גרסוקיימ
(.C=8,P=5) צבעים 8מתוך מאגר של 5 קוד באורך השחקן בוחר
GUI
ממשק
, אותו הרחבנו והתאמנו לצרכינו. לשימוש חופשי, המיועד 1את ממשק המשתמש יצרנו על בסיס ממשק מוכן
הוראות הפעלה
. באמצעות דפדפן applet.html( ולאחר מכן להפעיל את הקובץ Makefile)מצורף JAVAיש לקמפל את קבצי ה
( applet.htmlבלבד לכן חשוב ראשית לקמפל את הקבצים, ולוודא שכולם )ביחד עם classהקובץ מריץ קבצי
תיקייה.הבאותה נמצאים
1 http://richardbowles.tripod.com/durham/ai/mastermind/mastermind.htm
4
מסך הבחירה
-צים )ימינה או שמאלה(יעל ידי לחיצה על הח
יש לבחור את גודל מאגר הצבעים (C) צבעים. 20עד 6. על המאגר להיות בגודל של
הקוד אורךיש לבחור את (P) .מספר הצבעים ל שווה-קטן הוא מוכרח להיות, ו4הקוד המינימלי הוא אורך
(.C>=P) במאגר
רוצים להשתמש: אלגוריתם באיזהיש לבחורGenetic אוRandom Restart Hill Climbing.
מסך בחירת הצבעים
כעת מוצג מאגר הצבעים למשתמש )בהתאם לגודל המאגר שהוא בחר במסך הבחירה(. על המשתמש לבחור קוד
הקוד גם הוא בהתאם לגודל שבחר המשתמש במסך הבחירה. אורךמתוך צבעים אלה,
םהניחושימסך
ביעת מספר במסך זה מוצג למשתמש הניחוש החדש של המחשב )בחלק העליון(, ועליו לתת לו ציון על ידי ק
לחיצה על החיצים כדי להעלות או להוריד את מספר הפינים השחורים ת, זאת באמצעותהבולים ומספר הפגיעו
. )מספר הבולים והפגיעות, בהתאמה( והלבנים
.התקבל עליהםש משובבמידה וזהו לא הניחוש הראשון של המחשב, מוצגים גם כל ניחושיו הקודמים וה
.Doneעל המשתמש ללחוץ על כפתור ה בסיום מתן המשוב,
.בצע ניחוש נוסףהמחשב יבמידה וזהו לא הפתרון הנכון,
5
Auto player
מטרה
הנה ליצור שחקן ממוחשב, אשר יחליף את השחקן האנושי. התוכנה בוחרת AutoPlayer.javaתוכניתמטרת ה
ונותנת ,Brain.java-מתוכנית ה)במקום המשתמש האנושי(, מקבלת ניחושים באופן רנדומלי בעצמה קוד סודי
.המשוב על כל ניחוש באופן אוטומטיאת
. השחקן הרצת מספר רב של משחקים באופן אוטומטימטרת השחקן הממוחשב היא יצירת סטטיסטיקות, על ידי
כנגד כל אחד מהאלגוריתמים המשתמש(מ)אשר מספרם נקבע ע"י קלט האוטומטי משחק משחקים רבים
, ומדפיס לקובץ את תוצאותיהם.שמימשנו
שימוש
[מספר הצבעים=C] אורך הקוד[=P]מספר משחקים[ =N] פרמטרים: לושהיש להריץ את הקובץ עם ש
פעמים עבור כל אלגוריתם, 500האוטומטי תריץ את השחקן java AutoPlayer 6 4 500 , הפקודה:לדוגמא
.(C=6,P=4) 6ומאגר צבעים בגודל 4באורך במשחק עם קוד
בסיום הריצה. statistics[C]X[P].csvאת תוצאות המשחקים ניתן לראות בקובץ
יעדים
צבעים, כאשר חזרה על צבעים מותרת. 6מתוך מאגר בגודל 4כאמור, המשחק הקלאסי מורכב מקוד באורך
פתרונות אפשריים, מספר סביר לחישוב. 1296=64כלומר, מרחב החיפוש עבור הפתרון הינו בגודל של
אורך הקוד. Pגודל מאגר הצבעים, C( כאשרC,Pבפרויקט זה נכליל את המשחק הקלאסי ונגדיר משחק כזוג )
. כלומר, מרחב החיפוש גדל באופן CP(, כי גודל מרחב החיפוש הינו C,Pמתקיים, עבור משחק בגודל )
פתרונות 100,000,000=108(, לדוגמא, מכיל 10,8של המשחק. המשחק )אקספוננציאלי עם גדילת הפרמטרים
פתרונות אפשריים. 576,650,390,625( כבר מכיל 15,10אפשריים במרחב החיפוש. והמשחק )
)בהינתן סדרת ניחושים ומשוביהם, האם קיים ניחוש חוקי?( מוכרת MasterMindבעיית הספיקות של משחק ה
שלמה.-NPבספרות המקצועית כבעיה
נזכיר גם כי מטרת המשחק הינה לפצח את הקוד הסודי במספר מינימלי של ניחושים.
מפענח לעמוד בשני היעדים הבאים במקביל:-לכן, על אלגוריתם המממש שחקן
גודל המשחקכפונקציה של , הנדרשים להגעה לפתרוןמספר הניחושים תוחלת מזעור (C,P). נזכיר כי זו(
לפצח את הקוד הסודי במספר מינימלי של ניחושים(. בדיוק מטרת המשחק:
6
משמעותי כאמור, הופך ל) החיפוש במרחב החיפוש ורזאזמן הריצה של האלגוריתם, ע"י מזעור מזעור
גדולים(. P-ו Cעבור
, נציג את Hill-Climbingאלגוריתם גנטי ואלגוריתם וש של שני אלגוריתמי חיפוש שונים:בעבודה זו נציג מימ
השיקולים השונים הנוגעים למימושם ונשווה וננתח את תוצאותיהם במשחקים בגדלים שונים.
גישות
קיימות גישות רבות, ונערכו מחקרים רבים אודות מימוש אלגוריתם יעיל לפתרון MasterMind-למשחק ה
המשחק. נציג בקצרה כמה גישות מתוכם:
. אך כיצד נמצא סידור כזה?)שחקן אנושי בד"כ ישחק כך(מצא סידור חוקי ושחק אותו -הגישה הנאיבית
. ממומש ע"י בניית עץ לכל ניחוש ים הבאיםמצא את הפתרון שימזער את תוחלת מס' הניחוש -Rosu2הגישה של
ובחירת הניחוש בעל העץ המינימלי המורכב מכל ההסתעפויות האפשריות עבור כל ניחוש במרחב החיפוש,
מספר הניחושים הבאים תהיה מינימלית(. האלגוריתם מציג תוצאות יפות עבור מזעור בעומקו )כלומר שתוחלת
, Full Enumeration מספר הניחושים הנדרשים לפתרון, אולם דורש זמן חיפוש לא ריאלי משום שהוא מבצע
.הקודקודים במרחב החיפוש, ובניית עץ המורכב אף הוא מכל הניחושים במרחב החיפוש כלפיתוח כלומר,
עד שמצאנו שלב ראשון :ובכל שלב משתמש אסטרטגיה אחרת מבצע חלוקה לשני שלבים -Bento3הגישה של
ונותר רק לקבוע את הסדר שלהם. שכל הצבעים ידועים אחרשלב שני ל, והמרכיבים את הקוד הצבעיםכל את
.של הניחוש 'חוקיות'ההמעריכה את fitnessחיפוש עם פונקציית -4Mereloהגישה של
, למרות היותה טובה מאוד למזעור מספר הניחושים, אינה אפשרות סבירה כאשר Rosuברור כי הגישה של
( גדולים עקב זמן הריצה האינטנסיבי )מאוד!( שלה.C,Pמכלילים את המשחק ל )
הניחוש ביחס , ומבצעים חיפוש תוך הערכת החוקיות שלMereloבעבודה זו אנו מממשים ווריאציה על הגישה של
לפתרונות קודמים, על כך יפורט בהמשך.
2 Radu Rosu. Analysis of the game of Mastermind - the mn case. Undergraduate thesis, North Carolina State University, 1997.
http://www.csc.ncsu.edu/academics/undergrad/Reports/rtrosu/ 3 Luís Bento, Luísa Pereira, and Agostinho Rosa. MASTERMIND by Evolutionary Algorithms. http://delivery.acm.org/10.1145/300000/298360/p307-
bento.pdf?key1=298360&key2=6823389921&coll=DL&dl=ACM&ip=132.65.16.64&CFID=11969966&CFTOKEN=99784046 4 J. J. Merelo, J. Carpio, P. Castillo, V. M. Rivas, and G. Romero. Finding a needle in a haystack using hints and evolutionary computation: the case of
Genetic MasterMind. GeNeura Team. Departamento de Arquitectura y Tecnología de los Computadores Universidad de Granada. http://kal-el.ugr.es/~jmerelo/newGenMM/
7
האלגוריתמים
יישמנו שני אלגוריתמי חיפוש: אלגוריתם גנטי המשחק בתפקיד השחקן המפענח, כדי ליצור שחקן ממוחשב,
.Random Restart Hill-Climbingואלגוריתם
מוצג למשתמש, וזה מציין את מספר הבולים בשני האלגוריתמים, ניחושו הראשון של המחשב הוא רנדומלי. הוא
ומספר הפגיעות. סדרת הניחושים הבאים )עד למציאת הקוד המדויק( מחושבת לפי סוג האלגוריתם שבחר
המשתמש להפעיל.
fitness-פונקציית ה
שימוש
את טיב הניחוש העומד על הפרק, מעריכה ,משמשת את שני האלגוריתמים שמימשנו , אשרfitness הפונקציית
ולבסוף לבחור את הניחוש הטוב ביותר האפשרי. ,להשוותו אל מול ניחושים אפשריים אחריםעל מנת
מימוש
אשר תחשב fitnessוסדרת הניחושים הקודמים עם ערכי המשוב שלהם, נרצה להגדיר פונקציית gבהינתן ניחוש
שהגדרנו מחשבת את fitness. פונקציית ההאפשריים שאר הניחושיםביחס ל gותדרג באופן מספרי את הניחוש
ברשותנו אודות הקוד המוצפן )מידע שנאסף בתורות קודמים קייםה'חוקיות' של הניחוש ביחס למידע שכבר
(.הניחושים הקודמים עבור באמצעות המשוב שהתקבל
באופן הבא: ,ביחס אליו gשכבר בוצע, נחשב את החוקיות של הניחוש , aiעבור כל ניחוש
ונשווה אותו למספר ה'בולים' ,ai ,קודםהניחוש המול g נספור את מספר ה'בולים' וה'פגיעות' של הניחוש הנוכחי
פגיעה(. -)אנו משתמשים בטרנזיטיביות של ניקוד הבול sכמשוב ביחס לפתרון aiוה'פגיעות' שקיבל הניחוש
של הניחוש הנוכחי והניחוש הקודם. 'פגיעות'וה 'בולים'בין מספרי ה התאמה-נרצה לתת ערך שלילי עבור כל אי
התאמה:-נבחין בין שני סוגים של אי
כלומר, סכום ה'בולים' וה'פגיעות' של כל אחד מהניחושים שונה. בניחוש אחד יש .הצבעים שונה מספר
ההפרש בין כמויות הצבעים.יותר צבעים 'נכונים' מאשר בניחוש השני. ניתן מספר נקודות שלילי כגודל
כלומר, עבור צבע משותף, בניחוש אחד מופיע 'בול' ובשני מופיעה כנגדו 'פגיעה'. ניתן חצי .סוג שונה
נקודה שלילית על כל אי התאמה כזו.
בחנה בין שני המקרים היא לדרג את הניחושים השונים על פי קרבתם לפתרון חוקי, כאשר ברור כי מטרת הא
אשית תהיה התאמה בצבעים ואח"כ חשובה ההתאמה במיקומם של הצבעים הנ"ל.חשוב יותר שר
8
שבוצעו aiבעודו מושווה מול כל אחד מהניחושים הקודמים gהנקודות השליליות נצברות עבור הניחוש הנוכחי
של הניחוש. fitness במשחק ומשובם. בסוף התהליך הסכום השלילי המתקבל הוא ערך ה
ניחוש שאין בו סתירות מול אף לא אחד מהניחושים הקודמים, והוא קונסיסטנטי לחלוטין עם ניחוש חוקי, כלומר
במשחק. fitnessמהלך המשחק, יזכה לניקוד המקסימלי בשווי אפס, וזהו המקסימום הגלובלי של ערך פונקציית ה
של ניחוש fitnessלהערכת ערך דוגמא
בונן במצב המשחק הנתון:נת
ו לניחוש הראשון נקבל בול הינו קונסיסטנטי לחלוטין עם המידע שיש ברשותנו: נשווה אות אזי הניחוש
משוב זהה ל , נקבל בול אחד,. נשווה לניחוש השני0ולכן ההפרש הוא ,הניחוש הראשון משוב שלזהה ל ופגיעה,
סה"כ ערך בהה. ולכן ז -שוב , נקבל שתי פגיעות,. נשווה לניחוש השלישי0ולכן ההפרש שוב ,הניחוש השני של
חוקי.הוא אין שום סתירות ולכן הניחוש – 0של הניחוש יהיה fitnessה
, אינו קונסיסטנטי לחלוטין עם המידע שיש ברשותנו: נשווה אותו לניחוש הראשון לעומת זאת הניחוש
, נקבל בול . נשווה לניחוש השני0ההפרש הוא , בינתיים,ולכן ,זהה לתוצאת הניחוש הראשון נקבל בול ופגיעה,
אותו ,כלומר ,נקבל פעמיים בול ,ולכן נוסיף נקודה שלילית. נשווה לניחוש השלישי ,צבע אחד יותר ,כלומרופגיעה,
לית על כל אי התאמה )ויש שתייםלכן נוסיף חצי נקודה שלי ,מספר צבעים אבל לא זהים מבחינת בול/פגיעה
, -2של הניחוש יהיה הכולל fitness. וסה"כ ערך העבור ההשוואה הזו נקודה אחת שליליתנו קיבלכאלו(, סה"כ
.פתרון חוקיל כלומר, הניחוש אינו חוקי אבל הוא 'קרוב'
fitness-שיקולים לבניית פונקציית ה
בחנה בין ניחושים חוקיים שונים. אם ישנם שני ניחושים שונים אשלנו למעשה לא מבצעת fitnessפונקציית ה
אפס –שהינם קונסיסטנטיים עם הסדרה הנתונה של ניחושים קודמים ומשוביהם, אזי הם יקבלו את אותו ערך
)ערך המקסימום הגלובלי(. על מנת להבחין בין ניחושים חוקיים ולדרג אותם, היינו צריכים לבדוק כיצד הניחושים
לבדוק אילו משובים ,(, או לחילופיןRosuיעו על המהלכים הבאים של המשחק )כפי שנעשה בגישה של ישפ
אפשריים הניחושים יכולים לקבל וכדומה. אולם חישובים כאלו דורשים פיתוח אקספוננציאלי של מרחב החיפוש
מעריכה כל ניחוש באופן ה פונקציה( גדולים. לכן, התמקדנו במציאת C,Pואינם ישימים עבור משחקים בגודל )
, אלא רק בניחוש עצמו ובמידע שלנו על ה'עולם' הנתון לנו ע"י סדרת עצמאי בלי תלות בשאר הניחושים האפשריים
הניחושים הקודמים ומשוביהם.
9
אלגוריתם גנטי
נתון.מטרת האלגוריתם הגנטי ליצור באופן איטרטיבי שיבוטים של ניחושים טובים מתוך מאגר ניחושים
. POPULATION_SIZEבגודל ',אוכלוסייה, הנקרא 'ראשית, האלגוריתם יוצר באופן רנדומלי מאגר ניחושים
, המסמל עד כמה הניחוש הוא 'טוב'. fitnessעבור כל ניחוש באוכלוסייה אנו מבצעים חישוב של ערך ה
לאחר מכן אנו בוחרים . POPULATION_SIZEאנו מייצרים קבוצת צאצאים של האוכלוסייה בגודל בכל שלב,
תהליך זה בתהליך של 'ברירה טבעית' את הניחושים הטובים ביותר, וממשיכים לייצר צאצאים שלהם בשלב הבא.
, כלומר מקסימום גלובלי( או עד מקסימום של 0-השווה ל fitnessעד למציאת ניחוש חוקי )ערך מתבצע
NUM_GENERATION דורות(. 30הוגדר מינימום של לפחות )בכל מקרה, פעמים
מתבצע באופן הבא:שינוי(, וו שיבוט מחולק לשלושה שלבים )בחירה,ייצור הצאצאים
(Selectionבחירה )
וההכלאה של שניהם תיצור ניחוש חדש. 'הורים'באופן רנדומלי. זוג הניחושים ישמשו כ בוחרים זוג ניחושים
של כל הניחושים שבה, ומייצרת אובייקט fitnessהאוכלוסייה עם דירוג הלשם כך, יצרנו מחלקה המקבלת את
Random המחזיר בכל פעם אינדקס של אחד הניחושים מהאוכלוסייה, בהסתברות פרופורציונאלית לערכי
ככל שהערך של ניחוש גבוה יותר, כך ההסתברות שהוא יבחר גבוהה יותר, . כלומר,באוכלוסייה השונים fitnessה
באמצעות הניחושים הטובים יותר באוכלוסייה, וכך , בממוצע,כך אנו מוודאים ששיבוט הפתרונות יעשה ך.ולהפ
טובה יותר מהאוכלוסייה שקדמה לה. צפויה להיות אוכלוסיית הצאצאים
כמובן שהבחירה אינה מבטיחה שיבוט של פתרונות טובים בלבד, וכך אנו מאפשרים גיוון של האוכלוסייה
ממצבי מקסימום מקומי. יחלצותוה
(Cross Overשיבוט )
שלהם. fitnessאת ערכי פונקציית ה אנו משוויםהמיועד להכלאה, יםעבור כל זוג ניחוש
מהגנים של הניחוש הפחות טוב מביניהם. 1/4-מהגנים של הניחוש הטוב יותר, ו 3/4 בחרנו לקחת
חצי(.-)חציאם הניחושים טובים באותה מידה, היחס יהיה שווה
( שעד אליה לוקחים את הגנים של ניחוש אחד, וממנה והלאה לוקחים את pivotאנו בעצם מגדירים נקודת חלוקה )
של הניחושים, תוך מתן fitnessהגנים של הניחוש השני. מיקום נקודת החלוקה נקבע על פי ערך פונקציית ה
טוב יותר מביניהם.ניחוש המשקל רב יותר ל
(Mutationשינוי )
נבצע בו שינוי. במקרה שלנו(, 0.05מסוימת ) עבור כל ניחוש באוכלוסייה החדשה, בהסתברות
ממצבי מקסימום מקומי. היחלץמטרת השינוי היא לגוון את האוכלוסייה, לשפר את מרחב החיפוש ול
10
בניחוש, והחלפת השינוי הוא בחירה באופן רנדומלי של 'גן' של הניחוש, כלומר, אינדקס המציין מיקום של צבע
באופן רנדומלי. אף הוא נבחרה ,הצבע שנמצא בו לצבע אחר
גודל האוכלוסייה ומספר הדורות
ניחושים יחד עם מספר 150מקומות, גודל אוכלוסייה של 4-צבעים ו 6מצאנו כי עבור המשחק הקלאסי, בו ישנם
העוסקים בנושא. מניב תוצאות טובות. מספרים אלו נתמכים אף במאמרים 30דורות בגודל
בין מספר הדורות לגודל האוכלוסייה. 5-ל 1על מנת להכליל את המספרים הללו, החלטנו לשמר את היחס של
. גודל האוכלוסייה נקבע 30הגדרנו את מספר הדורות כמקסימום בין מכפלת מספר הצבעים ואורך הקוד לבין
ממספר הדורות. 5להיות פי
.(C,P) המשחקגודל נטי תלויים למעשה בפרמטרים של כך הפרמטרים של האלגוריתם הג
פתרון חוקי, אזי אנו 'הורגים' את נמצאכי אם ביצענו מהלך שלם של יצירת כל הדורות מבלי ש ,כמו כן, הגדרנו
האוכלוסייה, ומאתחלים אותה מחדש, תוך הגדלת הפרמטרים של גודל האוכלוסייה ומספר הדורות. לאחר
פעמים לביצוע 3האתחול מריצים שוב את האלגוריתם ומחפשים פתרון חוקי. גם כאן קבענו חסם עליון של עד
פעמים, אנו מחזירים את הפתרון הטוב 3מצאנו פתרון חוקי לאחר הריגה ואתחול מחדש של האוכלוסייה, אם לא
., למרות שהוא אינו חוקיהגבוה ביותר( fitnessביותר שמצאנו )בעל ערך
היא נמוכה, שכן יש צורך אחד פתרון חוקי אף לאההנחה היא כי ההסתברות שנגיע למצב בו לא מצאנו
ד באזור מצומצם בתוך מרחב החיפוש, על מנת להגיע למצב באוכלוסייה התחלתית 'לא טובה', אשר תישאר תמי
כזה. ומכיוון שהאוכלוסייה ההתחלתית מיוצרת באופן רנדומלי לחלוטין, ההסתברות לייצר אוכלוסייה התחלתית
'לא טובה' כזו היא נמוכה. לכן מהלך של הריגת האוכלוסייה ואתחולה מחדש אמור לחלץ אותנו ממצב כזה באם
. מלכתחילה וכאמור, ההסתברות כי נקלע אליו הינה נמוכה נקלענו אליו.
הממוצע הניחושים פרמס למוזמן הריצה
אם "נתעקש" על ניחושים חוקיים בלבד, נאלץ להגדיל את מספר הניחושים באוכלוסייה, את מספר הדורות, ואת
שמעותי את זמן הריצה של מספר הפעמים בו נרשה להרוג אוכלוסייה ולאתחלה מחדש. כל אלו מגדילים באופן מ
מספר הניחושים עד להצלחה. לכן, על מנת תוחלת האלגוריתם, אך בד בבד, מניבים תוצאות טובות יותר מבחינת
לייצר זמני ריצה סבירים עבור קלטים גדולים, אנו מאפשרים גם מתן ניחושים לא חוקיים )לא קונסיסטנטיים עם
. ניחושים בלתי fitnessטוב ביותר מביניהם עפ"י דירוג פונקציית ההתוצאות הקודמות(, כאשר תמיד ניקח את ה
-ואף חוקיים –חוקיים אלו מגדילים את המידע שלנו על "העולם" ומאפשרים לנו לייצר ניחושים טובים יותר
בתורות הבאים. אך כאמור, נדרשים לנו ניחושים רבים יותר על מנת להגיע לפתרון הקוד, מאשר אם היינו
בין זמן הריצה למספר הניחושים, כאשר 'אוף-טרייד'בד. לכן ניתן לומר כי קיים ים בניחושים חוקיים בלמשתמש
משפיע לרעה על( השני. כלומר,שיפור של אחד מהם בא על חשבון )
הגבלות
האלגוריתם הגנטי הינו אלגוריתם מורכב מעצם הגדרתו, ומעורבים בו פרמטרים רבים המשפיעים באופן שונה על
כי אם היינו מגדירים אחרת פרמטרים מסוימים )כגון גודל האוכלוסייה, ,ואף סביר ,תפקוד האלגוריתם. ייתכן
11
ועוד( היינו מקבלים תוצאות שונות, fitnessמספר הדורות, פונקציית המוטציה, פונקציית השיבוט פונקציית ה
ויקט, מצאנו כי הפרמטרים שהגדרנו עונים טובות יותר או טובות פחות, בתפקוד האלגוריתם. אולם, במסגרת הפר
על הדרישות באופן הטוב ביותר ביחס לבדיקות שביצענו.
(Random Restart Hill-Climbingאלגוריתם רנדומלי )
, האלגוריתם מחפש את הניחוש הטוב ביותר להציג למשתמש משוביהםבהינתן סדרת הניחושים שהיו עד כה ו
בשלב הבא, על ידי:
fitness -פונקציית הזהו השכן שעבורו שכניו של הניחוש האחרון, ומציאת השכן הטוב ביותר )מעבר על (1
(.מחזירה את הציון המקסימלי
טוב יותר. אם fitnessמעבר על שכניו של הניחוש שנמצא בשלב הקודם ובדיקה האם ישנו שכן בעל ערך (2
.2נמצא שכן כזה, חוזרים על שלב
3) Random Restart- עלזהנעשית חזרה על שלב על ניחוש זה. 2חוש רנדומלי והפעלת שלב בחירת ני ,
בהמשך( או -, מספר מסוים של פעמים )פירוט על קביעת פרמטר זהמנת להיחלץ ממצבי מקסימום מקומי
(.0המקסימלי )שהוא fitness -עד שנמצא ניחוש שמקבל את ערך ה
החזרת הניחוש הטוב ביותר שנמצא. (4
?מהו שכן של ניחוש
-שכן של ניחוש הוא ניחוש שזהה לניחוש המקורי, פרט למקום אחד, בו יש צבע שונה. לדוגמא
אם הניחוש המקורי הוא
)כאן הוחלף רק הצבע במקום הימני ביותר( דוגמא לניחוש שכן היא
והוחלפו הצבעים גם של הניחוש המקורי, היות ישיר אינו שכן לעומת זאת, הניחוש
ם הימני ביותר וגם בשמאלי ביותר.במקו
מספר האתחולים הרנדומליים
מספר האתחולים הינו מספר הפעמים שהאלגוריתם מתחיל עצמו מחדש )מנקודת מוצא שונה(. מספר זה נקבע
ניחושים מספר ה –השיקול בבחירת מספר האתחולים נבע משני נתונים עיקריים . RESTART_TIMESע"י פרמטר
, וזמן הריצה. שנדרשו כדי למצוא את הקוד
12
ככל -מספר הניחושים .א
שהפרמטר מקבל ערך
גבוה יותר, כך מספר
יורד. ניחושים הנדרשיםה
כמו כן, ישנה תלות בין
מספר הצבעים במאגר
הצבעים לבין מספר
-האתחולים הנדרשים
ככל שמספר הצבעים
במאגר גבוה יותר, כך
מספר גבוה יותר של נדרש
אתחולים על מנת למצוא ניחוש טוב, היות ומרחב החיפוש גדל. בנוסף, ככל שמספר הניחושים שהיו עד
כה גדל, נדרשים יותר אתחולים על מנת למצוא ניחוש חדש שהוא עקבי עם כל שאר הניחושים )כלומר,
חוקי(.
אתחולים גבוה יותר, זמן הריצה יתארך, זמן הריצה תלוי במספר האתחולים, ככל שמספר ה -זמן הריצה .ב
בעיקר במשחקים עם מאגר צבעים גדול, בהם נדרש מספר אתחולים גדול.
בסופו של דבר, הפרמטר הוא פונקציה של מספר הניחושים שהיו עד כה ומספר הצבעים במאגר הצבעים. אך כדי
מן הריצה לא יהיה גבוה מדי.ניחושים, כדי שז 3,000בגודל נקבע חסם עליון קבוע להגביל את גודלו
200מספר הניחושים הממוצע כפונקציה של מספר האתחולים, עבור הירידה בניתן לראות את 1.1 איורב
.6וגודל קוד של 9משחקים, עם מאגר צבעים בגודל
תוצאות
הרצנו את שני האלגוריתמים על משחקים בגודל משתנה, ושמרנו את תוצאותיהם AutoPlayerבעזרת המחלקה
בקבצים על מנת לנתח ולבצע סטטיסטיקות.
משחקים )כתלות בזמן הריצה של משחק בודד, כפי שיפורט בהמשך(. 10-500( הורץ בין C,Pכל משחק בגודל )
התחלתי.-וש באותו ניחוש רנדומלישני האלגוריתמים ניסו לפצח את אותו הקוד, תוך שימ ,בכל פעם
הפרמטרים אותם בחנו בעת ההשוואה הינם מספר הניחושים הממוצע וזמן הריצה הממוצע.
ניתן לראות את מספר הניחושים הממוצע שביצע כל אחד מהאלגוריתמים עבור משחקים 2.2 -ו 2.1 איוריםב
, והציר C, ציר העומק מציין את מספר הצבעים במאגר ,Pאורך הקוד ,בגדלים שונים. הציר האופקי מציין את
(.C,Pהאנכי )הגובה( מציין את מספר הניחושים הממוצע עבור משחק בגודל )
8.8
7.8
7.7
2
7.4
4
7.4
9
7.2
7
7.3
95
7.2
7.2
15
7.1
45
6.9
8
7.0
6
7.0
5
7.0
4
7.1
05
7.0
65
0
2
4
6
8
10
0 100 200 300 400 500 600 700 800 900 1000 1100
Ave
rage
nu
m. o
f gu
esse
s
Restart times
Avg. Num. Of Guesses vs. Restart Num. average numberof guesses
1.1איור
13
נציין כי הבדיקה בוצעה עבור משחקים
)מספר הצבעים הוא C>=Pהמקיימים
לפחות כמספר המקומות(, ולכן קיים
אלכסון בגרף שהחל ממנו והלאה אין
(.0-נתונים )ערכם נקבע שרירותית ל
ניתן לראות כי נוצרו בשני הגרפים
מישורים יחסית לינאריים, המעידים על
עליה מתונה במספר הניחושים הממוצע
Pמ. אולם החל P-ו Cכפונקציה של
, כלומר קוד באורך של יותר 8-מהגדול
צבעים, מתרחשת קפיצה משמונה
אקספוננציאלית במספר הניחושים
הממוצע, והערך גדל בצורה חדה מאוד.
התנהגות כללית זו משותפת לשני
האלגוריתמים, והיא נובעת מהגדילה
האקספוננציאלית של מרחב החיפוש.
, CPפוש הינו נזכיר כי גודל מרחב החי
וניתן לראות בגרף התנהגות התואמת
Cלכך באופן מלא: הגדלת הערך של
מגדילה את מספר הניחושים באופן לינארי,
משפיעה באופן אקספוננציאלי. Pואילו הגדלת הערך של
ביניהם כאמור ההתנהגות הכללית של הגרפים שיוצרו ע"י שני האלגוריתמים היא דומה. אולם ניתן לראות הבדלים
ניתן לראות איזה אלגוריתם השיג את )ממוצע( התוצאות הטובות ביותר עבור 2.3 איורבפרטים הקטנים יותר. ב
המשחקים השונים שנבדקו. ניתן לראות
בבירור כי האלגוריתם הגנטי משיג תוצאות
טובות יותר, בממוצע, עבור משחקים בגדלים
קטנים יותר, ואילו האלגוריתם הרנדומלי משיג
תוצאות טובות יותר, בממוצע, עבור משחקים
גדולים יותר. כאשר הפרמטר הדומיננטי הוא
, C, ולא מספר הצבעים, Pכמובן אורך הקוד,
כפי שראינו.
נציין, עם זאת, כי ההבדלים בין הממוצעים
במשחקים הקטנים, בהם האלגוריתם הטוב
יותר הינו האלגוריתם הגנטי, הינם הבדלים
, העומדים על כמה עשיריות קטנים יחסית
Best Algorithm – Avg. Num. Of Guesses
Num. Positions
4 5 6 7 8 9 10
5 Genetic Genetic - - - - -
Nu
m. C
olo
rs
6 Genetic Genetic Genetic - - - -
7 Genetic Genetic Genetic Random Restart
- - -
8 Genetic Genetic Genetic Random Restart
Random Restart
- -
9 Genetic Genetic Genetic Random Restart
Random Restart
- -
10 Genetic Genetic Genetic Random Restart
Random Restart
Random Restart
Genetic
11 Genetic Genetic Genetic Genetic Random Restart
Random Restart
-
12 Genetic Genetic Genetic Random Restart
Random Restart
Random Restart
Random Restart
13 Genetic Genetic Genetic Random Restart
Random Restart
Random Restart
-
14 Genetic Genetic Genetic Random Restart
Random Restart
- -
15 Genetic Genetic Genetic Genetic Random Restart
- -
5
7 9
11 13 15
0
10
20
4 5 6 7 8 9 10
Ave
rage
Nu
m. G
ue
sse
s
Random Restart Avg. Num. of Guesses
20-26
10-20
0-10
5
7
9 11
13 15
0
10
20
4 5 6 7 8 9 10
Ave
rage
Nu
m. G
ue
sse
s
Genetic Avg. Num. Of Guesses
20-26
10-20
0-10
2.1איור
2.2איור
2.3איור
14
אולם בספרות המחקר העוסקת בנושא מייחסים חשיבות גם )ניתן לראות מספרים מדויקים בנספח(. הנקודה
להבדלים בסדרי גודל כאלו.
כי הקפיצה במספר הניחושים שמבצע האלגוריתם הגנטי היא גבוהה 2.2-ו 2.1 איוריםניתן לראות גם ב
בצע האלגוריתם הרנדומלי.משמעותית יותר מהקפיצה שמ
זמן הריצה הממוצע לניחוש
בעת הרצת הסטטיסטיקות מדדנו את זמן הריצה של כל משחק באמצעות טיימר ממוחשב. את הסטטיסטיקות
, בעלילמטה"( מחשבים במקביל, כולם במעבדת המחשבים של מדעי המחשב )"האקווריום הרצנו על מספר
ומהירות( הרץ-גיגה 2.6) הרץ-מגה 2667 של שעון במהירות intel core 2 quad™ Q9400,ליבות מסוג 4 עבדמ
BUSS תחת מערכת ההפעלה הרץ-מגה 1333 של ,LINUX GNOME . נציין כי יתכנו הבדלים בזמני הריצה
)על אף שסוג שונהשנמדדו הנובעים מכך שהסטטיסטיקות בוצעו על מחשבים שונים ובימים שונים, תחת עומס
. לכן הנתונים נותנים ייצוג כללי של זמני הריצה הממוצעים, אך אינם מדויקים באופן מלא ומוחלט.המכונה זהה(
את זמן הריצה הממוצע לניחוש של כל אחד ניתן לראות 2.5 -ו 2.4 איוריםבדומה לגרפים קודמים, ב
, ציר העומק מציין את P אורך הקוד, מהאלגוריתמים עבור משחקים בגדלים שונים. שוב, הציר האופקי מציין את
(.C,Pוהציר האנכי )הגובה( מציין את זמן הריצה הממוצע לניחוש עבור משחק בגודל ) ,C מספר הצבעים במאגר,
נזכיר כי הבדיקה בוצעה עבור
)מספר C>=Pמשחקים המקיימים
הצבעים הוא לפחות כמספר
המקומות(, ולכן קיים אלכסון בגרף
שהחל ממנו והלאה אין נתונים
כדי -500)ערכם נקבע שרירותית ל
שנוכל לראות היטב את המישור
שנוצר(.
ניתן לראות כי בדומה לגרפים
קודמים, גם כאן נוצרו מישורים
יחסית לינאריים, המעידים על עליה
יצה הממוצע לניחוש מתונה בזמן הר
P. אולם החל מP-ו Cכפונקציה של
, כלומר קוד באורך של 8-הגדול מ
צבעים, מתרחשת שמונהיותר מ
קפיצה אקספוננציאלית בזמן הריצה
הממוצע, והערך גדל בצורה חדה
מאוד, ואפילו חדה יותר מאשר
מספר הניחושים הממוצע. כלומר,
5
7
9
11 13 15
-20
30
80
4 5 6 7 8 9 12
Ave
rage
Tim
e (
sec)
Genetic - Avg. Time Per Guess (sec)
80-10030-80
-20-30
5
7
9
11 13 15
-20
30
80
4 5 6 7 8 9 12
Ave
rage
Tim
e (
sec)
Random Restart - Avg. Time Per Guess (sec)
80-100
30-80
-20-30
2.4איור
2.5איור
15
גידול זמן הריצה הממוצע לניחוש רגיש יותר ל
מאשר מספר הניחושים P -ו Cבערכם של
הממוצע.
כאמור, הרצנו מספר משתנה של משחקים
. הסיבה לכך P-ו Cעבור גדלים שונים של
נעוצה בקפיצה החדה בה חזינו בזמני הריצה
של שני האלגוריתמים. לדוגמא, המשחק
( השיג תוצאה של זמן C=6,P=4הקלאסי )
שניות, עבור 0.09 -של כ לניחוש ממוצעריצה
שניות, עבור 0.03 -האלגוריתם הגנטי, ו
המשחק זאת, לעומת האלגוריתם הרנדומלי.
(C=10,P=10 ,) לניחוש ממוצעהשיג זמן ריצה
-שניות, עבור האלגוריתם הגנטי, ו 27 -של כ
הרצה של של משחק שלם כבר 'עולה' לנו בזמן ריצה גדול בהרבה. הרצהשניות, עבור האלגוריתם הרנדומלי. 99
משחקים רבים כאלו היתה משימה אפשרית אומנם, אך בלתי סבירה. ולכן הסתפקנו במקרים כגון אלו במספר
בין את המגמה הכללית של הנתונים.הרצות קטן יותר, כדי לה
איזה אלגוריתם השיג את )ממוצע( התוצאות הטובות ביותר עבור המשחקים השונים ניתן לראות 2.6 באיור
המכריע של המשחקים נצפה יתרון לאלגוריתם הרנדומלי, מבחינת זמן הריצה דקו. ניתן לראות כי ברובשנב
ית הממוצע לניחוש, והוא השיג ברוב המשחקים תוצאות מהירות יותר. כאשר במשחקים הקטנים הפערים היו יחס
זניחים, וככל שגודל המשחק, ובהתאם מרחב החיפוש, גדלו, הפערים הלכו והתעצמו, בד"כ לטובת האלגוריתם
נספח(.נתונים מדויקים בהרנדומלי )ראו
סיכום ומסקנות
תוצאות טובות יותר, הן מבחינת מספר הניחושים לנו היתה כי האלגוריתם הגנטי יציגש ההתחלתיתההשערה
מבצע את החיפוש בצורה יותר גנטי ה אלגוריתםהשהממוצע והן מבחינת זמן הריצה הממוצע. זאת משום
ובכל שלב מייצר את הניחושים "הטובים שבטובים". לעומת זאת, האלגוריתם הרנדומלי לא מבצע ,מתוחכמת
יותר שהוא יכול לייצר באותו הרגע, ולכן סברנו חיפוש מתוחכם, אלא מחפש באופן חמדני את הניחוש הטוב ב
שיציג תוצאות פחות טובות.
Best Algorithm – Avg. Time per Guess
Num. Positions
4 5 6 7 8 9 10
5 Genetic
Random Restart
- - - - -
Nu
m. C
olo
rs
6 Genetic Genetic Genetic - - - -
7 Genetic Random Restart
Random Restart
Random Restart
- - -
8 Genetic Random Restart
Random Restart
Random Restart
Genetic - -
9 Random Restart
Random Restart
Random Restart
Random Restart
Random Restart
- -
10 Random Restart
Genetic Random Restart
Random Restart
Random Restart
Random Restart
Genetic
11 Genetic Random Restart
Genetic Random Restart
Random Restart
Random Restart
-
12 Random Restart
Random Restart
Random Restart
Random Restart
Random Restart
Random Restart
Genetic
13 Random Restart
Random Restart
Random Restart
Random Restart
Random Restart
Genetic -
14 Random Restart
Random Restart
Random Restart
Random Restart
Random Restart
- -
15 Random Restart
Random Restart
Random Restart
Random Restart
Random Restart
- -
2.6איור
16
וחד ביחס לאלגוריתם הרנדומלי. נשים לב לא השיג תוצאות מרשימות במי להפתעתנו, האלגוריתם הגנטי
שבמשחקים הקטנים יותר )הקונבנציונאלים( יש לאלגוריתם הגנטי יתרון מול האלגוריתם הרנדומלי, אולם
במשחקים הגדולים יותר האלגוריתם הרנדומלי משיג תוצאות טובות יותר.
במשחקים הגדולים יותר, האלגוריתמים לא מצליחים למצוא ניחושים טובים לכך יכולה להיות מכיוון שסיבה
במסגרת הזמן או האיטרציות המקסימליות המוקצות להם, ולכן מחזירים ניחושים שאינם חוקיים )הכי טובים
זמן הריצהלהתארכות , כמו גם לגדולמספר הניחושים ל מצב זה גורם .שמצאו, אבל לאו דווקא מקסימום גלובלי(
הכולל של המשחק. ייתכן שהגדרה אחרת של הפרמטרים של המשחקים, כגון מספר האיתחולים מחדש
באלגוריתם הרנדומלי, או גודל האוכלוסייה, מספר הדורות, שיעור ביצוע המוטציה וכו' באלגוריתם הגנטי, היו
רמטרים השונים אותם משפרים את הביצועים של האלגוריתמים במשחקים מסדר גבוה יותר. אולם מכיוון שהפ
שזמן ריצתם ,במשחקים מסדר גבוה ניתן להגדיר רבים כל כך, היה קשה לבדוק את כל הווריאציות האפשריות
ואכן מציגים תוצאות יפות ים בעיקר למשחקים מסדר נמוך יותר,מתאימ שהגדרנו . לכן הפרמטריםגם כך גבוה
בהם.
The End.
17
נספחים
רשימת הקבצים - 1נספח
MasterMind.java – ה- GUI .של המשחק
Brain.java – מחלקה שתפקידה לספק את הניחוש הבא. הפונקציות העיקריות שלה הן פונקציית ה-
calcFitness שתפקידה להחזיר ערך ,fitness של ניחוש ופונקציית ה- calc שתפקידה לקרוא ,
ישנן שתי מחלקות פנימיות, שעושות שימוש Brainבתוך מחלקת ה לאלגוריתם החיפוש הרצוי.
:calcFitness -בפונקציית ה
o מחלקתHillClimbing – את אלגוריתם החיפוש ממשתמRandom Restart Hill-Climbing.
o מחלקתGenetic – את אלגוריתם החיפוש הגנטי. מממשת
Guess.java – צבעים, יש לו את מספר מחלקה שמייצגת אובייקט ניחוש. אובייקט ניחוש מכיל קוד של
המתאים לקוד. fitness -הבולים ומספר הפגיעות ביחס לקוד הצבעים הזה וערך ה
ColorComperator.java – תפקידה להשוות בין שני אובייקטים שלColor.
WeightedRandomGenerator.java – מחלקה המקבלת את האוכלוסייה עם דירוג הfitness של כל
המחזיר בכל פעם אינדקס של אחד הניחושים מהאוכלוסייה, Randomהניחושים שבה, ומייצרת אובייקט
השונים, כאשר ככל שהערך של ניחוש גבוה יותר, כך fitnessבהסתברות פרופורציונאלית לערכי ה
ההסתברות שהוא יבחר גבוהה יותר, ולהפך.
AutoPlayer.java – מריץ את שני האלגוריתמים קוד כלשהו )באופן רנדומלי( ושחקן אוטומטי שבוחר
של שני האלגוריתמים הוא זהה, על מנת )הרנדומלי( . הניחוש הראשוןכך שינסו לפצח את הקוד
השחקן האוטומטי משחק משחקים רבים באופן אוטומטי ובכך מייעל את . ההשוואה תהיה אובייקטיביתש
תהליך איסוף וניתוח הנתונים.
htmlapplet. – דףHTML .המריץ את המשחק בדפדפן
Makefile
18
תוצאות סטטיסטיות - 2נספח
מספר הניחושים הממוצע
Genetic - Average Num. Of Guesses
Num Positions
4 5 6 7 8 9 10
5 4.242 4.628
Nu
m C
olo
rs
6 4.718 5.084 5.632
7 5.12 5.5 6.056 6.994
8 5.49 5.868 6.426 7.332 8.208
9 5.922 6.238 6.948 8.034 9.25 12.95
10 6.204 6.648 7.196 8.156 9.5 12.2 14.6
11 6.694 7.058 7.592 8.475409836 9.84 13.8
12 7.066132265 7.376 7.798 9.6 10.2 14 18
13 7.392 7.644 8.152 9.18 11 26
14 7.176 7.564 8.098 9.7 9.7
15 7.65 7.934 8.362 8.7 11.4
Random Restart - Average Num. Of Guesses
Num Positions
4 5 6 7 8 9 10
5 4.482 4.702
Nu
m C
olo
rs
6 4.872 5.276 5.812
7 5.374 5.638 6.134 6.706
8 5.99 6.09 6.558 7.124 7.956
9 6.254 6.508 6.968 7.506 8.2 10.9
10 6.768 7.122 7.406 7.932 8.7 10.6 15.4
11 7.424 7.476 7.794 8.549180328 8.96 11
12 7.863727455 7.904 8.2 8.6 9.4 12 12
13 8.248 8.424 8.602 8.94 9.7 16
14 8.482 8.488 8.664 9.5 9.6
15 9.092 9.036 9.078 9.4 9.9
19
הזמן הממוצע לניחוש
Genetic - Average Time per Guess (sec)
Num Positions
4 5 6 7 8 9 10
5 0.0174 0.0260
Nu
m C
olo
rs
6 0.0273 0.0468 0.1112
7 0.0345 0.0669 0.1935 0.7742
8 0.0451 0.0925 0.2770 1.1487 2.4422
9 0.0626 0.1303 0.3955 2.0356 4.9613 8.1872
10 0.0794 0.1654 0.5186 2.3868 6.7007 15.5871 27.0177
11 0.1015 0.2205 0.7061 3.0169 6.0744 20.5213
12 0.1216 0.2680 0.9051 6.4728 9.5295 36.5323 60.2381
13 0.1499 0.3113 1.1181 5.3813 11.6532 70.0612
14 0.1517 0.3369 1.3319 5.4149 7.2399
15 0.1853 0.4193 1.2770 2.4541 20.6315
Random Restart - Average Time per Guess (sec)
Num Positions
4 5 6 7 8 9 10
5 0.1342 0.0051
Nu
m C
olo
rs
6 0.0943 0.1452 0.2572
7 0.1172 0.0169 0.0985 0.3798
8 0.1398 0.0261 0.1338 0.7214 3.8163
9 0.0062 0.0362 0.2011 0.9587 3.0509 10.5556
10 0.0081 0.4821 0.2086 1.1354 5.8988 15.5834 98.7717
11 0.5485 0.0713 0.9740 2.0422 5.1587 19.8178
12 0.0139 0.0791 0.2967 0.8310 3.0553 34.5320 82.4588
13 0.0175 0.1037 0.4888 1.6784 4.7230 88.0700
14 0.0067 0.0256 0.1259 0.4109 4.6090
15 0.0076 0.0251 0.1342 0.3633 2.9425
20
הקוד של האלגוריתמים -3נספח
Random Restart Hill-Climbing
/**
* Random Restart Hill Climbing Algorithm
* @return the best next guess
*/
private static Guess getBestGuess() {
setRestartTimes();
Guess lastGuess = new Guess();
lastGuess.setAllColors(_guesses.elementAt(_guesses.size()-1)._colors);
Guess currentBestGuess = new Guess();
Guess currentBestGuessNotInList = new Guess();
currentBestGuess.setAllColors(lastGuess._colors);
double fit;
double currentBestFitness = MIN_NUM;
double bestFitness = MIN_NUM;
Guess bestGuess= new Guess(); // the best guess of all of the iterations
double currentBestFitnessNotInList = MIN_NUM;
double bestFitnessNotInList = MIN_NUM;
Guess bestGuessNotInList = new Guess();
boolean betterBeighbor= true;
colorComperator comp= new colorComperator();
Guess newGuess=new Guess();
Guess temp= new Guess();
// building a vector of random starting states (guesses) for the algorithm.
the first element in the vector is //the given guess
Vector <Guess> randomGuesses= new Vector<Guess>();
randomGuesses.add(lastGuess);
int index;
Random generator = new Random();
// adding guesses to the vector starting from the second place
for (int i=1; i<RESTART_TIMES; i++){
randomGuesses.add(new Guess());
// choosing the colors for the guess
for (int j= 0; j < _combinationSize; j++) {
index=generator.nextInt(_colors.size());
Color color= _colors.get(index);
randomGuesses.elementAt(i).insertColor(color);
}
}
// running the local search algorithm RESTART_TIMES times
int k;
for (k=0; k<RESTART_TIMES; k++) {
newGuess.setAllColors(randomGuesses.elementAt(k)._colors);
21
currentBestFitness = MIN_NUM;
currentBestFitnessNotInList = MIN_NUM;
while (betterBeighbor) {
temp.setAllColors(newGuess._colors);
betterBeighbor = false;
// going over all the neighbors
for (int i=0; i<_combinationSize; i++){
// going over all the possible colors
for (int j=0; j<_colors.size(); j++){
if(comp.compare(newGuess._colors.elementAt(i),
_colors.elementAt(j))!=0){
newGuess.setColor(i, _colors.elementAt(j));
fit = calcFitness(newGuess);
if (fit > currentBestFitness) {
betterBeighbor = true;
currentBestFitness = fit;
currentBestGuess.setAllColors(
newGuess._colors);
}
if (fit > currentBestFitnessNotInList &&
!checkGuessInList(newGuess)) {
currentBestFitnessNotInList = fit;
currentBestGuessNotInList.setAllColors(new
Guess._colors);
}
}
}
newGuess.setAllColors(temp._colors);
}
newGuess.setAllColors(currentBestGuess._colors);
} // end while
betterBeighbor= true;
//checking if the current round result is better from the best one found
if (currentBestFitness > bestFitness) {
bestFitness= currentBestFitness;
bestGuess.setAllColors(currentBestGuess._colors);
}
if (currentBestFitnessNotInList > bestFitnessNotInList) {
bestFitnessNotInList = currentBestFitnessNotInList;
bestGuessNotInList.setAllColors(currentBestGuessNotInList._colors);
}
if (bestFitnessNotInList==0.0) break;
} // end for
// setting the fitness of the returned guess
bestGuessNotInList.setFitness(bestFitnessNotInList);
return bestGuessNotInList;
}
22
Genetic
/**
* The genetic algorithm.
* @return the best next guess
*/
public static Guess getBestGuess() {
NUM_GENERATION = Math.max(30, _numColors*_combinationSize(;
POPULATION_SIZE = NUM_GENERATION*RATIO;
boolean foundLegalSol = false;
int iteration = 1;
int counter=0;
while (!foundLegalSol && iteration<=3) {
iteration++;
setInitialPopulation();
for (int i=0; i<NUM_GENERATION; i++){
createNextGeneration)(;
if (_population[0]._fitness==0.0 && i>=30) break;
{
counter=0;
if (_population[counter]._fitness==0.0) {
foundLegalSol = true;
while(counter<_population.length &&
_population[counter]._fitness==0.0){
counter++;
{
counter = _generator.nextInt(counter);
}
NUM_GENERATION += Math.max(30, _numColors*_combinationSize(;
POPULATION_SIZE = NUM_GENERATION*RATIO;
}
return _population[counter];
}
/**
* Create the next generation
*/
private static void createNextGeneration() {
Guess[] nextGeneration = new Guess[POPULATION_SIZE];
Guess[] newPopulation = new Guess[POPULATION_SIZE];
_weightedGenerator = new
WeightedRandomGenerator(_population,_combinationSize*_guesses.size()+2);
for (int i=0; i<POPULATION_SIZE; i++) {
Guess husband = _population[_weightedGenerator.getRandomIndex()];
Guess wife = _population[_weightedGenerator.getRandomIndex()];
Guess child = createChild(husband,wife);
mutate(child);
child.setFitness(calcFitness(child));
23
nextGeneration[i] = child;
}
Arrays.sort(nextGeneration,Collections.reverseOrder());
int prevIndex=0, newIndex=0, index=0;
for (index=0; index<POPULATION_SIZE; index++) {
if (prevIndex<POPULATION_SIZE && (newIndex>=POPULATION_SIZE ||
_population[prevIndex]._fitness > nextGeneration[newIndex]._fitness)) {
newPopulation[index] = _population[prevIndex];
prevIndex++;
}
else {
newPopulation[index] = nextGeneration[newIndex];
newIndex++;
}
}
for (int i=0; i<POPULATION_SIZE; i++) {
_population[i] = newPopulation[i];
}
Arrays.sort(_population,Collections.reverseOrder());
}
/**
* Create a child
* @param husband The father of the child
* @param wife The mother of the child
* @return Guess that is the child
*/
private static Guess createChild(Guess husband, Guess wife) {
int crossover = _combinationSize/2;
if (husband._fitness>wife._fitness) {
crossover = (3*_combinationSize)/4;
}
else if (wife._fitness>husband._fitness){
crossover = (_combinationSize)/4;
}
Guess child = new Guess();
for (int i=0; i<crossover; i++) {
child.insertColor(husband._colors.get(i));
}
for (int i=crossover; i<_combinationSize; i++) {
child.insertColor(wife._colors.get(i));
}
return child;
}
/**
* Set the initial population
*/
private static void setInitialPopulation() {
24
_population = new Guess[POPULATION_SIZE];
for (int i=0; i<POPULATION_SIZE; i++) {
Guess g = new Guess();
for (int j=0; j<_combinationSize; j++) {
g.insertColor(_colors.get(_generator.nextInt(_numColors)));
}
g.setFitness(calcFitness(g));
_population[i]=g;
}
Arrays.sort(_population,Collections.reverseOrder());
}
/**
* Mutate a guess
* @param guess the guess to mutate
*/
public static void mutate(Guess guess) {
if (_generator.nextInt(100)<MUTATE_PROBABILITY) {
int index = _generator.nextInt(_combinationSize);
int color = _generator.nextInt(_numColors);
guess.setColor(index, _colors.get(color));
}
}
