משתמש:האדם-החושב/רשת עצבית מתפתחת

רשת עצבית מתפתחת (CNN – Convolutional Neural Network), הינה סוג של רשת עצבית מלאכותית המשמשת בעיקר לניתוח תמונה.

שם נוסף המתאים לה הינו רשת עצבית מלאכותית בחלל (SIANN – Space Invariant Artificial Neural Network).

היא המבוססת על שכבות כינוס (באנגלית: convolution layers) הממומשות על ידיי העברת מסננת (filter) או ליבה (karnel) על גביי הקלט וביצוע כפל מטריצות, הפלט נקרא feature map.

לרשתות עצביות מתפתחות יש שימושים רבים בתחום הראייה ממוחשבת, מערכות המלצה, עיבוד שפה טבעית, ממשק מוח-מחשב ועוד תחומים רבים.

ארכיטקטורה

השוואה בין ארכיטקטורת LeNet ו AlexNet

רשת עצבית מתפתחת עושה שימוש בדרך כלל בשכבות fully connected, כינוס ( convolution ) ו pooling ( אגרגציה ) ובפונקציית הפעלה מסוג ReLU כאשר בדרך כלל (לא מחייב) שכבת הכניסה תהיה שכבת כינוס עם מספר שכבות כינוס, pooling ( אגרגציה ) וReLU נוספות אחריה, ולאחר מכן מספר שכבות fully connected.

שכבת כינוס

קלט לשכבה זאת הינו טנזור בגודל ( מספר קלטים ) x ( מספר ערוצי קלט ) x ( גובה הקלט ) x ( רוחב הקלט ). לאחר שהקלט מסיים לעבור בשכבה מתקבל טנזור המייצג תמונה מופשטת יותר הנקרא feature map בגודל (מספר קלטים) x ( מספר ערוצי ה-feature map ) x ( גובה ה-feature map ) x ( רוחב ה-feature map ).

שכבת כינוס מקבלת טנזור ומוציאה טנזור חדש שישמש כקלט עבור השכבת כינוס הבאה ממש כמו שכבות fully connected ברשת עצבית מלאכותית אחד מיתרונות שכבות הכינוס הינו הוזלת עלות החישוב של תמונות וכתוצאה מכך אפשור העמקת הרשת.

לדוגמה שכבה fully connected לתמונה בגודל 100x100 תיצור לנו כ 10,000 משקולות חדשות עבור כל נוירון בשכבה הבאה דבר שיכול מהר מאוד להפוך ל"יקר" מאוד לעומת זאת שכבת כינוס עם ליבה בגודל 5x5 תיצור לנו רק כ 25 משתנים למידים חדשים. שימוש במשקולות שעברו נרמול על פחות משתנים עוזר להימנע מבעיית הגרדיאנט הנעלם.

שכבת אגרגציה

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

שכבת fully connected

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

היסטוריה

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

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

אבניי בניין

רשת עצבית מתפתחת מורכבת ממספר שכבות כגוון שכבת כינוס, שכבת אגרגציה ושכבה fully connected.

כמובן שיכול להיות שימוש בעוד הרבה סוגי שכבות אבל אלה הנפוצות והבסיסיות ביותר.

קונבולוציה על תמונה בגודל 4x4 (כחול) עם ליבה בגודל 3x3 (צל כחול כהה) וקפיצות בגודל 1 היוצרת תמונה חדשה בגודל 2x2 (טורקיז)

שכבת כינוס

