Do You Know VGG 16? – Towards AI

Do You Know VGG 16? – Towards AI

Author(s): Chinmay Bhalerao

Awalnya diterbitkan di Menuju AI.

VGG 16 dari awal dengan implementasi python

Gambar dibuat oleh Dalle.2

“Sejauh ini, bahaya terbesar dari Kecerdasan Buatan adalah orang menyimpulkan terlalu dini bahwa mereka memahaminya.”

— Eliezer Yudkowsky

Selalu ada arsitektur atau kerangka kerja yang muncul dan mengubah keseluruhan skenario domain tersebut. VGG 16 adalah arsitektur CNN pertama dengan prinsip desain dan perencanaan lapisan yang sistematis. Banyak arsitektur lain bergantung pada VGG dan menggunakan struktur ini sebagai basis.

Mari kita mulai dengan,

Mengapa kita membutuhkan jaringan saraf Convolutional dan arsitekturnya? Mengapa kita tidak bisa menggunakan ANN atau multi-layer perceptron untuk gambar?

Berikut ini adalah alasannya:

Kami harus mengirim gambar sebagai gambar rata untuk setiap piksel yang akan bertindak sebagai input. Namun ketika gambar diratakan, ada kehilangan informasi spasial. [Spatial information: information related to objects’ topography, geometry, reference, etc.]
Menangani begitu banyak piksel sebagai bobot dan bias akan menyebabkan masalah hilangnya gradien, dan itu akan menyebabkan masalah besar saat menangani data gambar. Bahkan jika kami membuat peta fitur dengan MLP, tetapi sedikit terjemahan akan merusak segalanya. di CNN, kami memiliki opsi seperti Pooling yang kami gunakan

sebuah. Peta fitur downsample

b. Invarian model untuk terjemahan lokal

Karena alasan ini, kami memerlukan CNN dan arsitekturnya.

Di atas CNN, banyak arsitektur dibangun dalam periode waktu tertentu, seperti AlexNet, ZFNet[ A Bigger AlexNet]GoogLeNet, Jaringan Residual, dan banyak lagi…

Di blog ini, mari kita pahami VGG dan variasinya dari awal.

Apa itu VGG?

Ini adalah desain Jaringan Neural Convolutional (CNN) yang dalam dengan banyak lapisan, dan singkatan VGG adalah singkatan dari Visual Geometry Group.

Sumber: Makalah dengan kode

Istilah “dalam” menggambarkan jumlah lapisan, dengan VGG-16 atau VGG-19 masing-masing memiliki 16 atau 19 lapisan konvolusional. Model identifikasi objek yang inovatif dibangun menggunakan arsitektur VGG. VGGNet, dibuat sebagai jaringan saraf yang dalam, mengungguli tolok ukur pada berbagai tugas dan kumpulan data di luar ImageNet. Itu juga tetap menjadi salah satu arsitektur pengenalan gambar yang paling sering digunakan saat ini.

Model VGG pertama kali diusulkan oleh Andrew Zisserman dan Karen Simonyan pada tahun 2013, dan prototipe dibuat untuk Tantangan ImageNet 2014. Mereka adalah bagian dari Kelompok Geometri Visual Oxford (VGG).

16 lapisan convolutional VGGNet-16 cukup menarik, dan arsitekturnya sangat konsisten. Ini memiliki beberapa filter tetapi hanya konvolusi 3×3, seperti AlexNet. Pada 4 GPU, dapat dilatih selama dua hingga tiga minggu.

Sumber: Catatan kuliah Justin Johnson dari Universitas Michigan

Mari kita lihat setiap lapisan secara detail.

Jadi 16 atau 19 dalam VGG16 atau VGG19 menunjukkan jumlah lapisan dalam arsitektur. Penulis menyebut makalah ini sebagai jaringan yang lebih dalam lebih baik daripada yang lebih panjang. Daripada menambahkan lapisan secara acak ke jaringan, penulis memutuskan untuk menetapkan beberapa aturan untuk desain.

Semua lapisan convolutional harus berisi 3×3 langkah 1 pad 1

