קונבולוציה (עיבוד תמונה)[עריכת קוד מקור | עריכה]

קונבולוציה (באנגלית: convolution, בעברית: כינוס) הינה דרך לזיקוק תמונות לצורך חידודן, זיהוי קצוות או צורות פרימיטיביות כלשהן בתוכן ועוד בתחום הבינה המלאכותית והראיה הממוחשבת. שמות נוספים המתאימים לשיטה זאת הינם Convolutional neural networks (בעברית: רשתות עצביות מתפתחות) או ConvNet או פשוט CNN.

היסטוריה[עריכת קוד מקור | עריכה]

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

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

אופן הפעולה[עריכת קוד מקור | עריכה]

עוברים על התמונה ומכפילים עם הליבה (באנגלית: 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$ מייצג את הליבה.

פעולה	ליבה ω	התמונה הסופית g(x,y)
הזהות	${\begin{bmatrix}\ \ 0&\ \ 0&\ \ 0\\\ \ 0&\ \ 1&\ \ 0\\\ \ 0&\ \ 0&\ \ 0\end{bmatrix}}$
זיהוי קצוות	${\begin{bmatrix}\ \ 1&\ \ 0&-1\\\ \ 0&\ \ 0&\ \ 0\\-1&\ \ 0&\ \ 1\end{bmatrix}}$
	${\begin{bmatrix}\ \ 0&-1&\ \ 0\\-1&\ \ 4&-1\\\ \ 0&-1&\ \ 0\end{bmatrix}}$
	${\begin{bmatrix}-1&-1&-1\\-1&\ \ 8&-1\\-1&-1&-1\end{bmatrix}}$
חידוד	${\begin{bmatrix}\ \ 0&-1&\ \ 0\\-1&\ \ 5&-1\\\ \ 0&-1&\ \ 0\end{bmatrix}}$
טשטוש קופסה	${\frac {1}{9}}{\begin{bmatrix}\ \ 1&\ \ 1&\ \ 1\\\ \ 1&\ \ 1&\ \ 1\\\ \ 1&\ \ 1&\ \ 1\end{bmatrix}}$
טשטוש גאוס 3 × 3	${\frac {1}{16}}{\begin{bmatrix}\ \ 1&\ \ 2&\ \ 1\\\ \ 2&\ \ 4&\ \ 2\\\ \ 1&\ \ 2&\ \ 1\end{bmatrix}}$
טשטוש גאוס 5 × 5	${\frac {1}{256}}{\begin{bmatrix}1&4&6&4&1\\4&16&24&16&4\\6&24&36&24&6\\4&16&24&16&4\\1&4&6&4&1\end{bmatrix}}$
ביטול חידוד 5 × 5 מבוסס על טשטוש גאוס עם כמות 1 וסף 0	${\frac {-1}{256}}{\begin{bmatrix}1&4&\ \ 6&4&1\\4&16&\ \ 24&16&4\\6&24&-476&24&6\\4&16&\ \ 24&16&4\\1&4&\ \ 6&4&1\end{bmatrix}}$

קוד[עריכת קוד מקור | עריכה]

פסאודו קוד :

for each image row in input image:
    for each pixel in image row:

        set accumulator to zero

        for each kernel row in kernel:
            for each element in kernel row:

                if element position  corresponding* to pixel position then
                    multiply element value  corresponding* to pixel value
                    add result to accumulator
                endif

         set output image pixel to accumulator

מודל TensorFlow העושה שימוש בשכבות קונבולוציה (Conv2D) :

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)

ריפוד[עריכת קוד מקור | עריכה]

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

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

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

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

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

ראו גם[עריכת קוד מקור | עריכה]

Ludwig, Jamie (n.d.). Image Convolution (PDF). Portland State University.
Lecarme, Olivier; Delvare, Karine (בינואר 2013). The Book of GIMP: A Complete Guide to Nearly Everything. No Starch Press. p. 429. ISBN 978-1593273835. {{cite book}}: (עזרה)
Gumster, Jason van; Shimonski, Robert (במרץ 2012). GIMP Bible. Wiley. pp. 438–442. ISBN 978-0470523971. {{cite book}}: (עזרה)
Shapiro, Linda G.; Stockman, George C. (בפברואר 2001). Computer Vision. Prentice Hall. pp. 53–54. ISBN 978-0130307965. {{cite book}}: (עזרה)

קישורים חיצוניים[עריכת קוד מקור | עריכה]

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