Mem-build model computer vision dengan TensorFlow

1. Sebelum memulai

Dalam codelab ini, Anda akan membuat model computer vision yang dapat mengenali item pakaian dengan TensorFlow.

Prasyarat

  • Pengetahuan yang solid tentang Python
  • Keterampilan pemrograman dasar

Yang akan Anda pelajari

Dalam codelab ini, Anda akan:

  • Latih jaringan neural untuk mengenali artikel pakaian
  • Selesaikan serangkaian latihan untuk memandu Anda bereksperimen dengan berbagai lapisan jaringan

Yang akan Anda build

  • Jaringan neural yang mengidentifikasi artikel pakaian

Yang Anda butuhkan

Jika belum pernah membuat jaringan neural untuk computer vision dengan TensorFlow, Anda dapat menggunakan Colaboratory, lingkungan berbasis browser yang berisi semua dependensi yang diperlukan. Anda dapat menemukan kode untuk codelab lainnya yang berjalan di Colab.

Jika tidak, bahasa utama yang akan Anda gunakan untuk model pelatihan adalah Python, jadi Anda harus menginstalnya. Selain itu, Anda juga akan memerlukan TensorFlow dan library NumPy. Anda dapat mempelajari lebih lanjut dan menginstal TensorFlow di sini. Instal NumPy di sini.

2. Mulai coding

Pertama, pelajari notebook Colab yang dapat dijalankan.

Mulai dengan mengimpor TensorFlow.

import tensorflow as tf
print(tf.__version__)

Anda akan melatih jaringan neural untuk mengenali item pakaian dari set data umum yang disebut Fashion MNIST. Ini berisi 70.000 item pakaian dalam 10 kategori berbeda. Setiap produk pakaian menggunakan gambar berwarna abu-abu berukuran 28x28. Anda dapat melihat beberapa contoh di sini:

Label yang terkait dengan set data adalah:

Label

Deskripsi

0

Kaos/atasan

1

Celana panjang

2

Pullover

3

Gaun

4

Mantel

5

Sandal

6

Baju

7

Kets

8

Tas

9

Sepatu Boot Semata Kaki

Data Fashion MNIST tersedia di tf.keras.datasets API. Muat seperti ini:

mnist = tf.keras.datasets.fashion_mnist

Memanggil load_data pada objek tersebut akan memberi Anda dua kumpulan dua daftar: nilai pelatihan dan nilai pengujian, yang mewakili grafik yang menampilkan item pakaian dan labelnya.

(training_images, training_labels), (test_images, test_labels) = mnist.load_data()

Seperti apa tampilan nilai tersebut? Cetak gambar pelatihan dan label pelatihan untuk dilihat. Anda dapat bereksperimen dengan indeks yang berbeda dalam array.

import matplotlib.pyplot as plt
plt.imshow(training_images[0])
print(training_labels[0])
print(training_images[0])

Cetakan data untuk item 0 akan terlihat seperti ini:

Anda akan melihat bahwa semua nilai adalah bilangan bulat antara 0 dan 255. Saat melatih jaringan neural, lebih mudah untuk memperlakukan semua nilai sebagai antara 0 dan 1, suatu proses yang disebut normalisasi. Untungnya, Python menyediakan cara mudah untuk menormalkan daftar seperti itu tanpa melakukan loop.

training_images  = training_images / 255.0
test_images = test_images / 255.0

Anda mungkin juga ingin melihat 42, sepatu bot yang berbeda dari yang ada di indeks 0.

Sekarang, Anda mungkin bertanya-tanya mengapa ada dua set data—pelatihan dan pengujian.

Idenya adalah memiliki kumpulan data untuk pelatihan dan kumpulan data lain yang belum ditemukan oleh model untuk melihat seberapa baik model tersebut dapat mengklasifikasikan nilai. Lagi pula, setelah selesai, Anda akan menggunakan model dengan data yang belum pernah dilihat sebelumnya! Selain itu, tanpa menjalankan data pengujian terpisah, Anda berisiko menjalankan jaringan hanya mengingat data pelatihannya tanpa menggeneralisasi pengetahuannya.

3. Mendesain model

Sekarang desain model. Anda akan memiliki tiga lapisan. Telusuri satu per satu dan jelajahi berbagai jenis lapisan serta parameter yang digunakan untuk setiap lapisan.

model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), 
                                    tf.keras.layers.Dense(128, activation=tf.nn.relu), 
                                    tf.keras.layers.Dense(10, activation=tf.nn.softmax)])
  • Sequential menentukan urutan lapisan di jaringan neural.
  • Flatten mengambil persegi dan mengubahnya menjadi vektor satu dimensi.
  • Dense menambahkan lapisan neuron.
  • Fungsi Activation memberi tahu setiap lapisan neuron yang harus dilakukan. Ada banyak opsi, tetapi gunakan opsi tersebut untuk saat ini:
  • Relu secara efektif berarti bahwa jika X lebih besar dari 0 menampilkan X, jika tidak, menampilkan 0. Ini hanya meneruskan nilai 0 atau yang lebih besar ke lapisan berikutnya di jaringan.
  • Softmax menggunakan serangkaian nilai, dan secara efektif memilih nilai terbesar. Misalnya, jika output lapisan terakhir terlihat seperti [0.1, 0.1, 0.05, 0.1, 9.5, 0.1, 0.05, 0.05, 0.05], maka Anda tidak perlu mengurutkan untuk nilai terbesar—hal ini akan menampilkan [0,0,0,0,1,0,0,0,0].

