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 itu. 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 masukan. Namun saat 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
