1. Sebelum memulai
Dalam codelab ini, Anda akan belajar menggunakan CNN untuk meningkatkan model klasifikasi gambar Anda.
Prasyarat
Codelab ini dibuat berdasarkan pekerjaan yang diselesaikan dalam dua cicilan sebelumnya, Membuat model computer vision, tempat kami memperkenalkan beberapa kode yang akan Anda gunakan di sini, dan codelab Membuat konvolusi dan melakukan penggabungan, tempat kami memperkenalkan konvolusi dan penggabungan.
Yang akan Anda pelajari
- Cara meningkatkan visi dan akurasi komputer dengan konvolusi
Yang akan Anda build
- Lapisan untuk menyempurnakan jaringan neural Anda
Yang Anda butuhkan
Anda dapat menemukan kode untuk codelab lainnya yang berjalan di Colab.
Anda juga perlu menginstal TensorFlow, dan library yang Anda instal di codelab sebelumnya.
2. Meningkatkan akurasi computer vision dengan konvolusi
Sekarang Anda tahu cara melakukan pengenalan gambar mode menggunakan Deep Neural Network (DNN) yang berisi tiga lapisan—lapisan input (dalam bentuk data input), lapisan output (dalam bentuk output yang diinginkan) dan lapisan tersembunyi. Anda bereksperimen dengan beberapa parameter yang memengaruhi akurasi akhir, seperti ukuran lapisan tersembunyi yang berbeda dan jumlah iterasi pelatihan.
Untuk memudahkan, berikut lagi seluruh kodenya. Jalankan pengujian dan catat akurasi pengujian yang tercetak di bagian akhir.
import tensorflow as tf
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(128, activation='relu'),
tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(training_images, training_labels, epochs=5)
test_loss, test_accuracy = model.evaluate(test_images, test_labels)
print ('Test loss: {}, Test accuracy: {}'.format(test_loss, test_accuracy*100))
Akurasi Anda mungkin sekitar 89% pada pelatihan dan 87% pada validasi. Anda dapat membuatnya lebih baik menggunakan konvolusi, yang akan mempersempit konten gambar untuk berfokus pada detail tertentu yang berbeda.
Jika Anda pernah melakukan pemrosesan gambar menggunakan filter, maka konvolusi akan terlihat sangat umum.
Singkatnya, Anda mengambil array (biasanya 3x3 atau 5x5) dan meneruskannya ke atas gambar. Dengan mengubah piksel dasar berdasarkan formula dalam matriks tersebut, Anda dapat melakukan operasi seperti deteksi tepi. Misalnya, biasanya 3x3 ditentukan untuk deteksi tepi di mana sel tengah adalah 8, dan semua tetangganya adalah -1. Dalam hal ini, untuk setiap piksel, Anda akan mengalikan nilainya dengan 8, lalu dikurangi nilai setiap tetangga. Lakukan ini untuk setiap piksel, dan Anda akan mendapatkan gambar baru dengan pinggiran yang ditingkatkan.
Ini sempurna untuk computer vision, karena meningkatkan fitur seperti edge membantu komputer membedakan satu item dengan item lainnya. Lebih baik lagi, jumlah informasi yang dibutuhkan jauh lebih sedikit, karena Anda hanya akan berlatih tentang fitur yang disorot.
Itu adalah konsep Jaringan Neural Konvolusional. Tambahkan beberapa lapisan untuk melakukan konvolusi sebelum Anda memiliki lapisan padat, kemudian informasi yang masuk ke lapisan padat akan menjadi lebih terfokus dan mungkin lebih akurat.
3. Coba kode
Jalankan kode berikut. Ini adalah jaringan neural yang sama dengan sebelumnya, tapi kali ini dengan lapisan konvolusional yang ditambahkan terlebih dahulu. Proses ini akan memerlukan waktu lebih lama, tetapi lihat dampaknya pada akurasi:
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.reshape(60000, 28, 28, 1)
training_images=training_images / 255.0
test_images = test_images.reshape(10000, 28, 28, 1)
test_images=test_images / 255.0
model = tf.keras.models.Sequential([
tf.keras.layers.Conv2D(64, (3, 3), activation='relu', input_shape=(28, 28, 1)),
tf.keras.layers.MaxPooling2D(2, 2),
tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),
tf.keras.layers.MaxPooling2D(2,2),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.summary()
model.fit(training_images, training_labels, epochs=5)
test_loss, test_accuracy = model.evaluate(test_images, test_labels)
print ('Test loss: {}, Test accuracy: {}'.format(test_loss, test_accuracy*100))
Kemungkinan naik hingga sekitar 93% pada data pelatihan dan 91% pada data validasi.
Sekarang coba jalankan untuk lebih banyak iterasi pelatihan—misalnya sekitar 20—dan jelajahi hasilnya. Meskipun hasil pelatihan mungkin tampak sangat bagus, hasil validasi sebenarnya bisa turun karena fenomena yang disebut overfit.
Overfit terjadi saat jaringan mempelajari data dari set pelatihan terlalu baik, sehingga fitur ini dikhususkan untuk mengenali data tersebut saja, dan akibatnya kurang efektif dalam melihat data lainnya dalam situasi yang lebih umum. Misalnya, jika Anda hanya berlatih menggunakan sepatu hak tinggi, jaringan mungkin sangat baik untuk mengidentifikasi sepatu hak, tetapi sepatu kets dapat membingungkannya.
Lihat kodenya lagi, dan lihat langkah demi langkah cara konvolusi dibangun.
4. Mengumpulkan data
Langkah pertama adalah mengumpulkan data.
Anda akan melihat bahwa ada perubahan di sini dan data pelatihan perlu dibentuk ulang. Itu karena konvolusi pertama mengharapkan tensor tunggal yang berisi semuanya, jadi alih-alih 60.000 item 28x28x1 dalam daftar, Anda memiliki satu daftar 4D berukuran 60.000x28x28x1, dan sama untuk gambar uji. Jika Anda tidak melakukannya, maka Anda akan mendapatkan error saat berlatih karena konvolusi tidak mengenali bentuknya.
import tensorflow as tf
mnist = tf.keras.datasets.fashion_mnist
(training_images, training_labels), (test_images, test_labels) = mnist.load_data()
training_images=training_images.reshape(60000, 28, 28, 1)
training_images = training_images/255.0
test_images = test_images.reshape(10000, 28, 28, 1)
test_images = test_images/255.0
5. Menentukan model
Selanjutnya, tentukan model Anda. Sebagai ganti lapisan input di bagian atas, Anda akan menambahkan lapisan konvolusional. Parameternya adalah:
- Jumlah konvolusi yang ingin dihasilkan. Nilai seperti 32 adalah titik awal yang bagus.
- Ukuran matriks konvolusional, dalam hal ini petak 3x3.
- Fungsi aktivasi yang digunakan, dalam hal ini menggunakan
relu. - Di lapisan pertama, bentuk data input.
Anda akan mengikuti konvolusi dengan lapisan penggabungan maks, yang dirancang untuk mengompresi gambar sekaligus mempertahankan konten fitur yang disorot oleh konvolusi. Dengan menentukan (2,2) untuk penggabungan maksimum, efeknya adalah mengurangi ukuran gambar dengan faktor 4. Ini membuat array piksel 2x2 dan memilih nilai piksel terbesar, mengubah 4 piksel menjadi 1. Fungsi ini mengulangi komputasi ini di seluruh gambar, dan dengan demikian mengurangi jumlah piksel horizontal dan membagi dua jumlah piksel vertikal.
Anda dapat memanggil model.summary() untuk melihat ukuran dan bentuk jaringan. Perhatikan bahwa setelah setiap lapisan penggabungan maks, ukuran gambar dikurangi dengan cara berikut:
_________________________________________________________________ Layer (type) Output Shape Param # ================================================================= conv2d_2 (Conv2D) (None, 26, 26, 64) 640 _________________________________________________________________ max_pooling2d_2 (MaxPooling2 (None, 13, 13, 64) 0 _________________________________________________________________ conv2d_3 (Conv2D) (None, 11, 11, 64) 36928 _________________________________________________________________ max_pooling2d_3 (MaxPooling2 (None, 5, 5, 64) 0 _________________________________________________________________ flatten_2 (Flatten) (None, 1600) 0 _________________________________________________________________ dense_4 (Dense) (None, 128) 204928 _________________________________________________________________ dense_5 (Dense) (None, 10) 1290 =================================================================
Ini kode lengkapnya untuk CNN:
model = tf.keras.models.Sequential([
tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
tf.keras.layers.MaxPooling2D(2, 2),
#Add another convolution
tf.keras.layers.Conv2D(64, (3,3), activation='relu'),
tf.keras.layers.MaxPooling2D(2, 2),
#Now flatten the output. After this you'll just have the same DNN structure as the non convolutional version
tf.keras.layers.Flatten(),
#The same 128 dense layers, and 10 output layers as in the pre-convolution example:
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(10, activation='softmax')
])
6. Mengompilasi dan melatih model
Mengompilasi model, memanggil metode fit untuk melakukan pelatihan, dan mengevaluasi kerugian dan akurasi dari set pengujian.
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(training_images, training_labels, epochs=5)
test_loss, test_acc = model.evaluate(test_images, test_labels)
print ('Test loss: {}, Test accuracy: {}'.format(test_loss, test_acc*100))
7. Visualisasikan konvolusi dan penggabungan
Kode ini menampilkan konvolusi secara grafis. print (test_labels[:100]) menunjukkan 100 label pertama dalam kumpulan pengujian, dan Anda dapat melihat bahwa label pada indeks 0, indeks 23, dan indeks 28 semuanya memiliki nilai yang sama (9). Semuanya sepatu. Lihat hasil dari menjalankan konvolusi pada masing-masing dan Anda akan mulai melihat fitur umum di antara mereka muncul. Sekarang, ketika DNN sedang melatih data tersebut, DNN bekerja dengan lebih sedikit informasi, dan mungkin menemukan kesamaan antara sepatu berdasarkan kombinasi konvolusi dan penggabungan.
print(test_labels[:100])
[9 2 1 1 6 1 4 6 5 7 4 5 7 3 4 1 2 4 8 0 2 5 7 9 1 4 6 0 9 3 8 8 3 3 8 0 7 5 7 9 6 1 3 7 6 7 2 1 2 2 4 4 5 8 2 2 8 4 8 0 7 7 8 5 1 1 2 3 9 8 7 0 2 6 2 3 1 2 8 4 1 8 5 9 5 0 3 2 0 6 5 3 6 7 1 8 0 1 4 2]
Sekarang Anda dapat memilih beberapa gambar yang sesuai untuk label tersebut dan merender tampilannya melalui konvolusi. Jadi, dalam kode berikut, FIRST_IMAGE, SECOND_IMAGE, dan THIRD_IMAGE adalah indeks untuk nilai 9, yaitu sepatu bot.
import matplotlib.pyplot as plt
f, axarr = plt.subplots(3,4)
FIRST_IMAGE=0
SECOND_IMAGE=23
THIRD_IMAGE=28
CONVOLUTION_NUMBER = 6
from tensorflow.keras import models
layer_outputs = [layer.output for layer in model.layers]
activation_model = tf.keras.models.Model(inputs = model.input, outputs = layer_outputs)
for x in range(0,4):
f1 = activation_model.predict(test_images[FIRST_IMAGE].reshape(1, 28, 28, 1))[x]
axarr[0,x].imshow(f1[0, : , :, CONVOLUTION_NUMBER], cmap='inferno')
axarr[0,x].grid(False)
f2 = activation_model.predict(test_images[SECOND_IMAGE].reshape(1, 28, 28, 1))[x]
axarr[1,x].imshow(f2[0, : , :, CONVOLUTION_NUMBER], cmap='inferno')
axarr[1,x].grid(False)
f3 = activation_model.predict(test_images[THIRD_IMAGE].reshape(1, 28, 28, 1))[x]
axarr[2,x].imshow(f3[0, : , :, CONVOLUTION_NUMBER], cmap='inferno')
axarr[2,x].grid(False)
Dan Anda akan melihat sesuatu seperti berikut, di mana konvolusi mengambil esensi dari sol sepatu, yang secara efektif melihatnya sebagai fitur umum di semua sepatu.
8 Latihan
Latihan 1
Coba edit konvolusi. Ubah jumlah konvolusi dari 32 menjadi 16 atau 64. Apa dampaknya terhadap akurasi dan waktu pelatihan?
Latihan 2
Hapus konvolusi akhir. Apa dampaknya terhadap akurasi atau waktu pelatihan?
Latihan 3
Tambahkan lebih banyak konvolusi. Apa dampaknya?
Latihan 4
Hapus semua konvolusi kecuali yang pertama. Apa dampaknya? Lakukan eksperimen dengan akun tersebut.
9. Selamat
Anda telah membuat CNN pertama Anda! Untuk mempelajari cara meningkatkan kualitas model computer vision Anda lebih lanjut, lanjutkan ke Menggunakan jaringan neural konvolusional (CNN) dengan gambar yang kompleks.