TensorFlow Autoencoder: מערך נתונים עם דוגמא למידה מעמיקה

מהו קוד אוטומטי?

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

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

במדריך זה של TensorFlow Autoencoder, תלמד:

כיצד פועל Autoencoder?

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

מקודד אוטומטי אופייני מוגדר עם קלט, ייצוג פנימי ופלט (קירוב של הקלט). הלמידה מתרחשת בשכבות המחוברות לייצוג הפנימי. למעשה, ישנם שני גושי שכבות עיקריים שנראים כמו רשת עצבית מסורתית. ההבדל הקל הוא שהשכבה המכילה את הפלט חייבת להיות שווה לקלט. בתמונה למטה, הקלט המקורי נכנס לבלוק הראשון שנקרא קוֹדַאִי . ייצוג פנימי זה דוחס (מפחית) את גודל הקלט. בבלוק השני מתרחשת שחזור הקלט. זהו שלב הפענוח.

עבודה של Autoencoder

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

באופן קונקרטי, דמיינו תמונה בגודל 50x50 (כלומר, 250 פיקסלים) ורשת עצבית עם רק שכבה נסתרת אחת המורכבת ממאה נוירונים. הלמידה נעשית על מפת תכונה שהיא קטנה פי שניים מהקלט. המשמעות היא שהרשת צריכה למצוא דרך לשחזר 250 פיקסלים כאשר וקטור נוירונים בלבד שווה ל -100.

דוגמת Autoencoder מוערמת

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

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

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

בנה מקודד אוטומטי עם TensorFlow

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

אתה תשתמש ב- מערך נתונים של CIFAR-10 המכיל 60000 תמונות 32x32 בצבע. מערך הנתונים של Autoencoder כבר מפוצל בין 50000 תמונות לאימון לבין 10000 לבדיקה. יש עד עשר כיתות:

  • מטוס
  • מְכוֹנִית
  • ציפור
  • חתול
  • צְבִי
  • כֶּלֶב
  • צְפַרְדֵעַ
  • סוּס
  • ספינה
  • מַשָׂאִית

עליך להוריד את התמונות בכתובת URL זו https://www.cs.toronto.edu/~kriz/cifar.html ולפתוח אותה. התיקייה for-10-batches-py מכילה חמש קבוצות נתונים עם 10000 תמונות כל אחת לפי סדר אקראי.

לפני שאתה בונה ומאמן את המודל שלך, עליך ליישם קצת עיבוד נתונים. תמשיך כך:

  1. ייבא את הנתונים
  2. המרת הנתונים לפורמט בשחור לבן
  3. צרף את כל המנות
  4. בנה את מערך ההדרכה
  5. בנה ויזואליזציה של תמונות

עיבוד תמונה מוקדם

שלב 1) ייבא את הנתונים.

על פי האתר הרשמי, אתה יכול להעלות את הנתונים עם הקוד הבא. קוד Autoencoder יטען את הנתונים במילון עם נתונים וה תווית . שים לב שהקוד הוא פונקציה. | _+_ |

שלב 2) המרת הנתונים לפורמט בשחור לבן

לשם הפשטות, תמיר את הנתונים לגווני אפור. כלומר, עם מימד אחד בלבד מול שלושה עבור תמונת הצבעים. רוב הרשת העצבית פועלת רק עם קלט ממד אחד. | _+_ |

שלב 3) צרף את כל המנות

כעת, לאחר שתי הפונקציות נוצרות והערך הנתונים נטען, תוכל לכתוב לולאה לצירוף הנתונים בזיכרון. אם תבדוק היטב, קובץ הפתיחה עם הנתונים נקרא data_batch_ עם מספר מ -1 עד 5. תוכל לעבור על הקבצים ולצרף אותו לנתונים.

בסיום שלב זה, אתה ממיר את נתוני הצבעים לתבנית בקנה מידה אפור. כפי שאתה יכול לראות, צורת הנתונים היא 50000 ו- 1024. 32*32 הפיקסלים שטוחים כעת לשנת 2014. | _+_ |

הערה: שנה את './cifar-10-batches-py/data_batch_' למיקום האמיתי של הקובץ שלך. למשל עבור מכונת Windows, הנתיב יכול להיות שם filen = 'E: cifar-10-batches-py data_batch_' + str (i)

שלב 4) בנה את מערך ההדרכה

בכדי להפוך את האימון למהיר וקל יותר, תאמן מודל על תמונות הסוס בלבד. הסוסים הם המחלקה השביעית בנתוני התווית. כפי שצוין בתיעוד מערך הנתונים CIFAR-10, כל מחלקה מכילה 5000 תמונות. אתה יכול להדפיס את צורת הנתונים כדי לאשר שיש 5.000 תמונות עם 1024 עמודות כפי שמוצג בשלב הדוגמה להלן של TensorFlow Autoencoder. | _+_ |

