קָשֶׁה

בין התוספים היעילים והידידותיים למשתמש לבניית אלגוריתמי למידה עמוקה היא מסגרת עצבית מוגבהת מבוססת Python בשם Keras, אשר תיבנה על גבי מסגרות למידה עמוקות ידועות כמו TensorFlow או CNTK. כדי לאפשר חקר מהיר יותר תוך שימוש ברשתות עצביות עמוקות יותר, הוא תוכנן ידידותי למשתמש, ניתן להרחבה וניתן להתאמה. הוא מטפל בשני רשתות Feedforward ו-Retractable בנפרד, כמו גם בשילוב. הוא משתמש בחבילת ה-Backend כדי לטפל בפעולות קטנות מכיוון שהוא לא מסוגל לנהל אותן. הפריסה של Keras, יסודות הלמידה העמוקה, מבני Keras, שכבות Keras, חבילות Keras ותכנות בזמן אמת יכוסו בשיעור זה.

הגדר את Keras ב-Linux

שלב 01: עדכן מערכת

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

שלב 02: התקן את Python ו-Pip

לשימוש ב-Deep Learning דרך Keras ו-TensorFlow, עלינו להגדיר את הגרסה האחרונה של Python במחשב שלנו. לכן, אנו מתחילים להתקין את החבילה המעודכנת של Python יחד עם כלי השירות ה'pip' ההכרחי שלה במערכת שלנו. לשם כך, עלינו להשתמש שוב בתוכנית השירות 'המתאימה' של מערכת Ubuntu 20.04 Linux בשאילתת 'התקן' במעטפת ואחריה את שמות החבילות שיותקנו, כלומר Python3 ו-Python3-pip. עם ביצוע השאילתה הפשוטה הזו באזור המסוף, המערכת תתחיל להתקין ולהגדיר את שתי החבילות במערכת שלנו.

מצד שני, אם למערכת שלך מותקנת גרסה ישנה של כלי השירות 'pip' עבור Python, עליך לעדכן אותה לפני שתתקדם.

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

שלב 03: התקן את TensorFlow

לבניית למידת מכונה ומודלים עצביים מפוקחים, TensorFlow היא חבילת המתמטיקה הסמלית הידועה ביותר. לאחר שעברנו את ההתקנות, ביצענו את אותה שאילתת התקנה של 'pip3' ואחריה את שם החבילה 'Tensorflow'.

נדרשות התקנה מלאה של כלי עזר אחרים הקשורים ל-TensorFlow במערכת. כלי עזר אלה יותקנו יחד עם TensorFlow, וזה עשוי להימשך עד 10 דקות או יותר.

שלב 04: התקן חבילות חיוניות

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

שלב זה לוקח את מירב תשומת הלב שלנו על ידי אישור התקנה זו. הקש על 'y' והמשך.

שלב 05: צור סביבה וירטואלית

לאחר ההתקנות הדרושות, הגיע הזמן ליצור סביבה וירטואלית. לכן, עלינו להשתמש בכלי השירות Python3 עם אפשרות '-m' כדי ליצור את הסביבה הווירטואלית 'kerasenv' באמצעות המשתנה 'venv'. השאילתה 'ls' מראה שהסביבה נוצרה.

כעת, עלינו לנוע בתוך הסביבה הווירטואלית של תיקיית Keras. אז, השתמשנו בהוראה 'cd' יחד עם השם של תיקיית סביבה וירטואלית. לאחר מכן, עברנו בתוך תיקיית 'bin' של הסביבה הווירטואלית הזו ורשמנו את המשנה שלה. כדי להפעיל את סביבת Python זו, ניסינו את הוראת 'מקור' באזור השאילתה שלה יחד עם קובץ 'הפעל'. הסביבה הוירטואלית מופעלת עם השם 'kerasenv'.

שלב 06: התקן את ספריות Python

