Halaman ini diterjemahkan oleh Cloud Translation API.
Switch to English

Klasifikasi dasar: Mengelompokkan gambar pakaian

Lihat di TensorFlow.org Jalankan di Google Colab Lihat sumber di GitHub Unduh buku catatan

Panduan ini melatih model jaringan saraf untuk mengklasifikasikan gambar pakaian, seperti sepatu kets dan kemeja. Tidak apa-apa jika Anda tidak memahami semua detailnya; ini adalah ringkasan cepat dari program TensorFlow lengkap dengan detail yang dijelaskan saat Anda melanjutkan.

Panduan ini menggunakan tf.keras , API level tinggi untuk membuat dan melatih model di TensorFlow.

# TensorFlow and tf.keras
import tensorflow as tf

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

print(tf.__version__)
2.3.1

Impor set data Fashion MNIST

Panduan ini menggunakan dataset Fashion MNIST yang berisi 70.000 gambar grayscale dalam 10 kategori. Gambar menunjukkan setiap artikel pakaian dengan resolusi rendah (28 kali 28 piksel), seperti yang terlihat di sini:

Fashion MNIST sprite
Gambar 1. Sampel Fashion-MNIST (oleh Zalando, MIT Licence).

Fashion MNIST dimaksudkan sebagai pengganti drop-in untuk kumpulan data MNIST klasik — sering digunakan sebagai "Halo, Dunia" dari program pembelajaran mesin untuk computer vision. Dataset MNIST berisi gambar angka tulisan tangan (0, 1, 2, dll.) Dalam format yang identik dengan artikel pakaian yang akan Anda gunakan di sini.

Panduan ini menggunakan Fashion MNIST untuk variasi, dan karena ini masalah yang sedikit lebih menantang daripada MNIST biasa. Kedua kumpulan data tersebut relatif kecil dan digunakan untuk memverifikasi bahwa algoritme berfungsi seperti yang diharapkan. Mereka adalah titik awal yang baik untuk menguji dan men-debug kode.

Di sini, 60.000 gambar digunakan untuk melatih jaringan dan 10.000 gambar untuk mengevaluasi seberapa akurat jaringan mempelajari cara mengklasifikasikan gambar. Anda dapat mengakses Fashion MNIST langsung dari TensorFlow. Impor dan muat data Fashion MNIST langsung dari 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 [==============================] - 0s 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

Memuat dataset akan mengembalikan empat array NumPy:

  • train_images dan train_labels adalah set pelatihan train_labels yang digunakan model untuk dipelajari.
  • Model diuji terhadap set pengujian , test_images , dan test_labels .

Gambar adalah larik NumPy 28x28, dengan nilai piksel mulai dari 0 hingga 255. Label adalah larik bilangan bulat, mulai dari 0 hingga 9. Ini sesuai dengan kelas pakaian yang diwakili oleh gambar:

Label Kelas
0 Kaos / atasan
1 Celana panjang
2 Menarik
3 Gaun
4 Mantel
5 Sandal
6 Kemeja
7 Sneaker
8 Tas
9 Pergelangan sepatu

Setiap gambar dipetakan ke satu label. Karena nama kelas tidak disertakan dengan kumpulan data, simpan di sini untuk digunakan nanti saat memplot gambar:

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

Jelajahi datanya

Mari jelajahi format kumpulan data sebelum melatih model. Berikut ini adalah tampilan 60.000 gambar dalam set pelatihan, dengan setiap gambar direpresentasikan sebagai 28 x 28 piksel:

train_images.shape
(60000, 28, 28)

Demikian pula, ada 60.000 label di set pelatihan:

len(train_labels)
60000

Setiap label adalah bilangan bulat antara 0 dan 9:

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

Ada 10.000 gambar dalam set pengujian. Sekali lagi, setiap gambar direpresentasikan sebagai 28 x 28 piksel:

test_images.shape
(10000, 28, 28)

Dan set pengujian berisi 10.000 label gambar:

len(test_labels)
10000

Proses data terlebih dahulu

