หน้านี้ได้รับการแปลโดย Cloud Translation API
Switch to English

การจำแนกขั้นพื้นฐาน: จำแนกรูปภาพของเสื้อผ้า

ดูใน TensorFlow.org เรียกใช้ใน Google Colab ดูแหล่งที่มาบน GitHub ดาวน์โหลดสมุดบันทึก

คู่มือนี้ฝึกโมเดลโครงข่ายประสาทเทียมเพื่อจำแนกรูปภาพของเสื้อผ้าเช่นรองเท้าผ้าใบและเสื้อเชิ้ต ไม่เป็นไรหากคุณไม่เข้าใจรายละเอียดทั้งหมด นี่คือภาพรวมที่รวดเร็วของโปรแกรม TensorFlow ที่สมบูรณ์พร้อมรายละเอียดที่อธิบายในขณะที่คุณไป

คู่มือนี้ใช้ tf.keras ซึ่งเป็น API ระดับสูงในการสร้างและฝึกโมเดลใน TensorFlow

# TensorFlow and tf.keras
import tensorflow as tf
from tensorflow import keras

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

print(tf.__version__)
2.3.0

นำเข้าชุดข้อมูล Fashion MNIST

fashion_mnist = keras.datasets.fashion_mnist

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

การโหลดชุดข้อมูลจะส่งคืนอาร์เรย์ NumPy สี่อาร์เรย์:

  • train_images และ train_labels อาร์เรย์มีการฝึกอบรมตั้งค่าข้อมูล -The ใช้รูปแบบการเรียนรู้
  • รูปแบบการทดสอบกับชุดทดสอบที่ test_images และ test_labels อาร์เรย์

รูปภาพเป็นอาร์เรย์ NumPy ขนาด 28x28 โดยมีค่าพิกเซลตั้งแต่ 0 ถึง 255 ป้ายกำกับ คืออาร์เรย์ของจำนวนเต็มตั้งแต่ 0 ถึง 9 ซึ่งสอดคล้องกับ คลาส ของเสื้อผ้าที่รูปภาพแสดงถึง:

ฉลาก คลาส
0 เสื้อยืด / top
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)
60000

แต่ละป้ายกำกับเป็นจำนวนเต็มระหว่าง 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)
10000

ประมวลผลข้อมูลล่วงหน้า

ข้อมูลต้องได้รับการประมวลผลล่วงหน้าก่อนการฝึกอบรมเครือข่าย หากคุณตรวจสอบภาพแรกในชุดการฝึกคุณจะเห็นว่าค่าพิกเซลอยู่ในช่วง 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 = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(10)
])

เลเยอร์แรกในเครือข่ายนี้ tf.keras.layers.Flatten แปลงรูปแบบของภาพจากอาร์เรย์สองมิติ (28 x 28 พิกเซล) เป็นอาร์เรย์หนึ่งมิติ (28 * 28 = 784 พิกเซล) ให้คิดว่าเลเยอร์นี้เป็นแถวของพิกเซลที่ไม่เรียงซ้อนกันในภาพและเรียงแถวกัน เลเยอร์นี้ไม่มีพารามิเตอร์ให้เรียนรู้ เพียงฟอร์แมตข้อมูลเท่านั้น

หลังจากพิกเซลถูกแบนเครือข่ายจะประกอบด้วยลำดับของสอง tf.keras.layers.Dense เลเยอร์ สิ่งเหล่านี้เชื่อมต่อกันอย่างหนาแน่นหรือเชื่อมต่อกันเต็มชั้นประสาท ชั้น Dense แรกมี 128 โหนด (หรือเซลล์ประสาท) เลเยอร์ที่สอง (และสุดท้าย) ส่งคืนอาร์เรย์ล็อกที่มีความยาว 10 แต่ละโหนดมีคะแนนที่ระบุว่ารูปภาพปัจจุบันเป็นของหนึ่งใน 10 คลาส

รวบรวมโมเดล

