Pembelajaran mesin adalah alat yang luar biasa, dan tekniknya dapat digunakan untuk mengembangkan dan mengevaluasi jaringan saraf tingkat lanjut untuk klasifikasi gambar. Tapi bagaimana memulainya? Berikut adalah contoh menyenangkan yang dapat Anda lakukan dengan mengajari komputer mengidentifikasi perbedaan antara foto kucing dan anjing.
Pertama, mari kita pahami dengan cepat cara kerja Convolutional Neural Network (CNN). Jaringan saraf adalah sekelompok koneksi yang dibuat untuk meniru neuron di otak manusia — bukan sel, ini disebut node. Masing-masing node ini saling berhubungan dan dipisahkan oleh sekelompok lapisan. Koneksi ini ditetapkan ke bobot — seperti yang Anda lihat di bawah — yang dikalikan saat menerima data dari node berbeda.
Sekarang, ketika kita berbicara tentang gambar, jaringan saraf ditentukan oleh masing-masing piksel. Semakin besar gambarnya, semakin banyak jumlah node yang dibutuhkan. Untuk gambar RGB dengan 3 warna, katakanlah gambar berukuran 64x64 piksel, kita memerlukan: bobot 64x64x3 atau 12288. Bekerja dengan beberapa gambar yang lebih besar memerlukan tingkat kekuatan komputer yang tidak dapat ditangani oleh jaringan saraf pada umumnya.
Di sinilah peran jaringan saraf konvolusional. Bagaimana jika kita dapat memfilter masukan gambar yang besar ke peta data yang lebih kecil sehingga kita dapat memproses semua informasi ini dengan sumber daya yang kita miliki?
Dengan menggunakan operasi matematika konvolusi, hal ini dimungkinkan, dan gambar dikurangi sedemikian rupa sehingga fitur-fitur berharga tidak hilang selama proses tersebut. Anda dapat membaca lebih detail tentang teori tersebut di sini.
Sekarang mari kita pergi ke latihan yang menyenangkan. Keseluruhan pengembangan ini didasarkan pada "tutorial" bagus dari Jason Brownlee tentang Penguasaan Pembelajaran Mesin. Beberapa perubahan dilakukan untuk memastikan kode disesuaikan dengan lingkungan Kaggle lokal, dan juga memperbarui beberapa fungsi yang sekarang tidak digunakan lagi.
Pertama, ambil kumpulan data dari Kaggle yang disebut Anjing vs. Kucing, melalui Data › Unduh Semua. Saya sarankan untuk memeriksa terlebih dahulu dokumentasi tentang cara mengenal Kaggle Notebook jika Anda baru mengenal lingkungan ini. Jika Anda sudah terbiasa memprogram dengan Python dengan alat lain, seperti Google Colab dan Jupyter Notebook, ini akan sangat intuitif.
Impor Perpustakaan dan Pratinjau Foto
from matplotlib import pyplot
from matplotlib.image import imread
# location of dataset in your diretory
folder = '../input/d/biaiscience/dogs-vs-cats/train/train/'
# plot images
for i in range(3):
#subplot
pyplot.subplot(330 + 1 + i)
#filename - either is .cat or .dog
filename = folder + 'dog.' + str(i) + '.jpg'
# image pixels
image = imread(filename)
#raw pixel data
pyplot.imshow(image)
# show the figure
pyplot.show()
Untuk melihat pratinjau gambar kucing, ulangi saja prosesnya, hanya saja kali ini ganti variabel nama file menjadi:
filename = folder + ‘cat.’ + str(i) + ‘.jpg'
Anda akan melihat hasilnya di bawah ini (sangat menggemaskan!):
Pisahkan Kumpulan Data menjadi Subdirektori
Bagian pertama adalah mengatur direktori pelatihan dan pengujian untuk proyek Anda. Kita dapat mengatur rasio 25% gambar yang nantinya akan digunakan untuk validasi model. Inilah cara kerjanya:
# organize dataset into a useful structure
from os import makedirs
from os import listdir
from shutil import copyfile
from random import seed
from random import random
# create directories
dataset_home = 'dataset_dogs_vs_cats/'
subdirs = ['train/', 'test/']
for subdir in subdirs:
# create label subdirectories
labeldirs = ['dogs/', 'cats/']
for labldir in labeldirs:
newdir = dataset_home + subdir + labldir
makedirs(newdir, exist_ok=True)
# seed random number generator
seed(1)
# define ratio of pictures to use for validation
val_ratio = 0.25
# copy training dataset images into subdirectories
src_directory = 'train/'
for file in listdir(src_directory):
src = src_directory + '/' + file
dst_dir = 'train/'
if random() < val_ratio:
dst_dir = 'test/'
if file.startswith('cat'):
dst = dataset_home + dst_dir + 'cats/' + file
copyfile(src, dst)
elif file.startswith('dog'):
dst = dataset_home + dst_dir + 'dogs/' + file
copyfile(src, dst)
Tentukan Modelnya
Sekarang kami mengembangkan Model CNN agar dapat digunakan dengan kumpulan data Anjing vs Kucing. Idenya adalah untuk mendefinisikan lapisan dengan satu blok VGG (Visual Geometry Group), dengan kedalaman 32 dengan filter 3x3, lapisan penggabungan maksimal, dan menggunakan fungsi aktivasi ReLU. Untuk contoh ini, kami hanya menggunakan satu lapisan, namun dimungkinkan untuk menambahkan lebih banyak blok VGG, misalnya, dengan kedalaman berbeda (mis.: 64, 128), tepat setelah blok pertama yang dijelaskan di bawah.
from tensorflow.keras.optimizers import SGD
from keras.models import Sequential
from keras.layers import Conv2D
from keras.layers import MaxPooling2D
from keras.layers import Flatten
from keras.layers import Dense
from keras.layers import Dropout
# define cnn model
def define_model():
model = Sequential()
model = Sequential()
# block 1
model.add(Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same', input_shape=(200, 200, 3)))
model.add(MaxPooling2D((2, 2)))
model.add(Flatten())
model.add(Dense(128, activation='relu', kernel_initializer='he_uniform'))
model.add(Dense(1, activation='sigmoid'))
# compile model
opt = SGD(learning_rate=0.001, momentum=0.9)
model.compile(optimizer=opt, loss='binary_crossentropy', metrics=['accuracy'])
return model
model = define_model()
Menskalakan Gambar dan Mempersiapkan Iterator
Data perlu disiapkan dan diskalakan sebelum Anda mulai melatih model. Kami melakukannya dengan mengatur piksel ke kisaran 0 hingga 1, menggunakan ‹rescale = 1.0/255.0› dalam fungsi ImageDataGenerator dari Keras. Setelah itu, kita menggunakan fungsi flow_from_directory() untuk menentukan ukuran yang ditargetkan sebesar 200x200 piksel untuk gambar di direktori train dantest.
# create data generator
from keras.preprocessing.image import ImageDataGenerator
datagen = ImageDataGenerator(rescale=1.0/255.0)
# prepare iterators
train_it = datagen.flow_from_directory('dataset_dogs_vs_cats/train/',
class_mode='binary', batch_size=64, target_size=(200, 200))
test_it = datagen.flow_from_directory('dataset_dogs_vs_cats/test/',
class_mode='binary', batch_size=64, target_size=(200, 200))
Anda akan mendapatkan hasil sebagai berikut:
› Ditemukan 18697 gambar milik 2 kelas.
› Ditemukan 6303 gambar milik 2 kelas.
Menyesuaikan dan Mengevaluasi Model
Setelah mengatur iterator dengan gambar dari direktori masukan kereta dan pengujian, model dapat disesuaikan. Di bawah ini, saya menggunakan total 20 epoch, yang merupakan berapa kali model tersebut belajar. Hal ini dapat ditingkatkan untuk menjamin akurasi; namun, penting untuk memastikan bahwa model berfungsi saat pengujian dengan gambar yang tidak digunakan selama langkah pelatihan.
# fit model
history = model.fit(train_it, steps_per_epoch=len(train_it),
validation_data=test_it, validation_steps=len(test_it), epochs=20, verbose=0)
Setelah itu, Anda dapat memeriksa persentase keakuratan model:
# evaluate model
_, acc = model.evaluate(test_it, steps=len(test_it), verbose=0)
print('> %.3f' % (acc * 100.0),'%')
Jika Anda menggunakan satu lapisan saja seperti yang dijelaskan di atas, Anda akan mendapatkan keluaran sebagai berikut:
> 72.553%
Uji Prediksi dengan Contoh Gambar Uji
Sekarang kita dapat memeriksa dua contoh hasil prediksi model berdasarkan contoh gambar dari direktori pengujian.
from keras.preprocessing.image import load_img
from keras.preprocessing.image import img_to_array
# load and prepare the image
img = load_img('dataset_dogs_vs_cats/test/dogs/dog.2163.jpg', target_size=(200, 200))
img = img_to_array(img)
img = img.reshape(1, 200, 200, 3)
img = img.astype('float32')
img = img - [123.68, 116.779, 103.939]
result = model.predict(img)
result
Anda mendapatkan output berikut:
›› larik([[1.]], dtype=float32)
Hal ini benar karena “1” berarti model memperkirakan bahwa foto tersebut berasal dari seekor anjing.
Selanjutnya, mari kita ulangi pengujiannya tetapi dengan gambar kucing:
img = load_img('dataset_dogs_vs_cats/test/cats/cat.6428.jpg', target_size=(200, 200))
img = img_to_array(img)
img = img.reshape(1, 200, 200, 3)
img = img.astype('float32')
img = img - [123.68, 116.779, 103.939]
result = model.predict(img)
result
Anda akan mendapatkan hasil sebagai berikut:
›› larik([[0.]], dtype=float32)
Ini benar karena “0” berarti model memperkirakan bahwa foto tersebut berasal dari kucing.
—
Saya harap Anda menikmati tutorial ini. Jangan ragu untuk menjelajahi artikel lain saya tentang karier teknologi, atau hubungi saya melalui Linkedin.
Coding yang bagus untuk Anda semua!