לאחר הגדרת הסביבה הוירטואלית של Python בהצלחה, עליך להתקין את כל ספריות Python הנדרשות לפני ההתקנה של Keras. לכן, התקנו תחילה את ספריית הפנדה באותה סביבה וירטואלית באמצעות חבילת 'pip' של Python.

המערכת תתחיל להגדיר אותה בתוך הסביבה הווירטואלית של Python, כפי שמוצג בתמונה:

לאחר התקנת ספריית הפנדות, נסה להתקין את ספריית NumPy בשיטה הבאה:

בצורה מאוד דומה, התקן את ספריית ה-scipy של Python באותה סביבה.

כעת, התקן את ספריית matplotlib של Python בסביבה.

Python משתמש באלגוריתמי אשכולות ורגרסיה בלמידת מכונה כדי לבצע מודלים של רשתות עצביות. לשם כך, יש לו את ספריית ה-sci-kit learn אותה אנו מתקינים עם כלי השירות 'pip' יחד עם אפשרות '-u' כדי להגדיר גם את החבילות הנדרשות.

העיבוד של התקנת ספריית scikit הוצג להלן:

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

שלב 07: התקן את ספריית Keras

לאחר ההתקנה של כל ספריות הדרישות הדרושות של Python, נוכל סוף סוף להתקין את Keras בתוך הסביבה הווירטואלית של Python. כלי השירות 'pip' ישמש למטרה זו בתוך שאילתת ה'התקנה' שלנו עם שם המודול, כלומר, 'Keras'. אם המערכת מראה שהדרישה שלה כבר מסופקת, זה אומר שהיא כבר מותקנת ומוגדרת.

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

לאחר ההגדרה וההתקנה המלאה של ספריית 'Keras' בסביבה הוירטואלית, הגיע הזמן להציג את המידע המלא לגביה במעטפת באמצעות שאילתת 'pip show'. הביצוע של שאילתת 'הצג' זו הציגה את גרסת ה-Keras המותקנת בסביבה הווירטואלית שלנו של Python, שמה, הסיכום שלה, דף הבית, המחבר, האימייל של המחבר, הרישיון, המיקום שהיא תופסת על המערכת שלנו, ועוד רבים. עוד כפי שמוצג להלן:

לאחר ההתקנות הטובות ביותר של ספריות Keras ו-TensorFlow של Python, עלינו לצאת מהסביבה הוירטואלית. לשם כך, נסה את שאילתת 'השבתה' במעטפת וצא.

שלב 08: התקן את Anaconda Cloud

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

קובץ זה שוכן בתיקיית הבית הנוכחית של מכונת לינוקס לפי שאילתת 'ls'. תחילה עליך לוודא שזהו checksum, כלומר, אם הוא נכון במלואו או לא באמצעות שאילתת sha256sum.

לאחר מכן, עלינו להתקין את קובץ ה-Bash שהורדת של anaconda במערכת שלנו באמצעות הוראת 'Bash' ושם הקובץ באותה קונסולה. הוא ביקש מאיתנו לעיין בהסכם הרישיון לפני ההתקנה. אז הקשנו על 'Enter' כדי להמשיך.

לאחר שעברנו על הסכם הרישיון שלו, הוא מבקש מאיתנו להקיש על 'כן' אם אנו מסכימים לתנאים. עליך ללחוץ על Enter כדי להמשיך להתקין אותו באותו מקום או לכתוב את הנתיב לספרייה שבה ברצונך להתקין אותה. אחרת, השתמש ב-'Ctrl-c' כדי לבטל את ההתקנה.

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

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

אתה צריך להפעיל את הקובץ 'הפעיל' מתיקיית anaconda דרך שאילתת 'מקור' בתור שורש.

נסה להפעיל את נווט anaconda באמצעות השאילתה הבאה.

כדי ליצור ולעבוד על סביבת הקונדה החדשה, נסה את הוראת 'conda create' עם אפשרות השם ואחריה שם הסביבה החדשה, כלומר PyCPU.

תהליך זה דורש אישור שלנו על יצירת הסביבה החדשה. הקש על 'y'.