Data harus diproses terlebih dahulu sebelum melatih jaringan. Jika Anda memeriksa gambar pertama di set pelatihan, Anda akan melihat bahwa nilai piksel berada dalam kisaran 0 hingga 255:

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

png

Skalakan nilai ini ke rentang 0 hingga 1 sebelum memasukkannya ke model jaringan neural. Untuk melakukannya, bagi nilai dengan 255. Penting bahwa set pelatihan dan set pengujian diproses sebelumnya dengan cara yang sama:

train_images = train_images / 255.0

test_images = test_images / 255.0

Untuk memverifikasi bahwa data dalam format yang benar dan bahwa Anda siap untuk membangun dan melatih jaringan, mari kita tampilkan 25 gambar pertama dari set pelatihan dan tampilkan nama kelas di bawah setiap gambar.

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

Bangun modelnya

Membangun jaringan neural membutuhkan konfigurasi lapisan model, kemudian menyusun model.

Siapkan lapisannya

Blok bangunan dasar dari jaringan neural adalah lapisan . Lapisan mengekstrak representasi dari data yang dimasukkan ke dalamnya. Semoga representasi ini bermakna untuk masalah yang dihadapi.

Sebagian besar pembelajaran mendalam terdiri dari merangkai lapisan-lapisan sederhana. Kebanyakan lapisan, seperti tf.keras.layers.Dense , memiliki parameter yang dipelajari selama pelatihan.

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

Lapisan pertama dalam jaringan ini, tf.keras.layers.Flatten , mengubah format gambar dari larik dua dimensi (28 kali 28 piksel) menjadi larik satu dimensi (28 * 28 = 784 piksel). Pikirkan layer ini sebagai baris piksel yang tidak menumpuk pada gambar dan melapisinya. Lapisan ini tidak memiliki parameter untuk dipelajari; itu hanya memformat ulang data.

Setelah piksel diratakan, jaringan terdiri dari urutan dua lapisan tf.keras.layers.Dense . Ini adalah lapisan saraf yang terhubung dengan rapat, atau sepenuhnya terhubung. Lapisan Dense pertama memiliki 128 node (atau neuron). Lapisan kedua (dan terakhir) mengembalikan array logits dengan panjang 10. Setiap node berisi skor yang menunjukkan gambar saat ini milik salah satu dari 10 kelas.

Kompilasi model

Sebelum model siap untuk pelatihan, diperlukan beberapa setelan lagi. Ini ditambahkan selama langkah kompilasi model:

  • Fungsi kerugian —Ini mengukur seberapa akurat model selama pelatihan. Anda ingin meminimalkan fungsi ini untuk "mengarahkan" model ke arah yang benar.
  • Pengoptimal —Ini adalah cara model diperbarui berdasarkan data yang dilihatnya dan fungsi kerugiannya.
  • Metrik —Digunakan untuk memantau langkah-langkah pelatihan dan pengujian. Contoh berikut menggunakan akurasi , bagian dari gambar yang diklasifikasikan dengan benar.
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

Latih modelnya

Melatih model jaringan saraf memerlukan langkah-langkah berikut:

  1. Masukkan data pelatihan ke model. Dalam contoh ini, data pelatihan ada dalam train_images dan train_labels .
  2. Model tersebut belajar mengasosiasikan gambar dan label.
  3. Anda meminta model untuk membuat prediksi tentang set pengujian — dalam contoh ini, array test_images .
  4. Pastikan prediksi cocok dengan label dari larik test_labels .

Beri makan model

Untuk memulai pelatihan, panggil metode model.fit — disebut demikian karena "menyesuaikan" model ke data pelatihan:

model.fit(train_images, train_labels, epochs=10)
Epoch 1/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.4917 - accuracy: 0.8277
Epoch 2/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.3702 - accuracy: 0.8674
Epoch 3/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.3328 - accuracy: 0.8793
Epoch 4/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.3106 - accuracy: 0.8859
Epoch 5/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2915 - accuracy: 0.8927
Epoch 6/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2771 - accuracy: 0.8968
Epoch 7/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2666 - accuracy: 0.9008
Epoch 8/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2547 - accuracy: 0.9055
Epoch 9/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2439 - accuracy: 0.9097
Epoch 10/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.2370 - accuracy: 0.9115

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

