בסרטון הזה נסתכל לתוך המודלים שסוכני קוד משתמשים בהם. נבחן איך רשת נוירונים בנויה מנוירונים בודדים, ונראה איך האימון משנה את המשקולות שלה. הבנת המנגנונים האלה עוזרת להסביר מאיפה מגיעות היכולות של מודל. כאן נעבור על רשתות נוירונים מהר מאוד. זה בסדר אם לא תבינו כל פרט. הנושא נלמד לעומק בקורסים מתקדמים יותר בלמידת מכונה.
רשתות נוירונים שאבו השראה כללית מהמוח. הנה איור של נוירון אמיתי. הוא אוסף אותות דרך הדנדריטים שלו, משמאל.
כשהאות המשולב חוצה סף, הנוירון יורה, ושולח פעימה לאורך האקסון שלו לימין.
נוירון מלאכותי משתמש בגרסה מפושטת של הרעיון הזה: לשלב כמה קלטים, ואז לחשב פלט.
בואו נבנה נוירון מלאכותי אחד. הקלטים שלו הם מספרים ממשיים, שמסומנים x1, x2, ו-x3.
אנחנו מכפילים כל קלט במשקולת, שמייצגת את חוזק הקשר שלו לנוירון. אנחנו מחברים את הקלטים המשוקללים האלה, ואז מוסיפים איבר bias, b. התוצאה היא מספר בודד, z. משקולת יכולה להיות אפס כשקלט לא תורם כלום. משקולת שלילית אומרת שהגדלת הקלט הזה מקטינה את z.
אז אנחנו מעבירים את z דרך פונקציית אקטיבציה לא לינארית. בחירה נפוצה אחת היא ReLU, שמחזירה את הגדול מבין z לבין אפס. ערכים שליליים הופכים לאפס, וערכים חיוביים עוברים ללא שינוי. השינוי הזה בשיפוע הופך את הפונקציה ללא לינארית. בלי אקטיבציות לא לינאריות, הרכבה של הסכומים המשוקללים האלה עדיין הייתה נותנת לנו רק טרנספורמציה לינארית ועוד bias.
התוצאה היא הפלט של הנוירון, y.
הנוירון משלב סכום משוקלל, כולל ה-bias, עם פונקציית אקטיבציה. אנחנו יכולים לחבר הרבה חישובים פשוטים כאלה כדי ליצור רשת נוירונים. החישוב המשולב שלהם יכול לייצג קשרים הרבה יותר מורכבים.
כדי לבנות את הרשת, אנחנו מתחילים מווקטור של מספרי קלט.
נוירון נסתר אחד מחשב סכום משוקלל של כל קלט, ואז מפעיל ReLU, בדיוק כמו קודם.
כמה נוירונים זה לצד זה נותנים לנו שכבה. הנוירונים מקבלים את אותם קלטים, אבל לכל אחד יש משקולות ו-bias משלו, אז כל אחד מחשב פונקציה אחרת של הקלטים האלה.
הפלטים של השכבה הראשונה הופכים לקלטים לשכבה נוספת. הרכבת שכבות מאפשרת לרשת לבנות חישובים מורכבים יותר על התוצאות של הקודמות.
השכבה האחרונה מייצרת את הפלטים של הרשת. אנחנו מסמנים את הניבוי הזה y hat.
מכיוון שמידע זורם בכיוון אחד, משמאל לימין, רשתות כאלה נקראות רשתות feed-forward.
בואו נשתמש ברשת למשימה מוחשית: זיהוי ספרה בכתב יד. תמונה סרוקה היא מטריצת פיקסלים. הדוגמה שלנו מציגה את הספרה 3 על מטריצה קטנה, ברוחב 5 פיקסלים ובגובה 7 פיקסלים.
אנחנו מקודדים כל פיקסל כמספר, מאפס בשחור עד אחד בלבן. מטריצת ה-5 על 7 נותנת לנו 35 מספרים, שמרכיבים את וקטור הקלט. המספרים האלה מתארים בהירות של פיקסלים, אבל הם לא אומרים לנו ישירות איזו ספרה נמצאת שם. נאמן רשת נוירונים לזהות את הספרה מתוך דוגמאות, במקום לכתוב את כללי הזיהוי בעצמנו.
אנחנו מעבירים את הווקטור דרך רשת feed-forward, בדיוק כמו זו שדיברנו עליה הרגע.
הרשת מייצרת 10 מספרים, ציון אחד לכל ספרה מ-0 עד 9. ציון גבוה יותר אומר שהרשת מעדיפה את הספרה הזו. הציונים האלה לא חייבים להיות הסתברויות.
אנחנו משתמשים בספרה עם הציון הגבוה ביותר כניבוי של הרשת. כאן הציון של 3 הוא הגבוה ביותר, אז הספרה המנובאת היא 3.
לא כתבנו כלל שמתאר את הצורה של 3. הרשת המאומנת יכולה לזהות אותה כי המשקולות שלה כוונו בעזרת דוגמאות. כלל הזיהוי מיוצג בתוך המשקולות האלה, ולא כתוב כרצף הוראות שאפשר לקרוא. כדי להבין איך המשקולות קיבלו את הערכים האלה, אנחנו צריכים להסתכל על האימון.
במקום לכתוב כללים, אנחנו אוספים דוגמאות. אנחנו צריכים הרבה ספרות סרוקות.
לכל תמונה מצורפת התווית הנכונה שלה, התשובה הידועה. אנחנו מסמנים את התשובה הזו y.
אוסף של זוגות תמונה ותווית כאלה נקרא סט אימון. דוגמאות מגוונות יותר ומתויגות נכון נותנות לרשת יותר הזדמנויות ללמוד את התבניות שהיא צריכה.
אימון צריך מספר שמודד את שגיאת הניבוי. עבור תמונה אחת, הרשת מייצרת 10 ציונים, שמוצגים כאן כעמודות סגולות. יחד הציונים האלה מרכיבים את הניבוי, y hat.
אנחנו גם כותבים את התשובה הנכונה כ-10 מספרים: אחד בספרה האמיתית ואפס בכל ספרה אחרת. זה היעד, y, שמוצג בנקודות הכתומות.
אנחנו משווים כל ציון מנובא ליעד שלו. עבור הספרה האמיתית, 3, הניבוי נמוך מאחד. הציונים האחרים גבוהים מהיעדים שלהם, שהם אפס. אנחנו מעלים כל הפרש בריבוע ומחברים את 10 התוצאות. ההעלאה בריבוע גורמת לכך שגם הפרשים חיוביים וגם שליליים תורמים בחיוב, ונותנת לשגיאות גדולות יותר משקל רב יותר. התוצאה היא ה-loss עבור התמונה הזו. loss של אפס אומר שכל פלט תואם בדיוק ליעד שלו.
עבור כל סט האימון, אנחנו מחברים את ערכי ה-loss של כל התמונות ומחלקים במספר הדוגמאות, N. זה נותן את ה-loss הממוצע. האימון מכוונן את המשקולות כדי להקטין את ה-loss הממוצע הזה ולשפר את ניבויי הספרות.
איך אנחנו מקטינים את ה-loss? כשסט האימון קבוע, שינוי המשקולות משנה את הניבויים ולכן גם את ה-loss. אנחנו יכולים להתייחס ל-loss כפונקציה של המשקולות. כדי להמחיש את זה, הגרף מציג את ה-loss כפונקציה של משקולת אחת. אנחנו מאתחלים את המשקולות באקראי ומתחילים בנקודה על העקומה הזו. הקערה היא דוגמה פשוטה לעקומת loss, ולא הצורה המלאה של בעיית האימון של רשת.
שאלו שאלה פשוטה על המשקולת הזו. אם אזיז אותה קצת למעלה או למטה, ה-loss גדל או קטן? במילים אחרות, האם הרשת מנבאת טוב יותר כשמזיזים את המשקולת למעלה, או שהיא טובה יותר כשמזיזים את המשקולת הזו למטה?
השיפוע של העקומה הוא הנגזרת של ה-loss ביחס למשקולת הזו. הסימן שלה אומר לנו איזה כיוון מגדיל את ה-loss, והגודל שלה אומר לנו כמה תלול השינוי.
כשיש לנו את השיפוע, אנחנו מחסרים אותו מהמשקולת הנוכחית (אחרי שמכפילים אותו בגורם קבוע כלשהו). זה מזיז את המשקולת לכיוון loss נמוך יותר, כל עוד הצעד קטן מספיק. התהליך הזה נקרא gradient descent. המספר הקטן, אטא, הוא קצב הלמידה. הוא קובע כמה גדול יהיה העדכון בכל צעד. אתם יכולים לעבוד עם סוכני קוד בלי לממש את האלגוריתם הזה. זו שיטה בסיסית לאימון רשתות נוירונים, וקורס בלמידת מכונה יפתח את השלבים האלה בפירוט רב יותר.
אנחנו חוזרים על העדכונים הקטנים האלה על הרבה דוגמאות. עבור רשת הספרות הזו, אנחנו יכולים לעבור על סט האימון הרבה פעמים.
כדי לעדכן את כל המשקולות, אנחנו צריכים את הנגזרת של ה-loss ביחס לכל אחת מהן. אלגוריתם שנקרא backpropagation מחשב את הנגזרות האלה ביעילות. הוא מבצע forward pass דרך הרשת, ואחריו backward pass.
נשאיר את הגזירה של backpropagation לקורס בלמידת מכונה. לצרכינו, הרצף החשוב הוא לעשות ניבוי, למדוד את ה-loss שלו, לחשב את הנגזרות, ולהשתמש בהן כדי לעדכן את המשקולות.
כשאנחנו מסיימים את האימון, אנחנו משאירים את המשקולות שנלמדו קבועות בזמן השימוש ברשת. ניבוי לא מעדכן אותן.
כדי להשתמש ברשת, אנחנו מריצים forward pass על קלט חדש, כמו תמונת ספרה שלא הייתה בסט האימון. הרשת מייצרת ניבוי. לזה קוראים היסק.
עם משקולות קבועות, הרשת הזו היא פונקציה קבועה מקלט לפלט. אנחנו יכולים לחשב את הפונקציה הזו שוב ושוב, ולהשתמש באותן משקולות לכל תמונה חדשה. אותה הבחנה חלה על מודל שפה: היסק רגיל משתמש במשקולות קבועות ולא מאמן אותן על השיחה שלכם. המודל עדיין יכול להשתמש במידע חדש שנמצא בהקשר שלו. ספק יכול גם לאמן ולהשיק גרסה חדשה יותר, אבל זה נפרד מההיסק שמתרחש כשאתם מבקשים תשובה.
בואו נסכם. בנינו נוירון מסכום משוקלל, איבר bias, ופונקציית אקטיבציה לא לינארית. חיבור נוירונים לשכבות נתן לנו רשת feed-forward. אז אימנו את הרשת הזו על דוגמאות מתויגות. ה-loss מודד שגיאת ניבוי, backpropagation מחשב את הנגזרות שלו, ו-gradient descent משתמש בהן כדי לעדכן את המשקולות. בזמן היסק, אנחנו משתמשים במשקולות שנלמדו בלי לשנות אותן. מודלי שפה משתמשים באותם רעיונות אימון בסיסיים ברשתות גדולות ומורכבות יותר. הסרטון הבא מסתכל על הנתונים והחישוב שנדרשים כדי לאמן אותם בקנה מידה כזה.