שלב 5) בנה ויזואליזציה של תמונות

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

דרך קלה להדפיס תמונות היא שימוש באובייקט imshow מספריית matplotlib. שים לב כי עליך להמיר את צורת הנתונים מ- 1024 ל- 32*32 (כלומר פורמט של תמונה). | _+_ |

הפונקציה לוקחת 3 ארגומנטים:

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

תוכל לנסות לשרטט את התמונה הראשונה במערך הנתונים. אתה צריך לראות גבר על סוס. | _+_ |

הגדר מעריך נתונים

בסדר, עכשיו כשנתון הנתונים מוכן לשימוש, אתה יכול להתחיל להשתמש ב- Tensorflow. לפני בניית המודל, בואו נשתמש במערכת הנתונים של Tensorflow כדי להאכיל את הרשת.

תוכל לבנות מערך נתונים עם אומדן TensorFlow. כדי לרענן את דעתך, עליך להשתמש ב:

  • from_tensor_slices
  • חזור
  • קבוצה

הקוד המלא לבניית מערך הנתונים הוא: | _+_ |

שים לב ש- x הוא מציין מיקום בעל הצורה הבאה:

  • [None, n_inputs]: הגדר ל- None מאחר ומספר הזנת התמונה לרשת שווה לגודל האצווה.

לפרטים, עיין במדריך בנושא רגרסיה לינארית.

לאחר מכן, עליך ליצור את האיטרציה. ללא שורת קוד זו, לא יעברו נתונים בצינור. | _+_ |

כעת, כשהצינור מוכן, תוכל לבדוק אם התמונה הראשונה זהה לבעבר (כלומר, אדם על סוס).

אתה מגדיר את גודל האצווה ל -1 מכיוון שאתה רק רוצה להאכיל את מערך הנתונים עם תמונה אחת. אתה יכול לראות את ממד הנתונים בעזרת הדפסה (sess.run (features) .shape). הוא שווה ל (1, 1024). 1 פירושו שרק תמונה אחת עם 1024 היא הזנה כל אחת. אם גודל האצווה מוגדר לשניים, שתי תמונות יעברו בצינור. (אל תשנה את גודל האצווה. אחרת היא תשליך שגיאה. רק תמונה אחת בכל פעם יכולה לעבור לפונקציה plot_image (). | _+_ |

בנה את הרשת

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

לרשת שלך יהיו שכבות קלט אחת עם 1024 נקודות, כלומר 32x32, צורת התמונה.

בלוק המקודד תהיה שכבה נסתרת עליונה אחת עם 300 נוירונים, שכבה מרכזית עם 150 נוירונים. בלוק המפענח סימטרי למקודד. אתה יכול לדמיין את הרשת בתמונה למטה. שים לב שאתה יכול לשנות את הערכים של שכבות נסתרות ומרכזיות.

בניית הרשת עבור Autoencoder

בניית קוד אוטומטי דומה מאוד לכל מודל למידה עמוקה אחרת.

תוכלו לבנות את המודל על פי השלבים הבאים:

  1. הגדר את הפרמטרים
  2. הגדירו את השכבות
  3. הגדר את הארכיטקטורה
  4. הגדר את האופטימיזציה
  5. הפעל את המודל
  6. להעריך את המודל

בחלק הקודם למדת כיצד ליצור צינור להזנת המודל, כך שאין צורך ליצור פעם נוספת את מערך הנתונים. תוכל לבנות קוד מקודד בעל ארבע שכבות. אתה משתמש באתחול Xavier. זוהי טכניקה לקביעת המשקולות הראשוניות השונות לשונות של הקלט והפלט. לבסוף, אתה משתמש בפונקציית ההפעלה elu. אתה מסדיר את פונקציית ההפסד בעזרת Lizerizer L2.

שלב 1) הגדר את הפרמטרים

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

לפני כן, אתה מייבא את הפונקציה באופן חלקי. זוהי שיטה טובה יותר להגדיר את הפרמטרים של השכבות הצפופות. הקוד שלהלן מגדיר את הערכים של ארכיטקטורת האוטודן. כפי שצוין קודם לכן, לאופן המקודד יש שתי שכבות, עם 300 נוירונים בשכבות הראשונות ו -150 בשכבות השנייה. הערכים שלהם מאוחסנים ב- n_hidden_1 ו- n_hidden_2.

עליך להגדיר את קצב הלמידה ואת היפרפרמטר L2. הערכים מאוחסנים ב- learning_rate וב- l2_reg | _+_ |

טכניקת האתחול של חאווייר נקראת עם האובייקט xavier_initializer מהתרומת האומדן. באותו אומדן, אתה יכול להוסיף את הסדיר עם l2_regularizer | _+_ |