כדי להפעיל ולהפעיל את סביבת הקונדה החדשה, השתמש בשאילתת 'הפעל conda' עם שם הסביבה החדשה שלך, כלומר, סביבת PyCPU מופעלת כעת.

שלב 09: התקן את Spyder IDE

יש להתקין את Spyder IDE בסביבה זו לביצוע תוכניות Python. לשם כך, ניסינו את שאילתת ההתקנה של conda במעטפת סביבת PyCPU עם מילת המפתח 'spyder'.

הקש על 'y' כדי להמשיך בהתקנת Spyder.

שלב 10: התקן את ספריית Pandas and Keras

לאחר ההתקנה של Spyder, התקן את ספריית הפנדה של Python בסביבת אנקונדה באמצעות שאילתת ההתקנה של conda עם אפשרות -c.

שוב, לחץ על כפתור 'y' כדי להמשיך.

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

המשך לאחר לחיצה על כפתור 'y'.

אתה יכול להפעיל את Spyder IDE במסוף הסביבה הנוכחית של anaconda באופן הבא:

ה-Spyder IDE התכונן להשקה.

התיקיה הנסתרת '.keras' אותרה בספריית הבית. הסר אותו ופתח את קובץ 'keras.json' שלו כדי להוסיף בו את התצורות הבאות.

הגדר את Keras ו- TensorFlow ב-Windows

כדי להגדיר את Keras ו-TensorFlow בסביבת Windows, עליך לוודא ששפת Python יחד עם ספריית ה-'pip' שלה ו-Anaconda Navigator כבר מוגדרים עליה. לאחר הגדרתו, עליכם לפתוח אותו מאזור החיפוש שלכם ולעבור בכרטיסייה 'סביבות'. בכרטיסייה זו, תמצא את שם הסביבה שבה אתה עובד כעת, כלומר, בסיס. באזור למטה תמצא את הכרטיסייה הבאה. הקש על האפשרות 'צור'.

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

אתה תראה שהסביבה התחילה להיטען.

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

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

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

זה התחיל לעבוד ולהגדיר את TensorFlow בסביבת האנקונדה שלנו.

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

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

מסרגל החיפוש של Windows, חפש את מילת המפתח 'Jupyter'. האפליקציה בשם 'Jupyter Notebook (TensorFlow)' תוצג יחד עם אחרים. הקש עליו כדי להפעיל את מחברת jupyter כאשר הקצה האחורי TensorFlow מופעל. צור קובץ Python חדש והתחל לעבוד.

למידה עמוקה דרך קשה

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

רשת עצבית מלאכותית (ANN)

נראה שמתודולוגיית 'הרשת העצבית המלאכותית' (ANN) היא השיטה הנפוצה והבסיסית ביותר ללמידה עמוקה. הם מוציאים את הרמזים שלהם מהמוח האנושי, המרכיב הטבעי המסובך ביותר של הגוף שלנו, המשמש כמודל שלהם. למעלה מ-90 מיליארד תאים מיקרוסקופיים הנקראים 'נוירונים' מרכיבים את מוחו של אדם. אקסונים ודנדריטים הם סוגים של סיבי עצב המחברים נוירונים זה לזה. תפקידו העיקרי של האקסון הוא לשלוח נתונים מנוירון מקושר אחד לשני. למידע נוסף, אנא חפש ממנוע החיפוש של גוגל.

אדריכלות קרס

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

• דֶגֶם
• שִׁכבָה
• מודולי ליבה

דגם קשיח

מודל Keras מורכב משני סוגים בדיוק, כלומר, API רציף ופונקציונלי.

מודל רציף

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

הוסף שכבות

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

גישה לדגם

אתה יכול לקבל מידע לגבי שכבות הדגם שלך, נתוני הקלט שבהם השתמש ונתוני הפלט שלו. הפונקציה model.layers מאפשרת לך לגשת לכל השכבות. ה-model.inputs יציג טנסור קלט, ו-model.output יציג טנסור פלט.

עשה סדרה של הדגם