Semua layer penyatuan maksimal harus memiliki langkah 2×2

Setelah penyatuan, gandakan jumlah saluran

Ini membuat standar desain.

Sumber: Makalah dengan kode

Mari kita mulai pengkodean awal dengan mengimpor perpustakaan.

impor cv2
impor keras
impor tensorflow sebagai tf
impor matplotlib.pyplot sebagai plt
impor numpy sebagai np
dari tensorflow.keras.layers impor Conv2D
dari tensorflow.keras.layers mengimpor MaxPooling2D
dari impor keras.layers Padat, Aktivasi, Ratakan
dari impor keras.preprocessing.image ImageDataGenerator
tf.random.set_seed(0)

Sekarang kita akan membaca dan mengekstrak data gambar

trdata = ImageDataGenerator()
traindata = trdata.flow_from_directory(directory=”C:/Users/ChinmayB/BPProject/train”,target_size=(224,224))
tsdata = ImageDataGenerator()
testdata = tsdata.flow_from_directory(directory=”C:/Users/ChinmayB/BPProject/test”, target_size=(224,224))

Kami akan menggunakan model berurutan di sini.

model = keras.Sequential()

Mari tulis blok pertama yang sebenarnya untuk jaringan.

######## BLOK 1 ########

model.add(Conv2D(64, kernel_size = (3,3),padding = ‘sama’,aktivasi = “relu”,input_shape = (224,224,3)))
model.add(Conv2D(64, kernel_size = (3,3),padding = ‘sama’, aktivasi = “relu”))
model.tambahkan(MaxPooling2D(pool_size=(2, 2), langkah=(2,2)))

Sekarang dengan cara yang sama kita akan membangun semua blok dan lapisan

######## BLOK 1 ########

model.add(Conv2D(64, kernel_size = (3,3),padding = ‘sama’,aktivasi = “relu”,input_shape = (224,224,3)))
model.add(Conv2D(64, kernel_size = (3,3),padding = ‘sama’, aktivasi = “relu”))
model.tambahkan(MaxPooling2D(pool_size=(2, 2), langkah=(2,2)))

######## BLOK2 ########

model.add(Conv2D(128, kernel_size = (3,3),padding = ‘sama’, aktivasi = “relu”))
model.add(Conv2D(128, kernel_size = (3,3),padding = ‘sama’, aktivasi = “relu”))
model.tambahkan(MaxPooling2D(pool_size=(2, 2), langkah=(2,2)))

######## BLOK3 ########

model.add(Conv2D(256, kernel_size = (3,3),padding = ‘sama’, aktivasi = “relu”))
model.add(Conv2D(256, kernel_size = (3,3),padding = ‘sama’, aktivasi = “relu”))
model.add(Conv2D(256, kernel_size = (3,3),padding = ‘sama’, aktivasi = “relu”))
model.tambahkan(MaxPooling2D(pool_size=(2, 2), langkah=(2,2)))

######## BLOK4 ########

model.add(Conv2D(512, kernel_size = (3,3),padding = ‘sama’, aktivasi = “relu”))
model.add(Conv2D(512, kernel_size = (3,3),padding = ‘sama’, aktivasi = “relu”))
model.add(Conv2D(512, kernel_size = (3,3),padding = ‘sama’, aktivasi = “relu”))
model.tambahkan(MaxPooling2D(pool_size=(2, 2), langkah=(2,2)))

######## BLOK5 ########

model.add(Conv2D(512, kernel_size = (3,3),padding = ‘sama’, aktivasi = “relu”))
model.add(Conv2D(512, kernel_size = (3,3),padding = ‘sama’, aktivasi = “relu”))
model.add(Conv2D(512, kernel_size = (3,3),padding = ‘sama’, aktivasi = “relu”))
model.tambahkan(MaxPooling2D(pool_size=(2, 2), langkah=(2,2)))

######## Padat ########

model.tambahkan(Ratakan())
model.add(Padat(4096,aktivasi = ‘relu’))
model.add(Padat(4096,aktivasi = ‘relu’))
model.add(Padat(3, aktivasi = “softmax”))