ก่อนที่โมเดลจะพร้อมสำหรับการฝึกอบรมจำเป็นต้องมีการตั้งค่าเพิ่มเติมอีกเล็กน้อย สิ่งเหล่านี้จะถูกเพิ่มในขั้นตอนการ คอมไพล์ ของโมเดล:

  • ฟังก์ชันการสูญเสีย - เป็นการวัดความแม่นยำของแบบจำลองในระหว่างการฝึกอบรม คุณต้องการย่อฟังก์ชันนี้เพื่อ "คัดท้าย" โมเดลไปในทิศทางที่ถูกต้อง
  • เครื่องมือเพิ่มประสิทธิภาพ - นี่คือวิธีอัปเดตโมเดลตามข้อมูลที่เห็นและฟังก์ชันการสูญเสีย
  • เมตริก - ใช้เพื่อตรวจสอบขั้นตอนการฝึกอบรมและการทดสอบ ตัวอย่างต่อไปนี้ใช้ ความถูกต้อง ส่วนของภาพที่จัดประเภทอย่างถูกต้อง
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

ฝึกโมเดล

การฝึกโมเดลโครงข่ายประสาทเทียมจำเป็นต้องมีขั้นตอนต่อไปนี้:

  1. ป้อนข้อมูลการฝึกให้กับโมเดล ในตัวอย่างนี้ข้อมูลการฝึกอบรมอยู่ใน train_images และ train_labels อาร์เรย์
  2. โมเดลเรียนรู้ที่จะเชื่อมโยงรูปภาพและป้ายกำกับ
  3. คุณขอให้โมเดลคาดการณ์เกี่ยวกับชุดทดสอบ - ในตัวอย่างนี้อาร์เรย์ test_images
  4. ตรวจสอบว่าการคาดคะเนตรงกับเลเบลจากอาร์เรย์ test_labels

ป้อนโมเดล

ในการเริ่มต้นการฝึกให้เรียกเมธอด model.fit - เรียกเช่นนี้เพราะ "พอดี" กับโมเดลกับข้อมูลการฝึก:

model.fit(train_images, train_labels, epochs=10)
Epoch 1/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.5007 - accuracy: 0.8232
Epoch 2/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.3743 - accuracy: 0.8654
Epoch 3/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.3358 - accuracy: 0.8778
Epoch 4/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.3119 - accuracy: 0.8849
Epoch 5/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2957 - accuracy: 0.8911
Epoch 6/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2802 - accuracy: 0.8963
Epoch 7/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2674 - accuracy: 0.9008
Epoch 8/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2571 - accuracy: 0.9045
Epoch 9/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2491 - accuracy: 0.9086
Epoch 10/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2380 - accuracy: 0.9110

<tensorflow.python.keras.callbacks.History at 0x7f29ebf31518>

ในขณะที่โมเดลฝึกขึ้นเมตริกการสูญเสียและความแม่นยำจะปรากฏขึ้น แบบจำลองนี้มีความแม่นยำประมาณ 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.3312 - accuracy: 0.8832

Test accuracy: 0.8831999897956848

ปรากฎว่าความแม่นยำของชุดข้อมูลทดสอบนั้นน้อยกว่าความแม่นยำของชุดข้อมูลการฝึกเล็กน้อย ช่องว่างระหว่างความแม่นยำในการฝึกและความแม่นยำในการทดสอบนี้แสดงถึง การฟิตติ้ง มาก เกินไป การฟิตติ้งมากเกินไปเกิดขึ้นเมื่อโมเดลแมชชีนเลิร์นนิงทำงานได้แย่ลงกับอินพุตใหม่ที่มองไม่เห็นก่อนหน้านี้มากกว่าข้อมูลการฝึก โมเดลที่ติดตั้งมากเกินไปจะ "จดจำ" เสียงรบกวนและรายละเอียดในชุดข้อมูลการฝึกอบรมจนถึงจุดที่ส่งผลเสียต่อประสิทธิภาพของโมเดลในข้อมูลใหม่ สำหรับข้อมูลเพิ่มเติมโปรดดูสิ่งต่อไปนี้:

ทำการคาดการณ์

คุณสามารถใช้โมเดลนี้เพื่อคาดเดาเกี่ยวกับภาพบางภาพได้ เอาต์พุตเชิงเส้นของโมเดล บันทึก แนบเลเยอร์ softmax เพื่อแปลงบันทึกเป็นความน่าจะเป็นซึ่งง่ายต่อการตีความ

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