4. Mengompilasi dan melatih model

Setelah model ditentukan, hal berikutnya yang harus dilakukan adalah mem-build-nya. Buat model dengan mengompilasinya terlebih dahulu menggunakan fungsi optimizer dan loss, lalu melatihnya pada data dan label pelatihan Anda. Tujuannya adalah agar model mengetahui hubungan antara data pelatihan dan label pelatihannya. Kemudian, Anda ingin model melihat data yang menyerupai data pelatihan Anda, lalu membuat prediksi tentang tampilan data tersebut.

Perhatikan penggunaan metrics= sebagai parameter, yang memungkinkan TensorFlow melaporkan akurasi pelatihan dengan memeriksa hasil yang diprediksi terhadap jawaban yang diketahui (label).

model.compile(optimizer = tf.keras.optimizers.Adam(),
              loss = 'sparse_categorical_crossentropy',
              metrics=['accuracy'])

model.fit(training_images, training_labels, epochs=5)

Saat model.fit dijalankan, Anda akan melihat akurasi dan kerugian:

Epoch 1/5
60000/60000 [=======] - 6s 101us/sample - loss: 0.4964 - acc: 0.8247
Epoch 2/5
60000/60000 [=======] - 5s 86us/sample - loss: 0.3720 - acc: 0.8656
Epoch 3/5
60000/60000 [=======] - 5s 85us/sample - loss: 0.3335 - acc: 0.8780
Epoch 4/5
60000/60000 [=======] - 6s 103us/sample - loss: 0.3134 - acc: 0.8844
Epoch 5/5
60000/60000 [=======] - 6s 94us/sample - loss: 0.2931 - acc: 0.8926

Saat model selesai berlatih, Anda akan melihat nilai akurasi di akhir iterasi pelatihan terakhir. URL tersebut mungkin terlihat seperti 0,8926 seperti di atas. Ini memberitahukan bahwa jaringan neural Anda sekitar 89% akurat dalam mengklasifikasikan data pelatihan. Dengan kata lain, model ini menemukan kecocokan pola antara gambar dan label yang berfungsi sepanjang waktu. Tidak bagus, tetapi tidak buruk mengingat hanya dilatih untuk lima iterasi pelatihan dan dilakukan dengan cepat.

5. Menguji model

Bagaimana performa model pada data yang belum terlihat? Itulah sebabnya Anda memiliki set pengujian. Anda memanggil model.evaluate dan meneruskan kedua set, dan akan melaporkan kerugian untuk setiap set. Cobalah:

model.evaluate(test_images, test_labels)

Dan berikut ini outputnya:

10000/10000 [=====] - 1s 56us/sample - loss: 0.3365 - acc: 0.8789
[0.33648381242752073, 0.8789]

Contoh tersebut memberikan akurasi 0,8789, yang berarti sekitar 88% akurat. (Anda mungkin memiliki nilai yang sedikit berbeda.)

Seperti yang diharapkan, model tidak seakurat data yang tidak diketahui, tetapi sama seperti data yang digunakan untuk melatihnya. Saat mempelajari TensorFlow lebih lanjut, Anda akan menemukan cara untuk meningkatkannya.

Untuk mempelajari lebih lanjut, coba latihan pada langkah berikutnya.

6. Latihan eksplorasi

Latihan 1

Untuk latihan pertama ini, jalankan kode berikut:

classifications = model.predict(test_images)
print(classifications[0])

Alat ini membuat kumpulan klasifikasi untuk setiap gambar pengujian, lalu mencetak entri pertama dalam klasifikasi. Output setelah Anda menjalankannya adalah daftar angka. Menurut Anda, mengapa demikian?

Coba jalankan print(test_labels[0]) dan Anda akan mendapatkan angka 9. Apakah itu membantu Anda memahami alasan daftar tersebut terlihat seperti itu?

Output model adalah daftar yang berisi 10 angka. Angka-angka itu adalah probabilitas bahwa nilai yang diklasifikasikan adalah label yang sesuai. Misalnya, nilai pertama dalam daftar adalah probabilitas bahwa pakaian tersebut adalah kelas 0 dan nilai berikutnya adalah 1. Perhatikan bahwa semuanya merupakan probabilitas yang sangat rendah, kecuali satu. Selain itu, karena Softmax, semua probabilitas dalam daftar berjumlah 1,0.

Daftar dan label berbasis 0, jadi sepatu bot berlabel 9 berarti yang ke-10 dari 10 kelas. Daftar yang memiliki elemen ke-10 sebagai nilai tertinggi berarti jaringan neural telah memprediksi bahwa item yang diklasifikasikan kemungkinan besar adalah sepatu bot.

