מדריך TensorFlow - למידה עמוקה באמצעות TensorFlow

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

• מה זה TensorFlow
• יסודות קוד TensorFlow
• TensorFlow UseCase

מהם טנזורים?

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

כפי שמוצג בתמונה לעיל, טנסורים הם רק מערכים רב-ממדיים, המאפשרים לייצג נתונים בעלי ממדים גבוהים יותר. באופן כללי, Deep Learning אתה מתמודד עם ערכות נתונים ממדיות גבוהות כאשר הממדים מתייחסים לתכונות שונות הקיימות בערכת הנתונים. למעשה, השם 'TensorFlow' נגזר מהפעולות שרשתות עצביות מבצעות על טנזורים. זה ממש זרימה של טנזורים. מאז, הבנתם מהם טנזורים, הבה נתקדם במדריך זה של TensorFlow ונבין - מה זה TensorFlow?

מה זה TensorFlow?

TensorFlow היא ספרייה המבוססת על Python המספקת פונקציות מסוגים שונים ליישום מודלים של למידה עמוקה. כפי שנדון קודם לכן, המונח TensorFlow מורכב משני מונחים - Tensor & Flow:

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

עכשיו יש לנו מספיק רקע על TensorFlow.

בהמשך, במדריך זה של TensorFlow נדון אודות יסודות הקוד של TensorFlow.

מדריך TensorFlow: יסודות קוד

בעיקרון, התהליך הכולל של כתיבת תוכנית TensorFlow כולל שני שלבים:

1. בניית גרף חישובי
2. הפעלת גרף חישובי

תן לי להסביר לך את שני השלבים הנ'ל בזה אחר זה:

1. בניית גרף חישובי

כך, מהו גרף חישובי? ובכן, גרף חישובי הוא סדרה של פעולות TensorFlow המסודרות כצמתים בגרף. כל צמתים לוקחים 0 או יותר טנזורים כקלט ומייצרים טנזור כפלט. הרשו לי לתת לכם דוגמא לגרף חישובי פשוט המורכב משלושה צמתים - ל , ב & ג כפי שמוצג מטה:

הסבר לתרשים החישובי הנ'ל:

• צמתים קבועיםמשמשים לאחסון ערכים קבועים מכיוון שהוא לוקח קלט אפס, אך מייצר את הערכים המאוחסנים כפלט. בדוגמה שלעיל, a ו- b הם צמתים קבועים עם הערכים 5 ו- 6 בהתאמה.

• הצומת c מייצג את פעולת הכפלת הצומת הקבוע a עם b. לכן, ביצוע צומת c יביא לכפל של צומת const a & b.

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

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

ההבדל בין העמסת יתר של השיטה לביטול ב- Java

2. הפעלת גרף חישובי

הבה ניקח את הדוגמה הקודמת של גרף חישובי ונבין כיצד לבצע אותה. להלן הקוד מהדוגמה הקודמת:

דוגמה 1:

ייבא זרימת tensor כ tf # בנה גרף a = tf.constant (5.0) b = tf.constant (6.0) c = a * b

כעת, על מנת לקבל את הפלט של צומת c, עלינו להריץ את הגרף החישובי בתוך a מוֹשָׁב . מושב ממקם את פעולות הגרף בהתקנים, כגון מעבדים או GPUs, ומספק שיטות לביצוען.

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

# צור את אובייקט ההפעלה sess = tf.Session () # הפעל את הגרף בתוך הפעלה ושמור את הפלט למשתנה output_c = sess.run (c) # הדפס את הפלט של צומת c print (output_c) # סגור את ההפעלה ל פנה כמה משאבים sess.close ()

 תְפוּקָה: 30

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

קבועים, מציין מקום ומשתנים

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

מציין מקום:

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

יבוא זורם tensor כ tf # יצירת מצייני מיקום a = tf. מציין מיקום (tf.float32) b = tf. מציין מיקום (tf.float32) # הקצאת פעולת כפל w.r.t. a & ampamp b לצומת mul mul = a * b # צור אובייקט מושב sess = tf.Session () # ביצוע mul על ידי העברת הערכים [1, 3] [2, 4] עבור a ו- b בהתאמה output = sess.run ( mul, {a: [1,3], b: [2, 4]}) הדפס ('מכפיל ab:', פלט)

 תְפוּקָה: [2. 12.]

נקודות שיש לזכור מצייני מיקום:

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

עכשיו, הבה נתקדם ונבין - מהם משתנים?

ההבדל בין סוף סוף לסוף

משתנים

בלמידה מעמיקה, מצייני מיקום משמשים לקבלת תשומות שרירותיות במודל או בגרף שלך. מלבד לקליטת קלט, עליך לשנות את הגרף כך שיוכל להפיק תפוקות חדשות w.r.t. אותן תשומות. לשם כך תשתמש במשתנים. בקצרה, משתנה מאפשר לך להוסיף לפרמטרים או צומת כאלה שניתן להכשיר, כלומר ניתן לשנות את הערך לאורך תקופה. המשתנים מוגדרים על ידי מתן הערך והסוג הראשוני שלהם כמוצג להלן:

var = tf. משתנה ([0.4], dtype = tf.float32)

הערה:

• במקרה שלא סיפקת את סוג הנתונים במפורש, TensorFlow יסיק את סוג הקבוע / משתנה מהערך האתחול.
• ל- TensorFlow יש הרבה סוגי נתונים משלה כמו tf.float32 , tf.int32 וכו ' אתה יכול להתייחס לכולם מעל כאן .

קבועים מאותחל כאשר אתה מתקשר tf.constant , וערכם לעולם לא יכול להשתנות. נהפוך הוא, משתנים אינם מאותחל כאשר אתה מתקשר tf. משתנה . כדי לאתחל את כל המשתנים בתוכנית TensorFlow, אתה צריך התקשר במפורש לפעולה מיוחדת כמוצג להלן:

init = tf.global_variables_initializer () sess.run (init)

זכרו תמיד כי יש לאתחל משתנה לפני השימוש בגרף בפעם הראשונה.

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

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

מודל רגרסיה לינארי באמצעות TensorFlow

מודל רגרסיה לינארי משמש לחיזוי הערך הלא ידוע של משתנה (משתנה תלוי) מהערך הידוע של משתנים אחרים (משתנה עצמאי) באמצעות משוואת רגרסיה ליניארית כמוצג להלן:

לכן, ליצירת מודל לינארי, עליך:

1. משתנה תלוי או פלט (Y)
2. משתנה מדרון (w)
3. Y - יירוט או הטיה (b)
4. משתנה עצמאי או קלט (X)

אז בואו נתחיל לבנות מודל ליניארי באמצעות TensorFlow:

להמיר מכפול ל- int

העתק את הקוד על ידי לחיצה על הכפתור הבא:

# יצירת משתנה לשיפוע פרמטר (W) עם ערך התחלתי כ- 0.4 W = tf. משתנה ([. 4], tf.float32) # יצירה של משתנה להטיה של פרמטר (b) עם ערך התחלתי כ -0.4 b = tf. משתנה ( [-0.4], tf.float32) # יצירת מצייני מיקום לאספקת קלט או משתנה עצמאי, המסומן על ידי xx = tf.placeholder (tf.float32) # משוואת רגרסיה לינארית_מודל = W * x + b # אתחול כל המשתנים sess = tf.Session () init = tf.global_variables_initializer () sess.run (init) # הפעלת מודל רגרסיה לחישוב תפוקת הרווח להדפסת ערכי x שסופקו (sess.run (model_ ליניארי {x: [1, 2, 3, 4]}))

תְפוּקָה:

[0. 0.40000001 0.80000007 1.20000005]

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

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

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

תפקוד אובדן - אימות מודל

פונקציית הפסד מודדת את מידת ההפקה הנוכחית של הדגם לזו של התפוקה הרצויה או היעד. אשתמש בפונקציית אובדן הנפוצה ביותר עבור מודל הרגרסיה הליניארית שלי הנקרא Sum of Squared Error או SSE. SSE מחושב w.r.t. פלט מודל (מיוצג על ידי מודל ליניארי) ופלט רצוי או יעד (y) כ:

y = tf.placeholder (tf.float32) שגיאה = linear_model - y squared_errors = tf.square (error) loss = tf.reduce_sum (squared_errors) הדפס (sess.run (הפסד, {x: [1,2,3,4) ], y: [2, 4, 6, 8]})

 תְפוּקָה: 90.24

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

tf.train API - הדרכת המודל

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

# יצירת מופע של מיטוב אופטימיזציה של ירידת מעבר הצבע = tf.train. 4], y: [2, 4, 6, 8]}) הדפס (sess.run ([W, b]))

 תְפוּקָה: [מערך ([1.99999964], dtype = float32), מערך ([9.86305167e-07], dtype = float32)]

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

עכשיו שאתה יודע על למידה עמוקה, בדוק את מאת אדוריקה, חברת למידה מקוונת מהימנה עם רשת של יותר מ -250,000 לומדים מרוצים הפזורים ברחבי העולם. קורס ההדרכה למידה עמוקה של אדוריקה עם TensorFlow עוזר ללומדים להתמחות באימון וביצוע אופטימיזציה של רשתות עצביות בסיסיות והתפתחות באמצעות פרויקטים ומשימות בזמן אמת יחד עם מושגים כגון פונקציית SoftMax, רשתות עצביות מקודדות אוטומטיות, מכונת בולצמן מוגבלת (RBM).

יש לך שאלה עבורנו? אנא הזכיר זאת בסעיף ההערות ונחזור אליך.