1. Sebelum memulai
Dalam codelab ini, Anda akan mempelajari konvolusi dan alasan konvolusi sangat efektif dalam skenario computer vision.
Dalam codelab sebelumnya, Anda membuat Jaringan Neural Dalam (DNN) sederhana untuk visi komputer item fashion. Hal ini dibatasi karena mengharuskan item pakaian menjadi satu-satunya hal dalam gambar, dan harus dipusatkan.
Tentu saja, ini bukan skenario yang realistis. Anda ingin DNN Anda dapat mengidentifikasi item pakaian dalam gambar dengan objek lain, atau saat tidak diposisikan di tengah dan depan. Untuk melakukannya, Anda harus menggunakan konvolusi.
Prasyarat
Codelab ini dibangun berdasarkan tugas yang diselesaikan dalam dua bagian sebelumnya, Sapa "Hello, World" machine learning, dan Membangun model computer vision. Harap selesaikan codelab tersebut sebelum melanjutkan.
Yang akan Anda pelajari
- Apa itu konvolusi
- Cara membuat peta fitur
- Apa itu penggabungan
Yang akan Anda bangun
- Peta fitur gambar
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. Apa itu konvolusi?
Konvolusi adalah filter yang dijalankan pada suatu gambar, memprosesnya, dan mengekstrak fitur-fitur penting.
Misalnya, Anda memiliki gambar seseorang yang mengenakan sepatu kets. Bagaimana cara mendeteksi bahwa ada sepatu kets dalam gambar? Agar program Anda dapat "melihat" gambar sebagai sepatu kets, Anda harus mengekstrak fitur penting, dan mengaburkan fitur yang tidak penting. Hal ini disebut pemetaan fitur.
Proses pemetaan fitur secara teoretis sederhana. Anda akan memindai setiap piksel dalam gambar, lalu melihat piksel di sekitarnya. Anda mengalikan nilai piksel tersebut dengan bobot yang setara dalam filter.
Contoh:
Dalam hal ini, matriks konvolusi 3x3, atau kernel gambar, ditentukan.
Nilai piksel saat ini adalah 192. Anda dapat menghitung nilai piksel baru dengan melihat nilai tetangga, mengalikannya dengan nilai yang ditentukan dalam filter, dan menjadikan nilai piksel baru sebagai jumlah akhir.
Sekarang saatnya mempelajari cara kerja konvolusi dengan membuat konvolusi dasar pada gambar skala abu-abu 2D.
Anda akan mendemonstrasikannya dengan gambar pendakian dari SciPy. Ini adalah gambar bawaan yang bagus dengan banyak sudut dan garis.
3. Mulai coding
Mulai dengan mengimpor beberapa library Python dan gambar pendakian:
import cv2
import numpy as np
from scipy import misc
i = misc.ascent()
Selanjutnya, gunakan library Pyplot matplotlib untuk menggambar gambar sehingga Anda tahu tampilannya:
import matplotlib.pyplot as plt
plt.grid(False)
plt.gray()
plt.axis('off')
plt.imshow(i)
plt.show()
Anda dapat melihat bahwa itu adalah gambar tangga. Ada banyak fitur yang dapat Anda coba dan pisahkan. Misalnya, ada garis vertikal yang kuat.
Gambar disimpan sebagai array NumPy, sehingga kita dapat membuat gambar yang ditransformasikan hanya dengan menyalin array tersebut. Variabel size_x dan size_y akan menyimpan dimensi gambar sehingga Anda dapat melakukan loop di lain waktu.
i_transformed = np.copy(i)
size_x = i_transformed.shape[0]
size_y = i_transformed.shape[1]
4. Buat matriks konvolusi
Pertama, buat matriks konvolusi (atau kernel) sebagai array 3x3:
# This filter detects edges nicely
# It creates a filter that only passes through sharp edges and straight lines.
# Experiment with different values for fun effects.
#filter = [ [0, 1, 0], [1, -4, 1], [0, 1, 0]]
# A couple more filters to try for fun!
filter = [ [-1, -2, -1], [0, 0, 0], [1, 2, 1]]
#filter = [ [-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]
# If all the digits in the filter don't add up to 0 or 1, you
# should probably do a weight to get it to do so
# so, for example, if your weights are 1,1,1 1,2,1 1,1,1
# They add up to 10, so you would set a weight of .1 if you want to normalize them
weight = 1
Sekarang, hitung piksel output. Lakukan iterasi pada gambar, dengan menyisakan margin 1 piksel, dan kalikan setiap tetangga piksel saat ini dengan nilai yang ditentukan dalam filter.
Artinya, tetangga piksel saat ini di atas dan di sebelah kirinya akan dikalikan dengan item kiri atas dalam filter. Kemudian, kalikan hasilnya dengan bobot dan pastikan hasilnya berada dalam rentang 0 hingga 255.
Terakhir, muat nilai baru ke dalam gambar yang telah diubah:
for x in range(1,size_x-1):
for y in range(1,size_y-1):
output_pixel = 0.0
output_pixel = output_pixel + (i[x - 1, y-1] * filter[0][0])
output_pixel = output_pixel + (i[x, y-1] * filter[0][1])
output_pixel = output_pixel + (i[x + 1, y-1] * filter[0][2])
output_pixel = output_pixel + (i[x-1, y] * filter[1][0])
output_pixel = output_pixel + (i[x, y] * filter[1][1])
output_pixel = output_pixel + (i[x+1, y] * filter[1][2])
output_pixel = output_pixel + (i[x-1, y+1] * filter[2][0])
output_pixel = output_pixel + (i[x, y+1] * filter[2][1])
output_pixel = output_pixel + (i[x+1, y+1] * filter[2][2])
output_pixel = output_pixel * weight
if(output_pixel<0):
output_pixel=0
if(output_pixel>255):
output_pixel=255
i_transformed[x, y] = output_pixel
5. Memeriksa hasilnya
Sekarang, buat plot gambar untuk melihat efek penerapan filter padanya:
# Plot the image. Note the size of the axes -- they are 512 by 512
plt.gray()
plt.grid(False)
plt.imshow(i_transformed)
#plt.axis('off')
plt.show()
Pertimbangkan nilai filter berikut dan dampaknya pada gambar.
Menggunakan [-1,0,1,-2,0,2,-1,0,1] akan memberi Anda sekumpulan garis vertikal yang sangat kuat:
Menggunakan [-1,-2,-1,0,0,0,1,2,1] akan memberi Anda garis horizontal:
Jelajahi berbagai nilai. Selain itu, coba filter dengan ukuran berbeda, seperti 5x5 atau 7x7.
6. Memahami Penggabungan
Setelah Anda mengidentifikasi fitur penting gambar, apa yang Anda lakukan? Bagaimana Anda menggunakan peta fitur yang dihasilkan untuk mengklasifikasikan gambar?
Mirip dengan konvolusi, penggabungan sangat membantu dalam mendeteksi fitur. Penggabungan lapisan mengurangi jumlah keseluruhan informasi dalam gambar sekaligus mempertahankan fitur yang terdeteksi sebagai ada.
Ada sejumlah jenis penggabungan yang berbeda, tetapi Anda akan menggunakan salah satunya yang disebut Penggabungan Maksimum (Max).
Lakukan iterasi pada gambar dan, di setiap titik, pertimbangkan piksel dan tetangga terdekatnya di sebelah kanan, bawah, dan kanan-bawah. Ambil yang terbesar di antara keduanya (oleh karena itu, penggabungan maks) dan muat ke dalam gambar baru. Dengan demikian, gambar baru akan berukuran seperempat dari ukuran gambar lama. 
7. Menulis kode untuk penggabungan
Kode berikut akan menampilkan pooling (2, 2). Jalankan untuk melihat output.
Anda akan melihat bahwa meskipun ukurannya seperempat dari ukuran aslinya, gambar tersebut tetap mempertahankan semua fitur.
new_x = int(size_x/2)
new_y = int(size_y/2)
newImage = np.zeros((new_x, new_y))
for x in range(0, size_x, 2):
for y in range(0, size_y, 2):
pixels = []
pixels.append(i_transformed[x, y])
pixels.append(i_transformed[x+1, y])
pixels.append(i_transformed[x, y+1])
pixels.append(i_transformed[x+1, y+1])
pixels.sort(reverse=True)
newImage[int(x/2),int(y/2)] = pixels[0]
# Plot the image. Note the size of the axes -- now 256 pixels instead of 512
plt.gray()
plt.grid(False)
plt.imshow(newImage)
#plt.axis('off')
plt.show()
Perhatikan sumbu plot tersebut. Gambar sekarang berukuran 256x256, seperempat dari ukuran aslinya, dan fitur yang terdeteksi telah ditingkatkan meskipun data yang ada dalam gambar sekarang lebih sedikit.
8. Selamat
Anda telah membuat model computer vision pertama Anda. Untuk mempelajari cara lebih meningkatkan kualitas model computer vision Anda, lanjutkan ke Membangun jaringan neural konvolusional (CNN) untuk meningkatkan kualitas computer vision.