קל להחזיר את המודל המשמש בסקריפט כאובייקט או JSON. לדוגמה, הפונקציה get_config() מניבה את המודל כישות/אובייקט. הפונקציה from_config() יוצרת מודל חדש באמצעות האובייקט כערך פרמטרי.

אתה יכול גם לשנות את המודל שלך ל-JSON באמצעות הפונקציה to_json() .

סיכום דגם

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

לאמן ולחזות את הדגם

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

שכבות קשות

כל שכבת קלט, מוסתרת ותשואה במודל המוצע של רשתות עצביות תואמת לשכבת Keras שונה במודל האמיתי. כל רשת עצבית מתוחכמת עשויה להתפתח במהירות באמצעות שפע של שכבות מובנות מראש של ספריית Keras. יש לנו שכבות קרס שונות, כלומר שכבות ליבה, שכבות בריכה, שכבות חוזרות ושכבות קונבולציה. אתה יכול ללמוד אותם על ידי חיפוש באינטרנט. שתי השורות הראשונות ייבאו את שכבת מצב Sequential, צפוף, הפעלה ו-Dropout.

ניסינו את ה-API Sequential() ליצירת מודל רציף של נשירה. על ידי ביטול מודל ההפעלה 'relu' יצרנו שכבה צפופה באמצעות ה-API 'צפוף'. כדי לתת מענה להתאמת יתר של השכבה הצפופה, השתמשנו ב-Dropout() API, כלומר, שכבות נשירה באמצעות פונקציית dropout(). לאחר מכן, השתמשנו כאן בשכבה צפופה יותר עם מודל ההפעלה 'relu'. כדי להתמודד עם השכבות הצפופות מהתאמה יתר, עלינו לעשות שימוש בשכבות Dropout. בסופו של דבר, הורדנו את השכבות הצפופות הסופיות שלנו באמצעות מודל ההפעלה מסוג 'softmax'.

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

• צורת נתונים קלט
• סך הנוירונים/יחידות בשכבה
• אתחולים
• מסדרים
• אילוצים
• הפעלות

צורת נתונים קלט

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

אתחולים

מודול האתחולים של Keras Layers מספק לנו פונקציות רבות לציון משקל ספציפי לנתוני קלט. לדוגמה, הפונקציה zeros() מציינת 0 עבור כולם, ה-ones() תציין עבור כולם, והפונקציה constant() תציין ערך קבוע מוגדר שנוסף על ידי משתמש עבור כולם ועוד. להבנה טובה יותר, השתמשנו בפונקציה identity() כדי ליצור מטריצת זהות. את שאר הפונקציות ניתן לחפש גם ממנוע החיפוש.

אילוצים

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

מסדרים

במהלך האופטימיזציה, הוא מטיל חיובים שונים על נכס השכבה. זה גם הגיע עם כמה פונקציות לעשות זאת, כלומר, L1 regularizer, L2 regularizer ו-'LI ו-L2' Regularizer. להלן ההמחשה הפשוטה ביותר של פונקציית המסדר L1:

הפעלות

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

מודולים קשיחים

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

אחורי

אחד המודולים הידועים והמשומשים ביותר שלו הוא מודול 'Backend' שתוכנן להשתמש בספריות הקצה האחורי של Python כמו TensorFlow ו-Theano. באמצעות מודול הקצה האחורי, אנו יכולים להשתמש בכמה שיותר פונקציות קצה הקצה מספריית TensorFlow ו-Theano. כדי להשתמש במודול ספריית הקצה האחורי, עלינו לציין את ספריית הקצה האחורי שתשמש בקובץ התצורה 'keras.json, שיצרנו בתיקיית .keras הנסתרת. כברירת מחדל, הקצה האחורי צוין כ'TensorFlow', אך אתה יכול לשנות אותו גם לחלק אחר, כלומר, Theano או CNTK.

במסגרת הדוגמה שלנו, נשתמש בספריית TensorFlow כ-backend. כדי לטעון את התצורות של הקצה האחורי מקובץ keras.json של תיקיית השורש 'keras', השתמש ב:

• מ-keras ייבוא ​​אחורי כ-k

לאחר ייבוא ​​מוצלח של ה-backend מקובץ keras.json, הגיע הזמן לקבל את המידע ה-backend באמצעות המשתנה 'k' עם המשתנה שיש לאחזר. ראשית, הבאנו את השם של backend בו השתמשנו וכבר ייבאנו באמצעות הפונקציה 'backend()'. הוא מחזיר את 'Tensorflow' כערך הקצה האחורי שלו. כדי לקבל את ערך ה-float של ה-backend, קראנו לפונקציה floatx() דרך אובייקט המשתנה 'k' של Keras. זה מראה שהשתמשנו בערך float32.

כדי לקבל את הפורמט של נתוני תמונה, השתמש בפונקציה image_Data_format() עם המשתנה 'k'. בשימוש בו, זה מראה שה-backend שלנו השתמש בפורמט נתוני התמונה 'channels_last'. כדי לקבל את כוח המעריך עבור הקצה האחורי, קרא לפונקציה epsilon() עם המשתנה 'k'. זה מחזיר שהקצה האחורי ישתמש בעוצמה המעריכית של '07'. זה הכל לגבי שליפת מידע עורפי.

Get_uid() פונקציה

זה הזמן להסתכל על כמה פונקציות אחוריות של TensorFlow כדי להבין את הפונקציונליות שלה. אחת מהפונקציות האחוריות הנפוצות ביותר שלה 'פונקציית get_uid() המשמשת לזיהוי גרף ברירת המחדל שבו השתמשנו. השימוש בו עם הפרמטר prefix='' יחזיר '1', כלומר לפי השימוש. שוב, השימוש בו יחזיר '2' כפי שקראנו לו שוב וערך הגרף הוגדל. לאחר שימוש בפונקציה 'reset_uids', ערך מזהה המשתמש בגרף יאופס ל-0. לפיכך, שימוש בפונקציה get_uid() שוב יגדיל אותו ב-1.

Placeholder() פונקציה

הטנזור השתמש בפונקציית placeholder() כדי להחזיק בו צורות מימדיות שונות. לדוגמה, בתוך האיור הבא, השתמשנו בו כדי להחזיק את התמונה התלת-ממדית בטנזור באמצעות המשתנה Keras 'k' ולשמור אותו למשתנה אחר 'd'. הפלט של משתנה 'd' מציג את המאפיינים של צורה המשמשת בתוך מציין המיקום.

הפונקציה 'int_shape()' משמשת להצגת הצורה של ערך שנשמר במציין המיקום 'd'.

Dot() פונקציה

האם אי פעם הכפלת שני וקטורים? אם כן, זה לא יהיה מאתגר עבורך להכפיל שני טנסורים. לשם כך, ספריית הקצה האחורית המציאה את הפונקציה 'נקודה'. ראשית, כדי להחזיק את שתי הצורות השונות, השתמשנו בערכי הצורה בפונקציית המיקום() ב-2 השורות הראשונות כדי ליצור שני מחזיקים 'x' ו-'y'. הפונקציה dot() לקחה את מחזיקי ה-'x' וה-'y' כדי להכפיל את שני הטנזורים ולשמור את התוצאה למשתנה אחר 'z'. בשימוש בטנסור 'z' להדפסה, הוא הציג את צורת הטנזור המתקבלת המוכפלת (1, 5) על המסך.

Ones() פונקציה

הפונקציה ones() של מודול הקצה האחורי ידועה באתחול כל הערכים של צורה מסוימת ל-1. לדוגמה, השתמשנו בפונקציה ones() בצורת הטנסור (3,3) ושמרנו את התוצאה ל- המשתנה 'v'. הפונקציה eval() מודחקת כאן כדי להעריך את הערך של משתנה 'v' ולהציג ב- בסביבת Python. בתמורה, הוא המיר את הצורה (3,3) למטריצת מערך של כל אלה עם סוג הנתונים float32.