Setelah menulis semua layer di jaringan, akhirnya kita akan membangun modelnya.

model.build()
model.ringkasan()

Kita bisa melihat total file config dan berapa banyak parameter yang kita miliki.

Model: “berurutan”
_________________________________________________________________
Lapisan (tipe) Param Bentuk Keluaran #
================================================== ===============
conv2d (Conv2D) (Tidak ada, 224, 224, 64) 1792

conv2d_1 (Conv2D) (Tidak ada, 224, 224, 64) 36928

max_pooling2d (MaxPooling2D (Tidak ada, 112, 112, 64) 0
)

conv2d_2 (Conv2D) (Tidak ada, 112, 112, 128) 73856

conv2d_3 (Conv2D) (Tidak ada, 112, 112, 128) 147584

max_pooling2d_1 (MaxPooling (Tidak Ada, 56, 56, 128) 0
2D)

conv2d_4 (Conv2D) (Tidak ada, 56, 56, 256) 295168

conv2d_5 (Conv2D) (Tidak ada, 56, 56, 256) 590080

conv2d_6 (Conv2D) (Tidak ada, 56, 56, 256) 590080

max_pooling2d_2 (MaxPooling (Tidak ada, 28, 28, 256) 0
2D)

conv2d_7 (Conv2D) (Tidak ada, 28, 28, 512) 1180160

conv2d_8 (Conv2D) (Tidak ada, 28, 28, 512) 2359808

conv2d_9 (Conv2D) (Tidak ada, 28, 28, 512) 2359808

max_pooling2d_3 (MaxPooling (Tidak Ada, 14, 14, 512) 0
2D)

conv2d_10 (Conv2D) (Tidak ada, 14, 14, 512) 2359808

conv2d_11 (Conv2D) (Tidak ada, 14, 14, 512) 2359808

conv2d_12 (Conv2D) (Tidak ada, 14, 14, 512) 2359808

max_pooling2d_4 (MaxPooling (Tidak Ada, 7, 7, 512) 0
2D)

ratakan (Ratakan) (Tidak ada, 25088) 0

padat (Padat) (Tidak ada, 4096) 102764544

padat_1 (Padat) (Tidak ada, 4096) 16781312

padat_2 (Padat) (Tidak ada, 3) 12291

Terakhir, kami menambahkan jaringan saraf biasa atau jaringan rata karena itu akan menjadi simpul keputusan kami. Ini adalah jaringan pertama yang memiliki prinsip untuk mendesain.

hasil = model.prediksi(np.array([img]))
cetak(hasil)

Ada banyak keunggulan VGG dibanding pendahulunya.

Sumber: Catatan kuliah Justin Johnson dari Universitas Michigan

Komunitas sekarang melihatnya sebagai opsi terbaik untuk mengekstraksi karakteristik dari foto. Konfigurasi bobot VGGNet dapat diakses secara terbuka dan telah digunakan sebagai ekstraktor fitur standar dalam berbagai aplikasi dan tantangan yang berbeda. Sesuai makalahnya, VGG 16 mampu mengklasifikasikan 1000 gambar dari 1000 kategori berbeda dengan akurasi 92,7%.

Jika Anda menemukan artikel ini berwawasan

Jika Anda menemukan artikel ini berwawasan, ikuti saya di Linkedin dan medium. Anda juga dapat berlangganan untuk mendapatkan pemberitahuan ketika saya menerbitkan artikel. Ayo buat komunitas! Terima kasih atas dukunganmu!

Jika Anda ingin mendukung saya:

Mengikuti dan bertepuk tangan Anda adalah hal yang paling penting, tetapi Anda juga dapat mendukung saya dengan membeli kopi. KOPI.

Anda juga dapat membaca blog saya yang terkait dengan

Tanda tangan,

CHINMAY BHALERAO

Apakah Anda Tahu VGG 16? awalnya diterbitkan di Menuju AI di Medium, di mana orang melanjutkan percakapan dengan menyoroti dan menanggapi cerita ini.

Diterbitkan melalui Menuju AI

Author: Jonathan Kelly