Saat model berlatih, metrik kerugian dan akurasi ditampilkan. Model ini mencapai akurasi sekitar 0,91 (atau 91%) pada data pelatihan.

Evaluasi akurasi

Selanjutnya, bandingkan performa model pada set data pengujian:

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

print('\nTest accuracy:', test_acc)
313/313 - 1s - loss: 0.3637 - accuracy: 0.8693

Test accuracy: 0.8693000078201294

Ternyata keakuratan pada set data pengujian sedikit lebih rendah daripada keakuratan pada set data pelatihan. Kesenjangan antara akurasi pelatihan dan akurasi pengujian ini menunjukkan overfitting . Overfitting terjadi saat model machine learning berperforma lebih buruk pada input baru yang sebelumnya tidak terlihat daripada pada data pelatihan. Model overfitted "mengingat" noise dan detail dalam set data pelatihan ke titik yang berdampak negatif pada performa model pada data baru. Untuk informasi lebih lanjut, lihat yang berikut ini:

Membuat prediksi

Dengan model yang dilatih, Anda dapat menggunakannya untuk membuat prediksi tentang beberapa gambar. Keluaran linier model, logits . Lampirkan lapisan softmax untuk mengubah logit menjadi probabilitas, yang lebih mudah ditafsirkan.

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

Di sini, model telah memprediksi label untuk setiap gambar di set pengujian. Mari kita lihat prediksi pertama:

predictions[0]
array([5.1698703e-07, 5.0422708e-11, 1.0513627e-06, 4.2676376e-08,
       4.1753174e-07, 8.8213873e-04, 1.4294442e-06, 8.9591898e-02,
       3.7699414e-07, 9.0952224e-01], dtype=float32)

Prediksi adalah larik 10 angka. Mereka mewakili "keyakinan" model bahwa gambar tersebut sesuai dengan masing-masing dari 10 pakaian yang berbeda. Anda dapat melihat label mana yang memiliki nilai keyakinan tertinggi:

np.argmax(predictions[0])
9

Jadi, model paling yakin bahwa gambar ini adalah ankle boot, atau class_names[9] . Pemeriksaan label uji menunjukkan bahwa klasifikasi ini benar:

test_labels[0]
9

Buat grafik untuk melihat kumpulan lengkap dari 10 prediksi kelas.

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')

Verifikasi prediksi

Dengan model yang dilatih, Anda dapat menggunakannya untuk membuat prediksi tentang beberapa gambar.

Mari kita lihat gambar ke-0, prediksi, dan array prediksi. Label prediksi yang benar berwarna biru dan label prediksi yang salah berwarna merah. Angka tersebut memberikan persentase (dari 100) untuk label prediksi.

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

Mari plot beberapa gambar dengan prediksi mereka. Perhatikan bahwa modelnya bisa salah meskipun sangat percaya diri.

# 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

Gunakan model terlatih

Terakhir, gunakan model terlatih untuk membuat prediksi tentang satu gambar.

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

print(img.shape)
(28, 28)

Model tf.keras dioptimalkan untuk membuat prediksi pada sekumpulan , atau kumpulan, contoh sekaligus. Karenanya, meskipun Anda menggunakan satu gambar, Anda perlu menambahkannya ke daftar:

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

print(img.shape)
(1, 28, 28)

Sekarang prediksi label yang benar untuk gambar ini:

predictions_single = probability_model.predict(img)

print(predictions_single)
[[1.2673076e-05 1.9937504e-13 9.9978513e-01 1.8617269e-11 1.3060638e-04
  2.2522463e-12 7.1663781e-05 1.4157123e-21 3.1792444e-11 1.6293697e-13]]

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

png

tf.keras.Model.predict mengembalikan daftar daftar — satu daftar untuk setiap gambar dalam kumpulan data. Ambil prediksi untuk gambar (satu-satunya) kami dalam kelompok:

np.argmax(predictions_single[0])
2

Dan model memprediksi label seperti yang diharapkan.

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