ที่นี่แบบจำลองได้คาดคะเนฉลากสำหรับแต่ละภาพในชุดทดสอบ มาดูคำทำนายแรกกัน:

predictions[0]
array([2.3710859e-08, 3.1721327e-11, 1.4305586e-11, 1.3425981e-09,
       3.3166289e-10, 1.6982469e-04, 4.0853692e-07, 9.2678880e-03,
       9.4139558e-08, 9.9056178e-01], dtype=float32)

การทำนายคืออาร์เรย์ของตัวเลข 10 ตัว สิ่งเหล่านี้แสดงถึง "ความมั่นใจ" ของนางแบบว่าภาพนั้นสอดคล้องกับเสื้อผ้า 10 ชิ้น คุณสามารถดูว่าป้ายกำกับใดมีค่าความเชื่อมั่นสูงสุด:

np.argmax(predictions[0])
9

ดังนั้นนางแบบจึงมั่นใจที่สุดว่ารูปภาพนี้เป็นรองเท้า class_names[9] ข้อหรือ class_names[9] การตรวจสอบฉลากทดสอบแสดงให้เห็นว่าการจัดประเภทนี้ถูกต้อง:

test_labels[0]
9

วาดกราฟนี้เพื่อดูการคาดคะเนทั้ง 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)
[[3.8163576e-05 7.6493567e-14 9.9756038e-01 2.8972957e-09 7.7012519e-04
  1.9186120e-12 1.6312959e-03 2.7591241e-17 4.4947028e-12 4.1419238e-15]]

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

png

keras.Model.predict ส่งกลับรายการรายการหนึ่งรายการสำหรับแต่ละภาพในชุดข้อมูล รับการคาดการณ์สำหรับภาพ (เท่านั้น) ของเราในชุด:

np.argmax(predictions_single[0])
2

และแบบจำลองคาดการณ์ฉลากตามที่คาดไว้


#
# 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.

คู่มือนี้ใช้ชุดข้อมูล Fashion MNIST ซึ่งมีภาพสีเทา 70,000 ภาพใน 10 หมวดหมู่ ภาพแสดงเสื้อผ้าแต่ละชิ้นที่ความละเอียดต่ำ (28 x 28 พิกเซล) ดังที่เห็นที่นี่:

แฟชั่น MNIST สไปรท์
รูปที่ 1. ตัวอย่าง Fashion-MNIST (โดย Zalando, MIT License)

Fashion MNIST มีจุดประสงค์เพื่อทดแทนชุดข้อมูล MNIST แบบคลาสสิกซึ่งมักใช้เป็น "สวัสดีชาวโลก" ของโปรแกรมการเรียนรู้ของเครื่องสำหรับการมองเห็นด้วยคอมพิวเตอร์ ชุดข้อมูล MNIST ประกอบด้วยรูปภาพของตัวเลขที่เขียนด้วยลายมือ (0, 1, 2 เป็นต้น) ในรูปแบบที่เหมือนกับเสื้อผ้าที่คุณจะใช้ที่นี่

คู่มือนี้ใช้ Fashion MNIST เพื่อความหลากหลายและเนื่องจากเป็นปัญหาที่ท้าทายกว่า MNIST ทั่วไปเล็กน้อย ชุดข้อมูลทั้งสองมีขนาดค่อนข้างเล็กและใช้เพื่อตรวจสอบว่าอัลกอริทึมทำงานตามที่คาดไว้ เป็นจุดเริ่มต้นที่ดีในการทดสอบและแก้ปัญหาโค้ด

ที่นี่มีการใช้รูปภาพ 60,000 ภาพในการฝึกอบรมเครือข่ายและ 10,000 ภาพเพื่อประเมินว่าเครือข่ายเรียนรู้การจำแนกภาพได้แม่นยำเพียงใด คุณสามารถเข้าถึง Fashion MNIST ได้โดยตรงจาก TensorFlow นำเข้าและโหลดข้อมูล Fashion MNIST โดยตรงจาก TensorFlow: