דף זה תורגם על ידי Cloud Translation API.

Switch to English

סיווג בסיסי: סיווג תמונות של בגדים

צפה ב- TensorFlow.org

הפעל בגוגל קולאב

צפה במקור ב- GitHub

הורד מחברת

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

מדריך זה משתמש ב- tf.keras , ממשק API ברמה גבוהה לבניית והכשרת דגמים ב- TensorFlow.

# TensorFlow and tf.keras
import tensorflow as tf

# Helper libraries
import numpy as np
import matplotlib.pyplot as plt

print(tf.__version__)

2.4.1

ייבא את מערך האופנה MNIST

מדריך זה משתמש במערך הנתונים של Fashion MNIST המכיל 70,000 תמונות בגווני אפור ב -10 קטגוריות. בתמונות נראים פריטי לבוש בודדים ברזולוציה נמוכה (28 על 28 פיקסלים), כפי שנראה כאן:

איור 1. דוגמאות אופנה-MNIST (מאת זלנדו, רישיון MIT).

אופנה MNIST מיועדת כתחליף למערך הנתונים הקלאסי של MNIST - המשמש לעתים קרובות "שלום, עולם" של תוכניות למידת מכונה לראיית מחשב. מערך הנתונים MNIST מכיל תמונות של ספרות בכתב יד (0, 1, 2 וכו ') בפורמט זהה לזה של פריטי הלבוש שתשתמשו כאן.

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

כאן, 60,000 תמונות משמשות להכשרת הרשת ו -10,000 תמונות להערכת מידת הדיוק של הרשת לסווג תמונות. אתה יכול לגשת ל- MNIST האופנה ישירות מ- TensorFlow. ייבא וטען את נתוני האופנה MNIST ישירות מ- TensorFlow:

fashion_mnist = tf.keras.datasets.fashion_mnist

(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()

Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz
32768/29515 [=================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz
26427392/26421880 [==============================] - 1s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz
8192/5148 [===============================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz
4423680/4422102 [==============================] - 0s 0us/step

טעינת מערך הנתונים מחזירה ארבעה מערכי NumPy:

train_images ו train_labels המערכים הם האימונים להגדיר נתוני -The שימושי המודל ללמוד.
המודל נבדק על פי מערך הבדיקה , test_images test_labels .

התמונות הן מערכי 28x28 NumPy, עם ערכי פיקסלים שנעים בין 0 ל 255. התוויות הן מערך של מספרים שלמים, שנעים בין 0 ל 9. אלה תואמים לסוג הלבוש שהתמונה מייצגת:

תווית	מעמד
0	חולצה / עליונית
1	מכנסיים
2	תעצור בצד
3	שמלה
4	מעיל
5	סַנְדָל
6	חוּלצָה
7	נַעַל הִתעַמְלוּת
8	תיק
9	מגף קרסול

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

class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

חקור את הנתונים

בואו נבדוק את פורמט מערך הנתונים לפני אימון המודל. הבא מציג שיש בערכת האימונים 60,000 תמונות, כאשר כל תמונה מיוצגת כ- 28 x 28 פיקסלים:

train_images.shape

(60000, 28, 28)

כמו כן, יש בערכת ההדרכה 60,000 תוויות:

len(train_labels)

כל תווית היא מספר שלם בין 0 ל -9:

train_labels

array([9, 0, 0, ..., 3, 0, 5], dtype=uint8)

בערכת הבדיקה יש 10,000 תמונות. שוב, כל תמונה מיוצגת כ- 28 x 28 פיקסלים:

test_images.shape

(10000, 28, 28)

ומערכת הבדיקות מכילה 10,000 תוויות תמונות:

len(test_labels)

עיבד את הנתונים מראש

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

plt.figure()
plt.imshow(train_images[0])
plt.colorbar()
plt.grid(False)
plt.show()

png

קנה מידה של ערכים אלה לטווח של 0 עד 1 לפני הזנתם למודל הרשת העצבית. לשם כך, חלק את הערכים ב- 255. חשוב שמערך האימונים ומערכת הבדיקות יעובדו באותו אופן:

train_images = train_images / 255.0

test_images = test_images / 255.0

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

plt.figure(figsize=(10,10))
for i in range(25):
    plt.subplot(5,5,i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(train_images[i], cmap=plt.cm.binary)
    plt.xlabel(class_names[train_labels[i]])
plt.show()

png

בנה את המודל

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

הגדר את השכבות

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

רוב הלמידה העמוקה מורכבת משרשור רבדים פשוטים. ברוב השכבות, כמו tf.keras.layers.Dense , יש פרמטרים שנלמדים במהלך האימון.

model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(10)
])

השכבה הראשונה ברשת זו, tf.keras.layers.Flatten , הופכת את הפורמט של התמונות ממערך דו מימדי (של 28 על 28 פיקסלים) למערך חד ממדי (של 28 * 28 = 784 פיקסלים). חשוב על שכבה זו כשחרור שורות של פיקסלים בתמונה ומיישר אותם. לשכבה זו אין פרמטרים ללמוד; זה רק מעצב מחדש את הנתונים.

לאחר פיקסלים שטוחים, הרשת מורכבת מרצף של שתי שכבות tf.keras.layers.Dense . אלה הם שכבות עצביות מחוברות בצפיפות, או מחוברות לחלוטין. בשכבה Dense הראשונה יש 128 צמתים (או נוירונים). השכבה השנייה (והאחרונה) מחזירה מערך logits באורך 10. כל צומת מכיל ציון המציין שהתמונה הנוכחית שייכת לאחת מ -10 המחלקות.

הידר את המודל

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

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

model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

תאמן את המודל

הכשרת מודל הרשת העצבית דורשת את השלבים הבאים:

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

הזן את הדגם

כדי להתחיל באימון, התקשר לשיטת model.fit - מה שנקרא מכיוון שהיא "מתאימה" את המודל לנתוני האימון:

model.fit(train_images, train_labels, epochs=10)

Epoch 1/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.6278 - accuracy: 0.7812
Epoch 2/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.3862 - accuracy: 0.8595
Epoch 3/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.3487 - accuracy: 0.8720
Epoch 4/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.3150 - accuracy: 0.8836
Epoch 5/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2983 - accuracy: 0.8906
Epoch 6/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2813 - accuracy: 0.8975
Epoch 7/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2658 - accuracy: 0.9008
Epoch 8/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2567 - accuracy: 0.9059
Epoch 9/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2385 - accuracy: 0.9096
Epoch 10/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2367 - accuracy: 0.9108
<tensorflow.python.keras.callbacks.History at 0x7f9de07cb0b8>

כאשר המודל מתאמן, מדדי האובדן והדיוק מוצגים. מודל זה מגיע לדיוק של כ- 0.91 (או 91%) בנתוני האימון.

הערך דיוק

לאחר מכן, השווה את ביצועי המודל במערך הבדיקה:

test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)

print('\nTest accuracy:', test_acc)

313/313 - 0s - loss: 0.3547 - accuracy: 0.8761

Test accuracy: 0.8761000037193298

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

לעשות תחזיות

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

probability_model = tf.keras.Sequential([model, 
                                         tf.keras.layers.Softmax()])

predictions = probability_model.predict(test_images)

הנה, המודל חזה את התווית עבור כל תמונה בערכת הבדיקות. בואו נסתכל על התחזית הראשונה:

predictions[0]

array([1.2012765e-07, 5.3020085e-11, 3.2435774e-10, 6.8114465e-11,
       8.4152178e-11, 8.6389598e-05, 2.2522106e-09, 1.4491959e-03,
       4.0859813e-09, 9.9846435e-01], dtype=float32)

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

np.argmax(predictions[0])

לכן, המודל בטוח ביותר שתמונה זו היא מגף קרסול, או class_names[9] . בחינת תווית הבדיקה מראה כי סיווג זה נכון:

test_labels[0]

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

def plot_image(i, predictions_array, true_label, img):
  true_label, img = true_label[i], img[i]
  plt.grid(False)
  plt.xticks([])
  plt.yticks([])

  plt.imshow(img, cmap=plt.cm.binary)

  predicted_label = np.argmax(predictions_array)
  if predicted_label == true_label:
    color = 'blue'
  else:
    color = 'red'

  plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],
                                100*np.max(predictions_array),
                                class_names[true_label]),
                                color=color)

def plot_value_array(i, predictions_array, true_label):
  true_label = true_label[i]
  plt.grid(False)
  plt.xticks(range(10))
  plt.yticks([])
  thisplot = plt.bar(range(10), predictions_array, color="#777777")
  plt.ylim([0, 1])
  predicted_label = np.argmax(predictions_array)

  thisplot[predicted_label].set_color('red')
  thisplot[true_label].set_color('blue')

אמת תחזיות

בעזרת המודל המאומן תוכלו להשתמש בו לחיזוי תמונות מסוימות.

בואו נסתכל על התמונה 0, התחזיות ומערך החיזוי. תוויות חיזוי נכונות הן כחולות ותווי חיזוי שגויים אדומים. המספר נותן את האחוז (מתוך 100) עבור התווית החזויה.

i = 0
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions[i], test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions[i],  test_labels)
plt.show()

png

i = 12
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions[i], test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions[i],  test_labels)
plt.show()

png

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

# Plot the first X test images, their predicted labels, and the true labels.
# Color correct predictions in blue and incorrect predictions in red.
num_rows = 5
num_cols = 3
num_images = num_rows*num_cols
plt.figure(figsize=(2*2*num_cols, 2*num_rows))
for i in range(num_images):
  plt.subplot(num_rows, 2*num_cols, 2*i+1)
  plot_image(i, predictions[i], test_labels, test_images)
  plt.subplot(num_rows, 2*num_cols, 2*i+2)
  plot_value_array(i, predictions[i], test_labels)
plt.tight_layout()
plt.show()

png

השתמש במודל המאומן

לסיום, השתמש במודל המאומן בכדי לחזות תמונה אחת.

# Grab an image from the test dataset.
img = test_images[1]

print(img.shape)

(28, 28)

מודלים של tf.keras מותאמים לחיזוי על דוגמאות אצווה או אוסף בו זמנית. בהתאם לכך, למרות שאתה משתמש בתמונה אחת, עליך להוסיף אותה לרשימה:

# Add the image to a batch where it's the only member.
img = (np.expand_dims(img,0))

print(img.shape)

(1, 28, 28)

כעת צפו את התווית הנכונה לתמונה זו:

predictions_single = probability_model.predict(img)

print(predictions_single)

[[5.9622369e-04 4.4912915e-12 9.9706572e-01 3.1242684e-09 1.1509876e-03
  4.7866642e-13 1.1870833e-03 3.2586661e-17 1.0648579e-09 1.5709595e-13]]

plot_value_array(1, predictions_single[0], test_labels)
_ = plt.xticks(range(10), class_names, rotation=45)

png

tf.keras.Model.predict מחזירה רשימה של רשימות - רשימה אחת לכל תמונה באוסף הנתונים. קח את התחזיות עבור התמונה (היחידה) שלנו באצווה:

np.argmax(predictions_single[0])

והמודל מנבא תווית כצפוי.

# MIT License
#
# Copyright (c) 2017 François Chollet
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.