שלב 2) הגדירו את השכבות

כל הפרמטרים של השכבות הצפופות נקבעו; אתה יכול לארוז הכל במשתנה dense_layer באמצעות האובייקט חלקי. dense_layer המשתמש בהפעלת ELU, אתחול Xavier והסדרת L2. | _+_ |

שלב 3) הגדר את הארכיטקטורה

אם אתה מסתכל על תמונת הארכיטקטורה, אתה שם לב שהרשת מערמת שלוש שכבות עם שכבת פלט. בקוד למטה, אתה מחבר את השכבות המתאימות. לדוגמה, השכבה הראשונה מחשבת את מוצר הנקודה בין תכונות המטריצה ​​של הכניסות לבין המטריצות המכילות את 300 המשקולות. לאחר חישוב מוצר הנקודה, הפלט עובר לפונקציית ההפעלה Elu. הפלט הופך לקלט של השכבה הבאה, לכן אתה משתמש בה לחישוב Hidden_2 וכן הלאה. ריבוי המטריצות זהה לכל שכבה מכיוון שאתה משתמש באותה פונקציית הפעלה. שים לב כי השכבה האחרונה, הפלט, אינה מיישמת פונקציית הפעלה. זה הגיוני כי זהו הקלט המשוחזר | _+_ |

שלב 4) הגדר את האופטימיזציה

השלב האחרון הוא בניית האופטימיזציה. אתה משתמש בשגיאת ריבוע ממוצעת כפונקציית אובדן. אם אתה זוכר את ההדרכה בנושא רגרסיה לינארית, אתה יודע ש- MSE מחושב עם ההבדל בין הפלט החזוי לבין התווית האמיתית. כאן, התווית היא התכונה מכיוון שהמודל מנסה לשחזר את הקלט. לכן, אתה רוצה את ממוצע סכום ההפרש של הריבוע בין פלט חזה לקלט. בעזרת TensorFlow תוכל לקודד את פונקציית האובדן כדלקמן: | _+_ |

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

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

אם אתה רוצה להעביר 150 תמונות בכל פעם ואתה יודע שיש 5000 תמונות במערך הנתונים, מספר האיטרציות שווה. בפייתון אתה יכול להריץ את הקודים הבאים ולוודא שהפלט הוא 33: | _+_ |

שלב 5) הפעל את המודל

אחרון חביב, הכשיר את הדגם. אתה מאמן את הדגם עם 100 עידן. כלומר, המודל יראה פי 100 מהתמונות למשקלים מותאמים.

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

אתה מעוניין להדפיס את ההפסד לאחר עשרה תקופות כדי לראות אם המודל לומד משהו (כלומר, האובדן יורד). האימון אורך 2 עד 5 דקות, תלוי בחומרת המכונה שלך. | _+_ |

שלב 6) להעריך את המודל

כעת לאחר שהמודל שלך הוכשר, הגיע הזמן להעריך אותו. עליך לייבא את תעודת הבדיקה מהקובץ /cifar-10-batches-py /. | _+_ |

הערה: עבור מכונת Windows, הקוד הופך test_data = unpickle (r'E: cifar-10-batches-py test_batch ')

אתה יכול לנסות להדפיס את התמונות 13, שהיא סוס | _+_ |

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

הפונקציה לוקחת שני טיעונים:

  • df: ייבא את נתוני הבדיקה
  • מספר_תמונה: ציין איזו תמונה לייבא

הפונקציה מחולקת לשלושה חלקים:

  1. עיצב מחדש את התמונה למימד הנכון כלומר 1, 1024
  2. להאכיל את המודל עם התמונה הבלתי נראית, לקודד/לפענח את התמונה
  3. הדפס את התמונה האמיתית והמשוחזרת
 import numpy as np import tensorflow as tf import pickle def unpickle(file): import pickle with open(file, 'rb') as fo: dict = pickle.load(fo, encoding='latin1') return dict 

כעת, כאשר פונקציית ההערכה מוגדרת, תוכל להציץ במספר התמונה המשוחזר שלוש עשרה | _+_ | | _+_ |

סיכום

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

הארכיטקטורה של קוד אוטומטי סימטרי עם שכבת ציר בשם השכבה המרכזית.

אתה יכול ליצור את המקודד האוטומטי באמצעות:

  • חלקי: כדי ליצור את השכבות הצפופות עם ההגדרה האופיינית:
  • def grayscale(im): return im.reshape(im.shape[0], 3, 32, 32).mean(1).reshape(im.shape[0], -1) 
  • dense_layer (): לביצוע הכפלת המטריצה

אתה יכול להגדיר את פונקציית ההפסד והאופטימיזציה באמצעות: | _+_ |

ריצה אחרונה הפעלה לאימון המודל.