Latihan 2

Lihat lapisan di model Anda. Lakukan eksperimen dengan nilai yang berbeda untuk lapisan padat dengan 512 neuron.

Apa saja hasil yang Anda dapatkan untuk kerugian dan waktu pelatihan? Mengapa demikian?

Misalnya, jika Anda meningkatkannya menjadi 1.024 neuron, Anda harus melakukan lebih banyak perhitungan, sehingga memperlambat prosesnya. Namun, dalam hal ini contoh tersebut memiliki dampak yang baik karena modelnya lebih akurat. Itu tidak berarti lebih banyak selalu lebih baik. Anda dapat mencapai hukum pengembalian yang menurun dengan sangat cepat.

Latihan 3

Apa yang akan terjadi jika Anda menghapus lapisan Flatten(). Mengapa demikian?

Anda mendapatkan error tentang bentuk data. Detail error saat ini mungkin tampak tidak jelas, tetapi hal ini memperkuat aturan dasar bahwa lapisan pertama di jaringan Anda harus sama bentuknya dengan data Anda. Saat ini data Anda adalah gambar 28x28, dan 28 lapisan 28 neuron tidak akan memungkinkan, jadi lebih masuk akal untuk meratakan 28,28 tersebut menjadi 784x1.

Alih-alih menulis semua kode, tambahkan lapisan Flatten() di awal. Ketika array dimuat ke dalam model nanti, array tersebut akan diratakan secara otomatis untuk Anda.

Latihan 4

Pertimbangkan lapisan akhir (output). Mengapa ada 10 di antaranya? Apa yang akan terjadi jika Anda memiliki jumlah yang berbeda dari 10?

Coba latih jaringan dengan 5. Anda akan mendapat error segera setelah menemukan nilai yang tidak terduga. Aturan praktis lainnya—jumlah neuron di lapisan terakhir harus sesuai dengan jumlah class yang diklasifikasikan. Dalam hal ini, itu adalah angka 0 hingga 9, jadi ada 10 di antaranya, dan karenanya Anda harus memiliki 10 neuron di lapisan akhir Anda.

Latihan 5

Pertimbangkan efek lapisan tambahan di jaringan. Apa yang akan terjadi jika Anda menambahkan lapisan lain dengan 512 dan lapisan terakhir dengan 10?

Tidak ada dampak signifikan karena ini adalah data yang relatif sederhana. Untuk data yang jauh lebih kompleks, lapisan tambahan sering kali diperlukan.

Latihan 6

Sebelum dilatih, Anda menormalisasi data, dari nilai 0 hingga 255 menjadi nilai 0 hingga 1. Apa dampak dari menghapusnya? Berikut kode lengkapnya untuk mencobanya (perhatikan bahwa dua baris yang menormalisasi data diberi komentar).

Menurut Anda, mengapa Anda mendapatkan hasil yang berbeda? Ada jawaban yang bagus di sini di Stack Overflow.

import tensorflow as tf
print(tf.__version__)
mnist = tf.keras.datasets.fashion_mnist
(training_images, training_labels), (test_images, test_labels) = mnist.load_data()
#training_images=training_images/255.0
#test_images=test_images/255.0
model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(),
  tf.keras.layers.Dense(512, activation=tf.nn.relu),
  tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
model.fit(training_images, training_labels, epochs=5)
model.evaluate(test_images, test_labels)
classifications = model.predict(test_images)
print(classifications[0])
print(test_labels[0])

7. Pelajari callback

Sebelumnya, saat dilatih untuk epoch tambahan, Anda memiliki masalah di mana kerugian bisa berubah. Mungkin perlu waktu beberapa saat bagi Anda untuk menunggu pelatihan melakukannya dan Anda mungkin berpikir bahwa akan lebih baik jika Anda dapat menghentikan pelatihan saat mencapai nilai yang diinginkan, seperti akurasi 95%. Jika Anda mencapainya setelah 3 iterasi pelatihan, mengapa duduk menunggu untuk menyelesaikan lebih banyak iterasi pelatihan?

Seperti program lainnya, Anda memiliki callback. Lihat cara kerjanya:

import tensorflow as tf

class myCallback(tf.keras.callbacks.Callback):
  def on_epoch_end(self, epoch, logs={}):
    if(logs.get('accuracy')>0.95):
      print("\nReached 95% accuracy so cancelling training!")
      self.model.stop_training = True

callbacks = myCallback()
mnist = tf.keras.datasets.fashion_mnist
(training_images, training_labels), (test_images, test_labels) = mnist.load_data()
training_images=training_images/255.0
test_images=test_images/255.0
model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(),
  tf.keras.layers.Dense(512, activation=tf.nn.relu),
  tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(training_images, training_labels, epochs=5, callbacks=[callbacks])

8 Selamat

Anda telah membuat model computer vision pertama Anda! Untuk mempelajari cara meningkatkan model computer vision Anda, lanjutkan ke Membangun konvolusi dan melakukan penggabungan.