סיווג תמונות משימה שאפילו תינוק יכול לבצע תוך שניות, אך עבור מכונה זו הייתה משימה קשה עד ההתקדמות האחרונה ו למידה עמוקה . מכוניות בנהיגה עצמית יכולות לזהות חפצים ולנקוט פעולה נדרשת בזמן אמת ורוב זה אפשרי בגלל סיווג תמונות. במאמר זה אדריך אתכם בנושאים הבאים:
מה זה TensorFlow?
TensorFlow היא מסגרת הלמידה המקורית הפתוחה של גוגל לתכנות זרימת נתונים במגוון משימות. צמתים בגרף מייצגים פעולות מתמטיות, ואילו קצוות הגרף מייצגים את מערכי הנתונים הרב-ממדיים המועברים ביניהם.
טנזורים הם רק מערכים רב ממדיים, הרחבה של טבלאות דו ממדיות לנתונים עם ממד גבוה יותר. קיימות תכונות רבות של Tensorflow ההופכות אותו למתאים למידה עמוקה וספריית הקוד הפתוח המרכזית שלה מסייעת לך לפתח ולהכשיר דגמי ML.
מהי סיווג תמונות?
הכוונה בסיווג תמונות היא לסווג את כל הפיקסלים בתמונה דיגיטלית לאחד מכמה כיסוי קרקע שיעורים אוֹ ערכות נושא . לאחר מכן ניתן להשתמש בנתונים מסווגים אלה לייצור מפות נושאיות מכיסוי הקרקע המצוי בתמונה.
כעת, בהתאם לאינטראקציה בין האנליטיקאי למחשב במהלך הסיווג, ישנם שני סוגים של סיווג:
- בפיקוח &
- לא מפוקח
לכן, מבלי לבזבז זמן בוא נקפוץ לסיווג התמונות של TensorFlow. יש לי 2 דוגמאות: קל וקשה. בואו נמשיך עם זה הקל.
כיצד להתקין Hadoop באובונטו
סיווג תמונות TensorFlow: MNIST אופנה
מערך נתונים MNIST אופנה
כאן נשתמש במערך הנתונים של Fashion MNIST, המכיל 70,000 תמונות בגווני אפור ב -10 קטגוריות. נשתמש ב- 60000 לאימונים ובשאר 10000 למטרות בדיקה. אתה יכול לגשת ל- MNIST האופנה ישירות מ- TensorFlow, פשוט לייבא ולהעמיס את הנתונים.
- בואו נייבא את הספריות תחילה
מ __future__ ייבוא מוחלט_יבוא, חלוקה, פונקצית הדפסה # TensorFlow ו- tf.keras מייבאים זרימת טנזור כמו tf מספריית יבוא טנסור זורם # ספריות עוזרות מייבאות נומפי כמו np ייבוא matplotlib.pyplot כ plt
- בואו נטען את הנתונים
fashion_mnist = keras.datasets.fashion_mnist (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data ()
- בשלב הבא אנו ממפים את התמונות לשיעורים
class_names = ['חולצת טריקו / עליונית', 'מכנסיים', 'סוודר', 'שמלה', 'מעיל', 'סנדל', 'חולצה', 'נעלי ספורט', 'תיק', 'מגף קרסול']
- חקר הנתונים
תמונות_ רכבת.צוּרָה
# כל תווית היא בין 0-9
תוויות רכבת
תמונות_מבחן.צוּרָה
- עכשיו, הגיע הזמן לעבד מראש את הנתונים.
plt.דמות() plt.imshow(תמונות_ רכבת[0]) plt.סרגל צבעים() plt.רֶשֶׁת(שֶׁקֶר) plt.הופעה()
#אם תבדוק את התמונה הראשונה בערכת האימונים, תראה שערכי הפיקסלים נופלים בטווח של 0 עד 255.
- עלינו לשנות את קנה המידה של התמונות מ -0-1 כדי להזין אותן ברשת העצבים
תמונות_ רכבת = תמונות_ רכבת / 255.0 תמונות_מבחן = תמונות_מבחן / 255.0
- בואו נציג כמה תמונות.
plt.דמות(גודל תאנים=(10,10))) ל אני ב טווח(25): plt.עלילת משנה(5,5,אני+אחד) plt.טיקים([]) plt.yticks([]) plt.רֶשֶׁת(שֶׁקֶר) plt.imshow(תמונות_ רכבת[אני], cmap=plt.ס'מ.בינארי) plt.תווית(שמות כיתות[תוויות רכבת[אני]]) plt.הופעה()
- הגדר את השכבות
דֶגֶם = קָשֶׁה.סִדרָתִי([ קָשֶׁה.שכבות.לְשַׁטֵחַ(קלט_צורה=(28, 28)), קָשֶׁה.שכבות.צָפוּף(128, הַפעָלָה=tf.מספרים.relu), קָשֶׁה.שכבות.צָפוּף(10, הַפעָלָה=tf.מספרים.softmax) ])
- הידר את המודל
דֶגֶם.לְלַקֵט(אופטימיזציה='אדם', הֶפסֵד='דלילה_קטגורית_קרוסנטרופיה', מדדים=['דיוק'])
- אימון מודלים
דֶגֶם.לְהַתְאִים(תמונות_ רכבת, תוויות רכבת, תקופות=10)
- הערכת דיוק
אובדן מבחן, test_acc = דֶגֶם.להעריך(תמונות_מבחן, תוויות מבחן) הדפס('דיוק הבדיקה:', test_acc)
- להכין תחזיות
תחזיות = דֶגֶם.לנבא(תמונות_מבחן)
תחזיות[0]
חיזוי הוא מערך של 10 מספרים. אלה מתארים את 'הביטחון' של המודל שהתמונה מתאימה לכל אחד מ -10 פריטי הלבוש השונים. אנו יכולים לראות לאיזה תווית יש ערך הביטחון הגבוה ביותר.
לְמָשָׁל.ארגמקס(תחזיות[0])#Model בטוח ביותר שמדובר במגפונים. בואו נראה אם זה נכוןתפוקה: 9
תוויות מבחן[0]
תפוקה: 9
- עכשיו, הגיע הזמן לבחון את מערך 10 הערוצים המלא
def תמונה_עלילה(אני, תחזיות_מערך, תווית אמיתית, img): תחזיות_מערך, תווית אמיתית, img = תחזיות_מערך[אני], תווית אמיתית[אני], img[אני] plt.רֶשֶׁת(שֶׁקֶר) plt.טיקים([]) plt.yticks([]) plt.imshow(img, cmap=plt.ס'מ.בינארי) תווית חזויה = לְמָשָׁל.ארגמקס(תחזיות_מערך) אם תווית חזויה == תווית אמיתית: צֶבַע = 'ירוק' אַחֵר: צֶבַע = 'נֶטוֹ' plt.תווית('{} {: 2.0f}% ({}) '.פוּרמָט(שמות כיתות[תווית חזויה], 100*לְמָשָׁל.מקסימום(תחזיות_מערך), שמות כיתות[תווית אמיתית]), צֶבַע=צֶבַע) def מערך_עלילה_מערך(אני, תחזיות_מערך, תווית אמיתית): תחזיות_מערך, תווית אמיתית = תחזיות_מערך[אני], תווית אמיתית[אני] plt.רֶשֶׁת(שֶׁקֶר) plt.טיקים([]) plt.yticks([]) עלילה זו = plt.בָּר(טווח(10), תחזיות_מערך, צֶבַע=# 777777) plt.ילים([0, אחד]) תווית חזויה = לְמָשָׁל.ארגמקס(תחזיות_מערך) עלילה זו[תווית חזויה].סט_צבע('נֶטוֹ') עלילה זו[תווית אמיתית].סט_צבע('ירוק')
- בואו נסתכל תחילה על התמונה ה -0 וה -10
אני = 0 plt.דמות(גודל תאנים=(6,3))) plt.עלילת משנה(אחד,2,אחד) תמונה_עלילה(אני, תחזיות, תוויות מבחן, תמונות_מבחן) plt.עלילת משנה(אחד,2,2) מערך_עלילה_מערך(אני, תחזיות, תוויות מבחן) plt.הופעה()
אני = 10 plt.דמות(גודל תאנים=(6,3))) plt.עלילת משנה(אחד,2,אחד) תמונה_עלילה(אני, תחזיות, תוויות מבחן, תמונות_מבחן) plt.עלילת משנה(אחד,2,2) מערך_עלילה_מערך(אני, תחזיות, תוויות מבחן) plt.הופעה()
- עכשיו, בואו נתווה כמה תמונות ותחזיות שלהם. נכונים הם ירוקים, ואילו שגויים הם אדומים.
מספר_שורות = 5 מספר_קולים = 3 מספר_תמונות = מספר_שורות*מספר_קולים plt.דמות(גודל תאנים=(2*2*מספר_קולים, 2*מספר_שורות))) ל אני ב טווח(מספר_תמונות): plt.עלילת משנה(מספר_שורות, 2*מספר_קולים, 2*אני+אחד) תמונה_עלילה(אני, תחזיות, תוויות מבחן, תמונות_מבחן) plt.עלילת משנה(מספר_שורות, 2*מספר_קולים, 2*אני+2) מערך_עלילה_מערך(אני, תחזיות, תוויות מבחן) plt.הופעה()
- לבסוף, נשתמש במודל המאומן כדי לחזות לגבי תמונה אחת.
# תפוס תמונה ממערך הבדיקה img = תמונות_מבחן[0] הדפס(img.צוּרָה)
# הוסף את התמונה לאצווה שבה הוא החבר היחיד. img = (לְמָשָׁל.הרחב את העמודים(img,0))) הדפס(img.צוּרָה)
חיזויים_ יחיד = דֶגֶם.לנבא(img) הדפס(חיזויים_ יחיד)מערך_עלילה_מערך(0, חיזויים_ יחיד, תוויות מבחן) plt.טיקים(טווח(10), שמות כיתות, רוֹטַציָה=ארבע חמש) plt.הופעה()
חיזוי_תוצאה = לְמָשָׁל.ארגמקס(חיזויים_ יחיד[0])
תפוקה: 9
CIFAR-10: CNN
מערך CIFAR-10 מורכב ממטוסים, כלבים, חתולים וחפצים אחרים. תוכלו לעבד מראש את התמונות, ואז לאמן רשת עצבית קונבולוציה על כל הדגימות. יש לנרמל את התמונות ולקודד את התוויות באופן חם. מקרה שימוש זה בוודאי יבהיר את ספקותיך לגבי TensorFlow Image Classification.
- הורדת הנתונים
מ urllib.request יְבוּא urlretrieve מ os.path יְבוּא isfile, הוא פיח מ tqdm יְבוּא tqdm יְבוּא tarfile cifar10_dataset_folder_path = 'cifar-10-batches-py' מעמד DownloadProgress(tqdm): last_block = 0 def וו(עצמי, block_num=אחד, גודל חסום=אחד, גודל כולל=אף אחד): עצמי.סה'כ = גודל כולל עצמי.עדכון((block_num - עצמי.last_block) * גודל חסום) עצמי.last_block = block_num '' ' בדוק אם קובץ הנתונים (zip) כבר הורד אם לא, הורד אותו מ- https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz ושמור כ- cifar-10-python.tar.gz '' ' אם לֹא isfile('cifar-10-python.tar.gz'): עם DownloadProgress(יחידה='ב', יחידה_סולם=נָכוֹן, מיניטרים=אחד, ירידה='מערך נתונים CIFAR-10') כפי ש pbar: urlretrieve( 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz', 'cifar-10-python.tar.gz', pbar.וו) אם לֹא הוא פיח(cifar10_dataset_folder_path): עם tarfile.לִפְתוֹחַ('cifar-10-python.tar.gz') כפי ש זֶפֶת: זֶפֶת.חלץ הכל() זֶפֶת.סגור()
- ייבוא ספריות הכרחיות
יְבוּא מלפפון חמוץ יְבוּא קהה כפי ש לְמָשָׁל יְבוּא matplotlib.pyplot כפי ש plt
- הבנת הנתונים
אצוות הנתונים המקורית היא 10000 × 3072 טנסור המתבטא במערך קהה, כאשר 10000 הוא מספר נתוני המדגם. התמונה צבעונית ובגודל 32 × 32. האכלה יכולה להיעשות בפורמט של (רוחב x גובה x מספר_ערוץ) או (מספר_ערוץ x רוחב x גובה). בואו נגדיר את התוויות.
def שמות תוויות_טעינה(): לַחֲזוֹר ['מטוס', 'מְכוֹנִית', 'ציפור', 'חתול', 'צְבִי', 'כֶּלֶב', 'צְפַרְדֵעַ', 'סוּס', 'ספינה', 'מַשָׂאִית']
- עיצוב מחדש של הנתונים
אנו הולכים לעצב מחדש את הנתונים בשני שלבים
ראשית, חלק את וקטור השורה (3072) לשלוש חלקים. כל קטע מתאים לכל ערוץ. התוצאה היא (3 x 1024) ממד של טנסור. ואז חלק את הטנסור שנוצר מהשלב הקודם עם 32. 32 כאן פירושו רוחב התמונה. התוצאה היא (3x32x32).
מחרוזת java להמרה עד כה
שנית, עלינו להעביר את הנתונים מ (מספר_ערוץ, רוחב, גובה) ל (רוחב, גובה, מספר_ערוץ). לשם כך אנו נשתמש בפונקציית השינוי.
def load_cfar10_batch(cifar10_dataset_folder_path, batch_id): עם לִפְתוֹחַ(cifar10_dataset_folder_path + '/ data_batch_' + עמ '(batch_id), מצב='rb') כפי ש קוֹבֶץ: שים לב שסוג הקידוד הוא 'latin1' קבוצה = מלפפון חמוץ.לִטעוֹן(קוֹבֶץ, הַצפָּנָה='latin1') תכונות = קבוצה['נתונים'].שִׁנוּי צוּרָה((len(קבוצה['נתונים']), 3, 32, 32))).לְשַׁרבֵּב(0, 2, 3, אחד) תוויות = קבוצה['תוויות'] לַחֲזוֹר תכונות, תווית
- חקר הנתונים
def סטטיסטיקות תצוגה(cifar10_dataset_folder_path, batch_id, sample_id): תכונות, תוויות = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) אם לֹא (0 <= sample_id < len(תכונות)): הדפס('{}דגימות באצווה{}.{}הוא מחוץ לטווח. '.פוּרמָט(len(תכונות), batch_id, sample_id))) לַחֲזוֹר אף אחד הדפס(' נתונים סטטיסטיים של אצווה מספר{}: '.פוּרמָט(batch_id))) הדפס(מספר דוגמאות:{} '.פוּרמָט(len(תכונות))) תוויות_שמות = שמות תוויות_טעינה() תווית_ספירות = להכתיב(רוכסן(*לְמָשָׁל.ייחודי(תוויות, return_counts=נָכוֹן))) ל מַפְתֵחַ, ערך ב תווית_ספירות.פריטים(): הדפס('ספירת תוויות של [{}] ({}):{}'.פוּרמָט(מַפְתֵחַ, תוויות_שמות[מַפְתֵחַ].עֶלִיוֹן(), ערך))) תמונה_דוגמה = תכונות[sample_id] תווית מדגם = תוויות[sample_id] הדפס(' דוגמה לתמונה{}: '.פוּרמָט(sample_id))) הדפס(תמונה - ערך מינימלי:{}ערך מקסימלי:{}'.פוּרמָט(תמונה_דוגמה.דקה(), תמונה_דוגמה.מקסימום())) הדפס(תמונה - צורה:{}'.פוּרמָט(תמונה_דוגמה.צוּרָה))) הדפס('תווית - מזהה תווית:{}שֵׁם:{}'.פוּרמָט(תווית מדגם, תוויות_שמות[תווית מדגם])) plt.imshow(תמונה_דוגמה)
%matplotlib בשורה %config InlineBackend.פורמט דמות_ = 'רִשׁתִית' יְבוּא קהה כפי ש לְמָשָׁל # חקור את מערך הנתונים batch_id = 3 sample_id = 7000 סטטיסטיקות תצוגה(cifar10_dataset_folder_path, batch_id, sample_id)
- יישום פונקציות עיבוד מקדים
אנו הולכים לנרמל את הנתונים באמצעות מינימום מקסימום נורמליזציה. זה פשוט גורם לכל ערכי ה- x לנוע בין 0 ל -1.
y = (x-min) / (max-min)
def לנרמל(איקס): '' ' טַעֲנָה - x: קלט נתוני תמונה במערך קהה [32, 32, 3] לַחֲזוֹר - מנורמל x '' ' min_val = לְמָשָׁל.דקה(איקס) max_val = לְמָשָׁל.מקסימום(איקס) איקס = (איקס-min_val) / (max_val-min_val) לַחֲזוֹר איקס
- קידוד אחד חם
def one_hot_encode(איקס): '' ' טַעֲנָה - x: רשימת תוויות לַחֲזוֹר - מטריצת קידוד חמה אחת (מספר תוויות, מספר מחלקה) '' ' מוּצפָּן = לְמָשָׁל.אפסים((len(איקס), 10))) ל idx, שעות ב לִמְנוֹת(איקס): מוּצפָּן[idx] [שעות] = אחד לַחֲזוֹר מוּצפָּן
- עיבוד מראש ושמור את הנתונים
def _ עיבוד מקדים_ ושמירה(לנרמל, one_hot_encode, תכונות, תוויות, שם קובץ): תכונות = לנרמל(תכונות) תוויות = one_hot_encode(תוויות) מלפפון חמוץ.מזבלה((תכונות, תוויות), לִפְתוֹחַ(שם קובץ, 'wb'))) def עיבוד מראש של נתונים ושמירה(cifar10_dataset_folder_path, לנרמל, one_hot_encode): n_batches = 5 תכונות תקפות = [] תוויות תקפות = [] ל אצווה_י ב טווח(אחד, n_batches + אחד): תכונות, תוויות = load_cfar10_batch(cifar10_dataset_folder_path, אצווה_י) # מצא אינדקס כדי להיות הנקודה כנתוני אימות בכל מערך הנתונים של האצווה (10%) אינדקס_אימות = int(len(תכונות) * 0.1) # עיבוד מראש של 90% מכל מערך הנתונים של האצווה # - לנרמל את התכונות # - אחד_חיים_צפין את האילנות # - שמור בקובץ חדש בשם 'preprocess_batch_' + batch_number # - כל קובץ עבור כל אצווה _ עיבוד מקדים_ ושמירה(לנרמל, one_hot_encode, תכונות[:-אינדקס_אימות], תוויות[:-אינדקס_אימות], 'preprocess_batch_' + עמ '(אצווה_י) + '.p') # שלא כמו מערך האימונים, מערך האימות יתווסף דרך כל מערך האצווה # - קח 10% ממערך הנתונים המלא של האצווה # - הוסף אותם לרשימה של # - תכונות תקפות # - תוויות תקפות תכונות תקפות.לְהַאֲרִיך(תכונות[-אינדקס_אימות:]) תוויות תקפות.לְהַאֲרִיך(תוויות[-אינדקס_אימות:]) # עיבוד מראש של כל מערך האימות שנערם _ עיבוד מקדים_ ושמירה(לנרמל, one_hot_encode, לְמָשָׁל.מַעֲרָך(תכונות תקפות), לְמָשָׁל.מַעֲרָך(תוויות תקפות), 'preprocess_validation.p') # טען את מערך הבדיקה עם לִפְתוֹחַ(cifar10_dataset_folder_path + '/ test_batch', מצב='rb') כפי ש קוֹבֶץ: קבוצה = מלפפון חמוץ.לִטעוֹן(קוֹבֶץ, הַצפָּנָה='latin1') # עיבוד מראש של נתוני הבדיקה תכונות הבדיקה = קבוצה['נתונים'].שִׁנוּי צוּרָה((len(קבוצה['נתונים']), 3, 32, 32))).לְשַׁרבֵּב(0, 2, 3, אחד) תוויות מבחן = קבוצה['תוויות'] # עיבוד מראש ושמור את כל נתוני הבדיקה _ עיבוד מקדים_ ושמירה(לנרמל, one_hot_encode, לְמָשָׁל.מַעֲרָך(תכונות הבדיקה), לְמָשָׁל.מַעֲרָך(תוויות מבחן), 'preprocess_training.p')
עיבוד מראש של נתונים ושמירה(cifar10_dataset_folder_path, לנרמל, one_hot_encode)
- מחסום
יְבוּא מלפפון חמוץ תכונות תקפות, תוויות תקפות = מלפפון חמוץ.לִטעוֹן(לִפְתוֹחַ('preprocess_validation.p', מצב='rb')))
- בניית הרשת
הדגם כולו מורכב מ -14 שכבות בסך הכל.
יְבוּא זורם טנסור כפי ש tf def conv_net(איקס, keep_prob): מסנן 1 = tf.מִשְׁתַנֶה(tf.קטוע_נורמלי(צוּרָה=[3, 3, 3, 64], מתכוון=0, stddev=0.08))) מסנן conv2_ = tf.מִשְׁתַנֶה(tf.קטוע_נורמלי(צוּרָה=[3, 3, 64, 128], מתכוון=0, stddev=0.08))) מסנן_3 = tf.מִשְׁתַנֶה(tf.קטוע_נורמלי(צוּרָה=[5, 5, 128, 256], מתכוון=0, stddev=0.08))) conv4_filter = tf.מִשְׁתַנֶה(tf.קטוע_נורמלי(צוּרָה=[5, 5, 256, 512], מתכוון=0, stddev=0.08))) # 1, 2 conv1 = tf.מספרים.conv2d(איקס, מסנן 1, צעדים=[אחד,אחד,אחד,אחד], ריפוד='אותו') conv1 = tf.מספרים.relu(conv1) conv1_pool = tf.מספרים.max_pool(conv1, גודל=[אחד,2,2,אחד], צעדים=[אחד,2,2,אחד], ריפוד='אותו') conv1_bn = tf.שכבות.אצווה-נורמליזציה(conv1_pool) # 3. 4 conv2 = tf.מספרים.conv2d(conv1_bn, מסנן conv2_, צעדים=[אחד,אחד,אחד,אחד], ריפוד='אותו') conv2 = tf.מספרים.relu(conv2) conv2_pool = tf.מספרים.max_pool(conv2, גודל=[אחד,2,2,אחד], צעדים=[אחד,2,2,אחד], ריפוד='אותו') conv2_bn = tf.שכבות.אצווה-נורמליזציה(conv2_pool) # 5, 6 conv3 = tf.מספרים.conv2d(conv2_bn, מסנן_3, צעדים=[אחד,אחד,אחד,אחד], ריפוד='אותו') conv3 = tf.מספרים.relu(conv3) conv3_pool = tf.מספרים.max_pool(conv3, גודל=[אחד,2,2,אחד], צעדים=[אחד,2,2,אחד], ריפוד='אותו') conv3_bn = tf.שכבות.אצווה-נורמליזציה(conv3_pool) # 7, 8 conv4 = tf.מספרים.conv2d(conv3_bn, conv4_filter, צעדים=[אחד,אחד,אחד,אחד], ריפוד='אותו') conv4 = tf.מספרים.relu(conv4) conv4_pool = tf.מספרים.max_pool(conv4, גודל=[אחד,2,2,אחד], צעדים=[אחד,2,2,אחד], ריפוד='אותו') conv4_bn = tf.שכבות.אצווה-נורמליזציה(conv4_pool) # 9 שָׁטוּחַ = tf.תורם.שכבות.לְשַׁטֵחַ(conv4_bn) # 10 מלא 1 = tf.תורם.שכבות.מחובר באופן מלא(תשומות=שָׁטוּחַ, מספר_פלטים=128, הפעלה_פן=tf.מספרים.relu) מלא 1 = tf.מספרים.נשר(מלא 1, keep_prob) מלא 1 = tf.שכבות.אצווה-נורמליזציה(מלא 1) # אחת עשרה מלא 2 = tf.תורם.שכבות.מחובר באופן מלא(תשומות=מלא 1, מספר_פלטים=256, הפעלה_פן=tf.מספרים.relu) מלא 2 = tf.מספרים.נשר(מלא 2, keep_prob) מלא 2 = tf.שכבות.אצווה-נורמליזציה(מלא 2) # 12 מלא 3 = tf.תורם.שכבות.מחובר באופן מלא(תשומות=מלא 2, מספר_פלטים=512, הפעלה_פן=tf.מספרים.relu) מלא 3 = tf.מספרים.נשר(מלא 3, keep_prob) מלא 3 = tf.שכבות.אצווה-נורמליזציה(מלא 3) # 13 מלא 4 = tf.תורם.שכבות.מחובר באופן מלא(תשומות=מלא 3, מספר_פלטים=1024, הפעלה_פן=tf.מספרים.relu) מלא 4 = tf.מספרים.נשר(מלא 4, keep_prob) מלא 4 = tf.שכבות.אצווה-נורמליזציה(מלא 4) # 14 הַחוּצָה = tf.תורם.שכבות.מחובר באופן מלא(תשומות=מלא 3, מספר_פלטים=10, הפעלה_פן=אף אחד) לַחֲזוֹר הַחוּצָה
- היפרפרמטרים
תקופות = 10 גודל_ אצווה = 128 שומר_הסתברות = 0.7 שיעור_למידה = 0.001
logits = conv_net(איקס, keep_prob) דֶגֶם = tf.זהות(logits, שֵׁם='logits') # שם מתחבר ל Tensor, כך שניתן לטעון אותו מהדיסק לאחר האימון # הפסד ומיטוב עֲלוּת = tf.להפחית את האמצעי(tf.מספרים.softmax_cross_entropy_with_logits(logits=logits, תוויות=י))) אופטימיזציה = tf.רכבת.AdamOptimizer(שיעור_למידה=שיעור_למידה).לְצַמְצֵם(עֲלוּת) # דיוק correct_pred = tf.שווה(tf.ארגמקס(logits, אחד), tf.ארגמקס(י, אחד))) דיוק = tf.להפחית את האמצעי(tf.ללהק(correct_pred, tf.32), שֵׁם='דיוק')
- הכשר את הרשת העצבית
# מיטוב יחיד
def רכבת_עצבית_רכבת(מוֹשָׁב, אופטימיזציה, שומר_הסתברות, feature_batch, label_batch): מוֹשָׁב.לָרוּץ(אופטימיזציה, הזנת_הוראה={ איקס: feature_batch, י: label_batch, keep_prob: שומר_הסתברות })
# הצגת סטטיסטיקה Def סטטיסטיקות הדפסה(מוֹשָׁב, feature_batch, label_batch, עֲלוּת, דיוק): הֶפסֵד = סס.לָרוּץ(עֲלוּת, הזנת_הוראה={ איקס: feature_batch, י: label_batch, keep_prob: אחד. }) valid_acc = סס.לָרוּץ(דיוק, הזנת_הוראה={ איקס: תכונות תקפות, י: תוויות תקפות, keep_prob: אחד. }) הדפס('הֶפסֵד:{:> 10.4f}דיוק אימות:{: .6f}'.פוּרמָט(הֶפסֵד, valid_acc)))
- אימון מלא ושמירת המודל
def אצוות_תכונות_תוויות(תכונות, תוויות, גודל_ אצווה): '' ' פיצול תכונות ותוויות לקבוצות '' ' ל הַתחָלָה ב טווח(0, len(תכונות), גודל_ אצווה): סוֹף = דקה(הַתחָלָה + גודל_ אצווה, len(תכונות))) תְשׁוּאָה תכונות[הַתחָלָה:סוֹף], תוויות[הַתחָלָה:סוֹף] def load_preprocess_training_batch(batch_id, גודל_ אצווה): '' ' טען את נתוני האימון שעובד מראש והחזיר אותם בקבוצות או פחות '' ' שם קובץ = 'preprocess_batch_' + עמ '(batch_id) + '.p' תכונות, תוויות = מלפפון חמוץ.לִטעוֹן(לִפְתוֹחַ(שם קובץ, מצב='rb'))) # החזר את נתוני האימון בקבוצות גודל או פחות לַחֲזוֹר אצוות_תכונות_תוויות(תכונות, תוויות, גודל_ אצווה)
# שמירת דגם ונתיב
שמור_מודל_נתיב = './image_classification' הדפס('הַדְרָכָה...') עם tf.מוֹשָׁב() כפי ש סס: # אתחול המשתנים סס.לָרוּץ(tf.global_variables_initializer()) # מחזור אימונים ל תְקוּפָה ב טווח(תקופות): # לולאה על כל האצוות n_batches = 5 ל אצווה_י ב טווח(אחד, n_batches + אחד): ל תכונות אצווה, אצוות_תוויות ב load_preprocess_training_batch(אצווה_י, גודל_ אצווה): רכבת_עצבית_רכבת(סס, אופטימיזציה, שומר_הסתברות, תכונות אצווה, אצוות_תוויות) הדפס('תְקוּפָה{:> 2}, אצווה CIFAR-10{}: '.פוּרמָט(תְקוּפָה + אחד, אצווה_י), סוֹף='') סטטיסטיקות הדפסה(סס, תכונות אצווה, אצוות_תוויות, עֲלוּת, דיוק) # שמור דגם מַצִיל = tf.רכבת.מַצִיל() שמור_נתיב = מַצִיל.לשמור(סס, שמור_מודל_נתיב)
כעת, החלק החשוב בסיווג תמונות Tensorflow נעשה. עכשיו, הגיע הזמן לבדוק את המודל.
- בדיקת המודל
יְבוּא מלפפון חמוץ יְבוּא קהה כפי ש לְמָשָׁל יְבוּא matplotlib.pyplot כפי ש plt מ sklearn.precessing יְבוּא LabelBinarizer def אצוות_תכונות_תוויות(תכונות, תוויות, גודל_ אצווה): '' ' פיצול תכונות ותוויות לקבוצות '' ' ל הַתחָלָה ב טווח(0, len(תכונות), גודל_ אצווה): סוֹף = דקה(הַתחָלָה + גודל_ אצווה, len(תכונות))) תְשׁוּאָה תכונות[הַתחָלָה:סוֹף], תוויות[הַתחָלָה:סוֹף] def חיזוי תצוגת תמונה(תכונות, תוויות, תחזיות, חיזויים עליונים): n_classes = 10 תוויות_שמות = שמות תוויות_טעינה() label_binarizer = LabelBinarizer() label_binarizer.לְהַתְאִים(טווח(n_classes))) label_ids = label_binarizer.הפוך_הופעה(לְמָשָׁל.מַעֲרָך(תוויות))) תאנה, צירים = plt.עלילות משנה(מצמידים=חיזויים עליונים, ncols=2, גודל תאנים=(עשרים, 10))) תאנה.פריסה הדוקה() תאנה.סופיטל('תחזיות Softmax', גודל גופן=עשרים, י=1.1) חיזויים n = 3 שולים = 0.05 ind = לְמָשָׁל.מסודר(חיזויים n) רוֹחַב = (אחד. - 2. * שולים) / חיזויים n ל image_i, (תכונה, label_id, pred_indicies, ערכים קודמים) ב לִמְנוֹת(רוכסן(תכונות, label_ids, תחזיות.מדדים, תחזיות.ערכים)): אם (image_i < חיזויים עליונים): שמות מקדימים = [תוויות_שמות[pred_i] ל pred_i ב pred_indicies] השם הנכון = תוויות_שמות[label_id] צירים[image_i] [0].imshow((תכונה*255).astype(לְמָשָׁל.int32, עותק=שֶׁקֶר))) צירים[image_i] [0].set_title(השם הנכון) צירים[image_i] [0].set_axis_off() צירים[image_i] [אחד].בארה(ind + שולים, ערכים קודמים[:3], רוֹחַב) צירים[image_i] [אחד].set_yticks(ind + שולים) צירים[image_i] [אחד].set_yticklabels(שמות מקדימים[::-אחד]) צירים[image_i] [אחד].set_xticks([0, 0.5, 1.0])
%matplotlib בשורה %config InlineBackend.פורמט דמות_ = 'רִשׁתִית' יְבוּא זורם טנסור כפי ש tf יְבוּא מלפפון חמוץ יְבוּא אַקרַאִי שמור_מודל_נתיב = './image_classification' גודל_ אצווה = 64 דוגמאות n = 10 חיזויים עליונים = 5 def מודל מבחן(): תכונות הבדיקה, תוויות מבחן = מלפפון חמוץ.לִטעוֹן(לִפְתוֹחַ('preprocess_training.p', מצב='rb'))) נטען_גרף = tf.גרָף() עם tf.מוֹשָׁב(גרָף=נטען_גרף) כפי ש סס: # מודל עומס מטעין = tf.רכבת.import_meta_graph(שמור_מודל_נתיב + '.מטה') מטעין.לשחזר(סס, שמור_מודל_נתיב) # קבל טנסורים ממודל טעון נטען_x = נטען_גרף.get_tensor_by_name('input_x: 0') טעון_י = נטען_גרף.get_tensor_by_name('output_y: 0') טעון_החזקה_מבחן = נטען_גרף.get_tensor_by_name('keep_prob: 0') טעון_תחברות = נטען_גרף.get_tensor_by_name('logits: 0') load_acc = נטען_גרף.get_tensor_by_name('דיוק: 0') # קבל דיוק בקבוצות למגבלות זיכרון test_batch_acc_total = 0 test_batch_count = 0 ל רכבת_מאפיין_אצווה, רכבת_תווית ב אצוות_תכונות_תוויות(תכונות הבדיקה, תוויות מבחן, גודל_ אצווה): test_batch_acc_total + = סס.לָרוּץ( load_acc, הזנת_הוראה={נטען_x: רכבת_מאפיין_אצווה, טעון_י: רכבת_תווית, טעון_אחיזה_מבח: 1.0}) test_batch_count + = אחד הדפס('בדיקת דיוק:{} '.פוּרמָט(test_batch_acc_total/test_batch_count))) # הדפס דוגמאות אקראיות תכונות_בדיקות_אקראיות, תוויות_אופן אקראי = כפולה(רוכסן(*אַקרַאִי.לִטעוֹם(רשימה(רוכסן(תכונות הבדיקה, תוויות מבחן)), דוגמאות n))) תחזיות_בדיקות_אקראי = סס.לָרוּץ( tf.מספרים.top_k(tf.מספרים.softmax(טעון_תחברות), חיזויים עליונים), הזנת_הוראה={נטען_x: תכונות_בדיקות_אקראיות, טעון_י: תוויות_אופן אקראי, טעון_החזקה_מבחן: 1.0}) חיזוי תצוגת תמונה(תכונות_בדיקות_אקראיות, תוויות_אופן אקראי, תחזיות_בדיקות_אקראי, חיזויים עליונים) מודל מבחן()
תְפוּקָה: בדיקת דיוק: 0.5882762738853503
כעת, אם אתה מאמן את הרשת העצבית שלך לעוד תקופות או משנה את פונקציית ההפעלה, ייתכן שתקבל תוצאה אחרת שעשויה להיות בעלת דיוק טוב יותר.
אז, עם זה, אנו מגיעים לסוף מאמר זה של סיווג תמונות TensorFlow. אני בטוח שעכשיו אתה יכול להשתמש בו כדי לסווג כל סוג של תמונות ואינך מתחיל לסיווג תמונות.
אדוריקה עם אימון הסמכת Python אוצר על ידי אנשי מקצוע בתעשייה בהתאם לדרישות ולדרישות בתעשייה. תוכלו לשלוט במושגים כגון פונקצית SoftMax, Autoencoder Neural Networks, Restricted Boltzmann Machine (RBM), Keras & TFLearn. הקורס אוצר במיוחד על ידי מומחים בתעשייה עם מחקרי מקרה בזמן אמת.