ירידת שיפוע בג'אווה
1. הקדמה
במדריך זה נלמד על אלגוריתם הירידה בהדרגה. אנו מיישמים את האלגוריתם ב- Java וממחישים אותו שלב אחר שלב.
2. מהי ירידת שיפוע?
ירידת שיפוע היא אלגוריתם אופטימיזציה המשמש למציאת מינימום מקומי של פונקציה נתונה. זה נעשה שימוש נרחב באלגוריתמים של למידת מכונה ברמה גבוהה כדי למזער פונקציות אובדן.
שיפוע היא מילה נוספת לשיפוע, וירידה פירושה לרדת. כפי שהשם מרמז, ירידת שיפוע יורדת במורד הפונקציה עד שהיא מגיעה לסופה.
3. מאפיינים של ירידת שיפוע
ירידה בהדרגה מוצאת מינימום מקומי, שיכול להיות שונה מהמינימום העולמי. נקודת ההתחלה המקומית ניתנת כפרמטר לאלגוריתם.
זה אלגוריתם איטרטיביובכל שלב הוא מנסה לנוע במורד המדרון ולהתקרב למינימום המקומי.
בפועל, האלגוריתם חוזר על עקבותיו. אנו נמחיש וניישם ירידה במסלול אחורה במסלול הדרכה במדריך זה.
4. איור שלב אחר שלב
ירידת שיפוע זקוקה לפונקציה ונקודת התחלה כקלט. בואו נגדיר ולשרטט פונקציה:
אנחנו יכולים להתחיל בכל נקודה רצויה. נתחיל בשעה איקס=1:
בשלב הראשון, ירידת שיפוע יורדת במדרון עם גודל צעד מוגדר מראש:
לאחר מכן, זה הולך רחוק יותר עם אותו גודל צעד. עם זאת, הפעם זה בסופו של דבר גדול יותר y מהשלב האחרון:
זה מצביע על כך שהאלגוריתם עבר את המינימום המקומי, ולכן הוא הולך אחורה עם גודל צעד נמוך יותר:
לאחר מכן, בכל פעם שהזרם y גדול מהקודם y, גודל המדרגה יורד ונשלל. האיטרציה נמשכת עד להשגת הדיוק הרצוי.
כפי שאנו רואים, Gradient Descent מצא כאן מינימום מקומי, אך הוא אינו המינימום הגלובלי. אם נתחיל בשעה איקס= -1 במקום איקס= 1, המינימום הגלובלי יימצא.
5. יישום בג'אווה
ישנן מספר דרכים ליישם ירידה בהדרגה. כאן איננו מחשבים את הנגזרת של הפונקציה כדי למצוא את כיוון השיפוע, ולכן היישום שלנו פועל גם לפונקציות שאינן מובחנות.
בואו נגדיר דיוק ו stepCoefficient ותן להם ערכים ראשוניים:
דיוק כפול = 0.000001; צעד כפול מקדם = 0.1;בשלב הראשון אין לנו קודמת y לשם השוואה. אנו יכולים להגדיל או להקטין את הערך של איקס לראות אם y מוריד או מעלה. חיובי stepCoefficient פירושו שאנחנו מגדילים את הערך של איקס.
עכשיו בואו נבצע את הצעד הראשון:
כפול הקודם X = initialX; הקודם כפול Y = f.apply (הקודם X); currentX + = stepCoefficient * previousY;בקוד לעיל, f הוא פוּנקצִיָה, ו initialX הוא לְהַכפִּיל, שניהם מסופקים כקלט.
נקודת מפתח נוספת שיש לקחת בחשבון היא שלא ניתן להבטיח כי ירידת שיפוע תתכנס. כדי להימנע מלהיתקע בלולאה, בואו נקבל מגבלה על מספר האיטרציות:
int iter = 100;מאוחר יותר, נפחית איטר על ידי אחד בכל איטרציה. כתוצאה מכך, נצא מהלולאה לכל היותר 100 איטרציות.
עכשיו שיש לנו הקודם X, אנו יכולים להגדיר את הלולאה שלנו:
בעוד (שלב קודם> דיוק && iter> 0) {iter--; זרם כפול Y = f.apply (currentX); אם (currentY> previousY) {stepCoefficient = -stepCoefficient / 2; } הקודם X = הנוכחי X; currentX + = stepCoefficient * previousY; הקודם = הנוכחי; previousStep = StrictMath.abs (currentX - previousX); }בכל איטרציה אנו מחשבים את החדש y והשווה את זה לקודם y. אם הנוכחי גדול מ הקודם, אנו משנים את הכיוון שלנו ומקטינים את גודל הצעד.
הלולאה נמשכת עד שגודל המדרגות שלנו קטן מהרצוי דיוק. לבסוף נוכל לחזור currentX כמינימום המקומי:
החזר currentX;6. מסקנה
במאמר זה עברנו באלגוריתם הירידה בהדרגה עם איור שלב אחר שלב.
יישמנו גם את Gradient Descent ב- Java. הקוד זמין ב- GitHub.