עוברים על הטנזור ומכפילים עם הליבה (באנגלית: kernel) שהיא טנזור בגודל $\ k_{1}\times k_{2}$עם קפיצות בגודל $(s_{1},s_{2})$ כאשר $\ s_{1}$ מייצג את גודל הקפיצה בציר ה-$\ x$ ו $\ s_{2}$ מייצג את גודל הקפיצה בציר ה-$\ y$ (בדרך כלל $\ k_{1}$ ו $\ k_{2}$יהיו באותו גודל ולכן פשוט יקראו $\ k$כנ"ל לגביי $\ s$), כאשר כל ליבה יכולה לשמש לצורך מטרה שונה.

או פשוט $g(x,y)=\omega *f(x,y)=\sum _{dx=-a}^{a}{\sum _{dy=-b}^{b}{\omega (dx,dy)f(x+dx,y+dy)}}$.

כאשר $g(x,y)$ מייצג את התמונה החדשה, $f(x,y)$ מייצג את התמונה המקורית ו $\omega$ מייצג את הליבה.

גודל הפלט של שכבת כינוס עם חלון בגודל $\ k_{w}\times k_{h}$ וקפיצות (strides) בגודל $\ s_{w}\times s_{h}$ טנזור קלט בגודל $\ t_{w}\times t_{h}$

$\ o_{w}=\lfloor {\frac {t_{w}-k_{w}}{s_{w}}}\rfloor +1$ $\ o_{h}=\lfloor {\frac {t_{h}-k_{h}}{s_{h}}}\rfloor +1$ כאשר $\ o_{w}\times o_{h}$הם ממדיי הפלט.

שכבת אגרגציה (pooling)

max pooling עם ליבה בגודל 2x2 וקפיצות בגודל של 2

עוברים עם חלון בגודל $\ p_{w}\times p_{h}$ ועושים פעולה מתמטית המוציאה מספר אחד למשל במקרה של max pooling ניקח את המספר הגדול ביותר שיצא בגבולות החלון שלנו בכל החלקה במקרה של average pooling ניקח את כל המספרים שיצאו בגבולות החלון שלנו ונעשה להם ממוצע.

ביצוע max pooling עם חלון בגודל $\ p_{w}\times p_{h}$ וקפיצות (strides) בגודל $\ s_{w}\times s_{h}$ טנזור קלט בגודל $\ t_{w}\times t_{h}$

כאשר $\ o_{w}\times o_{h}$הם ממדיי הפלט ו $\ 0\leq x<t_{w}$ $\ 0\leq y<t_{h}$.

$o_{x,y}=max(\sum _{i=(x-1)*p_{w}}^{x*p_{w}}\sum _{j=(y-1)*p_{h}}^{y*p_{h}}t_{i,j})$

גודל הפלט של שכבת אגרגציה עם חלון בגודל $\ p_{w}\times p_{h}$ וקפיצות (strides) בגודל $\ s_{w}\times s_{h}$ טנזור קלט בגודל $\ t_{w}\times t_{h}$

$\ o_{w}=\lfloor {\frac {t_{w}-p_{w}}{s_{w}}}\rfloor +1$ $\ o_{h}=\lfloor {\frac {t_{h}-p_{h}}{s_{h}}}\rfloor +1$ כאשר $\ o_{w}\times o_{h}$הם ממדיי הפלט.

שכבת ReLU

Rectified linear unit ‏(ReLU) פונקציית אקטיבציה מאוד פופולרית בקרב רשתות עצביות מתפתחות עוברת על כל נוירון ומבצעת בו פונקציית יחידה לינארית מתוקנת

הפונקציה עבור כל נוירון $f(x)={\begin{cases}0&{\text{for }}x<0\\x&{\text{for }}x\geq 0\end{cases}}$ הטווח של פונקציה זאת הינו $[0,\infty )$.

שכבת dropout

נועדה למנוע התאמת יתר (overfitting) תופעה שבה המודל מתאים את עצמו לדאטה הספציפית שאימנו אותו עליה ולא יודע להכליל למשל מודל שניסנו ללמד אותו להבדיל בין תמונות של חתולים לתמונות של לא חתולים אם יתרחש overfitting המודל יוכל לסווג את כל תמונות החתולים שאימנו אתו עליהם בצורה טובה אך ברגע שניתן לו תמונות של חתולים שהוא לא מכיר הוא יתחיל לסווג ממש גרוע. דוגמה נוספת: זה כמו ילד בכיתה א שמשנן ש 1+2=3 אבל בגלל שהוא לא מבין לעומק ברגע שניתן לו את השאלה כמה זה 1+4 הוא לא ידע את התשובה.

השכבה פועלת בצורה כזאת היא מקבלת את $\ 0<p\leq 1$ וקלט של שכבת נוירונים והיא תתעלם מנוירונים אקראיים כלומר לכל נוירון יש $\ p$סיכוי להישמר או $\ 1-p$סיכויים להישמט.

משתנים כלליים

גודל הליבה (kernel)

הליבה היא הריי טנזור וצריך לבחור את ממדיי הטנזור בדרך כלל הגדלים יהיו $\ 3\times 3$ או $\ 5\times 5$ או $\ 7\times 7$אבל כמובן אפשרי לבחור כל גודל רצוי כל עוד הוא גדול מאפס כמובן.

ריפוד

ריפוד (באנגלית: padding) נועד על מנת לפתור שתי בעיות:

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

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

למשל לתמונה בגודל של $5\times 5$ עם ליבה בגודל $3\times 3$ וקפיצות בגודל של אחד אם נוסיף שכבת ריפוד אחת מכל כיוון לאחר כינוס נשאר עם תמונה בגודל $5\times 5$ כלומר לא הקטנו אותה.

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

גודל פסיעה Stride

משתנה זה מייצג את גודל הפסיעה/קפיצה שנעשה כל פעם עם הליבה בדרך כלל יהיה בגודל $\ 2\times 2$ או $\ 1\times 1$ אבל יכול להיות בכל גודל רצוי כל עוד הוא גדול מאפס כמובן.

מספר הליבות

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

גודל אגרגציה

אגרגציה היא הריי טנזור העובר על תמונת הקלט וצריך לבחור את ממדיי הטנזור בדרך כלל הגדלים יהיו $\ 2\times 2$ או $\ 4\times 4$ אבל כמובן אפשרי לבחור כל גודל רצוי כל עוד הוא גדול מאפס כמובן.

סוג אגרגציה

יש כמה סוגיי אגרגציה יש אגרגציה מקסימאלית (max pooling), אגרגציה מינימאלית (min pooling) ו אגרגציה ממוצעת (average pooling).

קוד

מודל רשת עצבית מתפתחת בTensorFlow:

def build_classifier():
    model = Sequential(name="classifier")

    model.add(Conv2D(64, kernel_size=5, strides=2, input_shape=img_shape, padding='same'))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.3))

    model.add(Conv2D(128, kernel_size=5, strides=2, padding='same'))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.3))

    model.add(Conv2D(256, kernel_size=5, strides=2, padding='same'))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.3))

    model.add(Conv2D(512, kernel_size=5, strides=2, padding='same'))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.3))

    model.add(Flatten())
    model.add(Dense(1, activation='sigmoid'))

    model.summary()
    image = Input(shape=img_shape)
    validity = model(image)
    return Model(image, validity)

הערות שוליים

קטגוריה:בינה מלאכותית קטגוריה:אלגוריתמים קטגוריה:למידה חישובית