Batch_dot() פונקציה

אצווה הטנזור תציין את סך הדגימות למיון לפני עדכון מודל. הפונקציה batch_dot() של הקצה האחורי של TensorFlow משמשת בעיקר כדי לגלות את תוצאת הכפל של שני נתוני אצווה שונים. לכן, יצרנו שני משתני טנסור v1 ו-v2 והשתמשנו בפונקציה Input() כדי לשמור אותם ב-v1 ו-v2 כקלט. לאחר מכן, ניסינו את הפונקציה batch_dot() בשני משתני הטנזור, v1 ו-v2, והערך המתקבל יישמר למשתנה אחר 'v3'. בהדפסת המשתנה v3, מצאנו את הצורה שהתקבלה (2,2) בתמורה.

פונקציה משתנה

אם אי פעם עבדת על שפה אחרת כלשהי, ייתכן שאתחלת משתנים רבים עם מילת המפתח 'var' או בלעדיה. פעמים רבות, ייתכן שאתחלת את המשתנים עם סוגי הנתונים שלהם כמו מספר שלם, מחרוזת או תו. בתוך ספריית Python Keras, אנו יכולים ליצור כל משתנה באמצעות פונקציית variable() בכמה נתוני טנסור בצורה של דוגמאות.

בתוך התמונה הבאה, יצרנו משתנה 'd' על ידי הוספת נתוני הרשימה לדוגמה של שני לתוך פונקציית משתנה() עם האובייקט Keras 'k'. לאחר הוספת המשתנה הזה, קראנו לפונקציה transpose() במשתנה זה 'd' כדי לגלות את ההעברה של נתוני מדגם בתוכו באמצעות האובייקט Keras 'k'. הטרנספוזיה שנוצרה תישמר למשתנה 'val'. הצהרת ההדפסה של שפת Python שימשה כאן כדי להדפיס את הערך של המשתנה המתקבל 'val'. הצהרת ההדפסה מציגה את בחירת הפונקציה שהחלנו על המשתנה 'd' ואת המספר הכולל של האלמנטים בכל רשימה.

לאחר מכן, ניסינו את הפונקציה 'eval' במשתנה 'val' כדי לקבל את ההעברה של הדוגמאות למשתנה 'd' ופונקציית ההדפסה מציגה אותו. אתה יכול לראות את ההעברה של שתי רשימות בפלט.

איור הקוד הקודם הושג על ידי שימוש בפונקציות פשוטות של Python מבלי לייבא ספריית Python מסוימת. ניתן למצוא את ה'טרנספוזי' של שני מערכי נתונים באמצעות מערכי NumPy. לשם כך, עלינו לייבא את ספריית NumPy בתור 'n' בהתחלה. הפורמט הבסיסי זהה, אבל אנחנו צריכים לאתחל את ערכת נתוני הצורה עם מילת המפתח 'מערך' במקום להשתמש במילת המפתח 'משתנה'. יש לשמור את מערך NumPy לדוגמה בחזרה למשתנה 'd'. אותו אובייקט NumPy 'n' משמש כדי לקרוא לפונקציה transpose() במשתנה 'd' ולשמור את התוצאה שלו במשתנה 'val'.

הצהרת ההדפסה קראה למשתנה 'val' שבו כדי להציג את טנסור ההעברה שלו. אתה יכול לראות, כדי להציג את הערך המועבר כתוצאה של המשתנה 'val', אנחנו לא צריכים את הפונקציה 'eval' כאן. כעת, השתמשנו בפונקציית המשתנה עם הארגומנט 'd' ושמרנו את התוצאה במשתנה 'z'. לאחר ניסיון של משפט ההדפסה על ידי הוספת ערך הארגומנט 'z' בו, הוא הציג את הפלט באותו פורמט קודם שניסינו בדוגמה של המשתנה שלמעלה.

Is_sparse() פונקציה

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

ראשית, קראנו לפונקציית placeholder() כדי להחזיק את צורת הטנזור (3,3) יחד עם הארגומנט Sparse מוגדר כ-true. ערך מציין מיקום זה יישמר על ה-'x' שניתן לשינוי ויוצג. הפלט הציג את המידע לגבי משתנה מציין המיקום 'x'.

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

To_dense() פונקציה

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

הפונקציה 'to_dense()' מוחלת על משתנה הטנסור הצפוף 'x', כלומר, להמיר אותו לטנסור צפוף ולשמור אותו למשתנה אחר 'res'. כעת, ה'מיל' הוא טנסור צפוף בעצמו. הצהרת ההדפסה בוטלה כדי להדפיס את המשתנה 'res'. השימוש בהצהרות הדפסה עבור המשתנה 'res' הציג את המידע לגבי המשתנה שהומר 'res', כלומר, המיר בהצלחה דלילה לצפוף ועוד הרבה יותר.

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

Random_uniform_variable() פונקציה

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

בשיטת random_uniform_variable() שני הארגומנטים הבאים הם הממוצע והסטייה האופיינית מהתפלגות אחידה. בתוך איור זה, אתחלנו שני טנסורים 'x' ו- 'y' באמצעות ההתפלגות האחידה הסטנדרטית באמצעות הפונקציה random_uniform_variable() . שני הטנזורים מכילים פורמטים שונים של צורות, כלומר שורות ועמודות עם אותו ממוצע וסטיית תקן, כלומר, נמוך=0, וגבוה=1.

לאחר מכן, אנו מסירים את הפונקציה 'נקודה' ולוקחים את הטנסורים 'x' ו- 'y' בה לכפל. התוצאה של הכפל הזה תישמר במשתנה 'z'. בסופו של דבר, חובה להשתמש ב-int_shape() כדי להציג את הצורה של טנסור שנוצר 'z'. הפלט מציג את הטנזור (2,2).

שימושים

אם אתה רוצה להשתמש בחלק מהפונקציות השימושיות מאוד מתפיסת הלמידה העמוקה של Python, עליך להשתמש במודול utils של ספריית Keras בסקריפטים שלך. לדוגמה, אם אתה רוצה להציג את הנתונים שלך בפורמט HDF5Matrix, עליך לייבא את המחלקה HDF5Matrix ולהשתמש בפונקציית HDF5Matrix שלה בסקריפט.

To_categorical() פונקציה

פונקציה זו מאפשרת לך לשנות וקטור מחלקה למטריצה, כלומר מטריצת מחלקה בינארית. נניח, ייבאנו את הפונקציה to_categorical() מהמודול utils ואתחול וקטור 'A'. הווקטור 'A' הועבר לפונקציה to_categorical() . המטריצה ​​הבינארית של וקטור מחלקה זה 'A' הוצגה.

print_summary() פונקציה

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

plot_model() פונקציה

הפונקציה plot_model() מסמנת את המודל בפורמט נקודה ומאפשרת לשמור אותו במסמך.

סיכום

לסיכום, אנו יכולים לומר ששפת Python היא שפה הכרחית לעידן של היום שכן הכל נהיה מהיר והטכנולוגיה התפתחה כל כך מהר בטירוף. לאורך הנחיות למידה זו, היינו עדים לשימוש בספריית Keras של Python בלמידה עמוקה וברשתות עצביות מלאכותיות. לשם כך, עברנו גם על החשיבות והשימוש בספריית הקצה האחורית שלה 'TensorFlow' כדי לקבל הבנה ברורה. בנוסף, דנו והסברנו על כל תצורה הנדרשת להגדרת סביבת Keras ו-Anaconda ב-Python בתוך מערכת ההפעלה Ubuntu 20.04 Linux. לאחר מכן, דנו ביסודיות במודלים, השכבות והמודולים של Keras אחד אחד יחד עם הפונקציות הנפוצות ביותר שלהם. להדגמה של מודל ה-API של Function, בדוק את התיעוד הרשמי.