Tutorial Autoencoder sebagai Klasifikator menggunakan Dataset Fashion-MNIST
Dalam tutorial ini, Anda akan mempelajari dan memahami cara menggunakan autoencoder sebagai pengklasifikasi di Python dengan Keras. Anda akan menggunakan dataset Fashion-MNIST sebagai contoh.
Catatan: Tutorial ini terutama akan membahas implementasi praktis klasifikasi menggunakan convolutional neural network dan convolutional autoencoder. Jadi, jika Anda belum familiar dengan convolutional neural network (CNN) dan autoencoder, Anda mungkin ingin melihat tutorial CNN dan Autoencoder.
Secara lebih spesifik, Anda akan membahas topik-topik berikut dalam tutorial hari ini:
Setelah itu, Anda akan mempraolah data: Anda akan belajar cara mengubah ukuran, penskalaan ulang data, memverifikasi tipe data gambar, dan membagi data menjadi set pelatihan dan validasi.
Setelah semua selesai, Anda dapat membangun model convolutional autoencoder: Anda akan belajar cara memodelkan data dan membentuk jaringan. Selanjutnya, Anda akan melakukan kompilasi, melatih model, memvisualisasikan plot akurasi dan loss, dan akhirnya menyimpan model.
Berikutnya, Anda akan menyegmentasi data fashion-mnist: pertama Anda akan mengonversi label menjadi vektor one-hot encoding, membagi gambar pelatihan dan validasi beserta labelnya masing-masing. Lalu Anda akan mendefinisikan fungsi encoder yang sama seperti pada arsitektur autoencoder, diikuti dengan lapisan fully connected.
Anda akan belajar cara memuat bobot dari model terlatih ke beberapa lapisan model baru, memverifikasi matriks bobot model terlatih dan model baru, menjadikan beberapa lapisan model baru tidak dapat dilatih, dan akhirnya mengompilasi model klasifikasi baru, melatih model, serta menyimpan bobotnya.
Anda akan melatih ulang model dengan semua lapisan dapat dilatih, mengevaluasi model, memvisualisasikan plot akurasi dan loss, membuat prediksi pada data uji, mengonversi probabilitas menjadi label kelas dan memplot beberapa sampel uji yang diklasifikasikan dengan benar maupun salah oleh model Anda.
Terakhir, Anda akan memvisualisasikan laporan klasifikasi yang akan memberi Anda intuisi lebih mendalam tentang kelas mana yang (tidak) diklasifikasikan dengan benar oleh model Anda.
Kumpulan Data Fashion-MNIST
Sebelum mulai memuat dataset dan memprosesnya, ada baiknya memiliki gambaran singkat tentang seperti apa jenis datasetnya, bagaimana dimensinya, dan berapa banyak kelas berbeda yang ada dalam dataset.
Dataset Fashion-MNIST berisi gambar grayscale 28x28 dari 70.000 produk fesyen dari 10 kategori, dengan 7.000 gambar per kategori. Set pelatihan memiliki 60.000 gambar, dan set pengujian memiliki 10.000 gambar. Fashion-MNIST merupakan pengganti dataset MNIST asli untuk menghasilkan hasil yang lebih baik; dimensi gambar serta pembagian pelatihan dan uji serupa dengan dataset MNIST asli. Dataset ini tersedia gratis di URL ini dan dapat dimuat menggunakan tensorflow maupun keras sebagai kerangka kerja tanpa harus mengunduhnya ke komputer Anda.
Mirip dengan MNIST, Fashion-MNIST juga terdiri dari 10 kelas, tetapi alih-alih digit tulisan tangan, kita memiliki 10 kelas aksesori fesyen yang berbeda seperti sandal, kemeja, celana, dan sebagainya.
Tugas Anda adalah melatih convolutional autoencoder dan menggunakan bagian encoder dari autoencoder yang digabungkan dengan lapisan fully connected untuk mengenali sampel baru dari set uji secara benar.
Tip: jika Anda ingin belajar cara mengimplementasikan Multi-Layer Perceptron (MLP) untuk tugas klasifikasi dengan dataset MNIST, lihat tutorial ini.
Pada kode di bawah, Anda pada dasarnya menetapkan variabel lingkungan di notebook menggunakan os.environ. Sebaiknya lakukan hal berikut sebelum menginisialisasi Keras untuk membatasi backend TensorFlow Keras agar menggunakan GPU pertama. Jika mesin tempat Anda melatih memiliki GPU di 0, pastikan menggunakan 0 alih-alih 1. Anda bisa memeriksanya dengan menjalankan perintah sederhana di terminal: misalnya, nvidia-smi
import os
os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"]="0"#model will be trained on GPU 0Didukung oleh
Memuat Data
Selanjutnya, Anda mengimpor semua modul yang diperlukan seperti numpy, matplotlib, dan yang terpenting Keras, karena dalam tutorial hari ini Anda akan menggunakan keras sebagai kerangka kerja!
import keras
from matplotlib import pyplot as plt
import numpy as np
import gzip
%matplotlib inline
from keras.models import Model
from keras.optimizers import RMSprop
from keras.layers import Input,Dense,Flatten,Dropout,merge,Reshape,Conv2D,MaxPooling2D,UpSampling2D,Conv2DTranspose
from keras.layers.normalization import BatchNormalization
from keras.models import Model,Sequential
from keras.callbacks import ModelCheckpoint
from keras.optimizers import Adadelta, RMSprop,SGD,Adam
from keras import regularizers
from keras import backend as K
from keras.utils import to_categorical
Didukung oleh
Using TensorFlow backend./usr/local/lib/python2.7/dist-packages/h5py/__init__.py:34: FutureWarning: Conversion of the second argument of issubdtype from`float` to `np.floating` is deprecated. In future, it will be treated as`np.float64 == np.dtype(float).type`.
from ._conv import register_converters as _register_converters
Didukung oleh
Di sini, Anda mendefinisikan fungsi yang membuka file gzip, membaca file menggunakan bytestream.read(). Anda meneruskan dimensi gambar dan jumlah total gambar ke fungsi ini. Lalu, menggunakan np.frombuffer(), Anda mengonversi string yang disimpan dalam variabel buf menjadi array NumPy bertipe float32.
Setelah dikonversi menjadi array NumPy, Anda membentuk ulang array menjadi array tiga dimensi atau tensor di mana dimensi pertama adalah jumlah gambar, dan dimensi kedua dan ketiga adalah dimensi gambar. Terakhir, Anda mengembalikan array NumPy data.
defextract_data(filename, num_images):with gzip.open(filename)as bytestream:
bytestream.read(16)
buf = bytestream.read(28*28* num_images)
data = np.frombuffer(buf, dtype=np.uint8).astype(np.float32)
data = data.reshape(num_images,28,28)return data
Didukung oleh
Sekarang Anda akan memanggil fungsi extract_data() dengan meneruskan file pelatihan dan pengujian beserta jumlah gambar masing-masing.
train_data = extract_data('train-images-idx3-ubyte.gz',60000)
test_data = extract_data('t10k-images-idx3-ubyte.gz',10000)Didukung oleh
Demikian pula, Anda mendefinisikan fungsi ekstraksi label yang membuka file gzip, membaca file menggunakan bytestream.read(), yang Anda beri dimensi label (1) dan jumlah total gambar. Lalu, menggunakan np.frombuffer(), Anda mengonversi string yang disimpan dalam variabel buf menjadi array NumPy bertipe int64.
Kali ini, Anda tidak perlu membentuk ulang array karena variabel labels akan mengembalikan vektor kolom berdimensi 60.000 x 1. Terakhir, Anda mengembalikan array NumPy labels.
Sekarang Anda akan memanggil fungsi ekstrak label dengan meneruskan file label pelatihan dan pengujian beserta jumlah gambar masing-masing.
train_labels = extract_labels('train-labels-idx1-ubyte.gz',60000)
test_labels = extract_labels('t10k-labels-idx1-ubyte.gz',10000)Didukung oleh
Setelah Anda memuat data pelatihan dan pengujian, Anda siap untuk menganalisis data guna mendapatkan intuisi tentang dataset yang akan Anda gunakan dalam tutorial hari ini!
Eksplorasi Data
Sekarang mari kita analisis seperti apa tampilan gambar dalam dataset dan lihat juga dimensi gambarnya dengan bantuan atribut array NumPy .shape:
# Shapes of training setprint("Training set (images) shape: {shape}".format(shape=train_data.shape))# Shapes of test setprint("Test set (images) shape: {shape}".format(shape=test_data.shape))Didukung oleh
Training set(images) shape:(60000,28,28)
Test set(images) shape:(10000,28,28)Didukung oleh
Dari output di atas, Anda dapat melihat bahwa data pelatihan memiliki bentuk 60000 x 28 x 28 karena ada 60.000 sampel pelatihan masing-masing berupa matriks berdimensi 28 x 28. Demikian pula, data uji memiliki bentuk 10000 x 28 x 28 karena ada 10.000 sampel uji.
Catatan bahwa dalam tugas rekonstruksi menggunakan convolutional autoencoder Anda tidak memerlukan label pelatihan dan pengujian. Gambar pelatihan Anda akan berperan sebagai masukan sekaligus ground truth mirip dengan label yang Anda miliki pada tugas klasifikasi.
Namun untuk tugas klasifikasi Anda juga akan membutuhkan label beserta gambar, yang akan Anda lakukan nanti dalam tutorial. Meskipun tugas saat ini hanya berurusan dengan gambar pelatihan dan pengujian, untuk tujuan eksplorasi yang mungkin memberi Anda intuisi lebih baik tentang data, Anda akan memanfaatkan label.
Mari buat kamus yang berisi nama kelas dengan label kelas kategorikal yang sesuai:
# Create dictionary of target classes
label_dict ={0:'A',1:'B',2:'C',3:'D',4:'E',5:'F',6:'G',7:'H',8:'I',9:'J',}Didukung oleh
Sekarang, mari lihat beberapa gambar dalam dataset Anda:
plt.figure(figsize=[5,5])# Display the first image in training data
plt.subplot(121)
curr_img = np.reshape(train_data[10],(28,28))
curr_lbl = train_labels[10]
plt.imshow(curr_img, cmap='gray')
plt.title("(Label: "+str(label_dict[curr_lbl])+")")# Display the first image in testing data
plt.subplot(122)
curr_img = np.reshape(test_data[10],(28,28))
curr_lbl = test_labels[10]
plt.imshow(curr_img, cmap='gray')
plt.title("(Label: "+str(label_dict[curr_lbl])+")")Didukung oleh
Keluaran dari dua plot di atas adalah salah satu gambar sampel dari data pelatihan dan pengujian, dan gambar-gambar ini diberi label kelas 0 atau A di satu sisi, dan 4 atau E di sisi lain. Demikian pula, alfabet lain akan memiliki label berbeda, tetapi alfabet yang sama akan memiliki label yang sama. Ini berarti semua 6.000 gambar kelas E akan memiliki label kelas 4.
Prapemrosesan Data
Gambar dalam dataset memang merupakan gambar grayscale dengan nilai piksel antara 0 hingga 255 dengan dimensi 28 x 28, jadi sebelum kita memasukkan data ke dalam model, sangat penting untuk memprosesnya terlebih dahulu. Anda akan terlebih dahulu mengonversi setiap gambar 28 x 28 dari set train dan test menjadi matriks berukuran 28 x 28 x 1, yang dapat Anda masukkan ke dalam jaringan:
train_data = train_data.reshape(-1,28,28,1)
test_data = test_data.reshape(-1,28,28,1)
train_data.shape, test_data.shape
Didukung oleh
Selanjutnya, pastikan untuk memeriksa tipe data array NumPy pelatihan dan pengujian, seharusnya dalam format float32; jika tidak, Anda perlu mengonversinya ke format ini, tetapi karena Anda sudah mengonversinya saat membaca data, Anda tidak perlu melakukannya lagi. Anda juga harus melakukan penskalaan ulang nilai piksel ke rentang 0 - 1 inklusif. Mari kita lakukan!
Jangan lupa untuk memverifikasi tipe data pelatihan dan pengujian:
Setelah semua ini, penting untuk melakukan partisi data. Agar model kita dapat melakukan generalisasi dengan baik, Anda membagi data pelatihan menjadi dua bagian: set pelatihan dan validasi. Anda akan melatih model pada 80% data dan memvalidasinya pada 20% sisa data pelatihan.
Ini juga akan membantu mengurangi kemungkinan overfitting, karena Anda akan memvalidasi model pada data yang tidak dilihat saat fase pelatihan.
Anda dapat menggunakan modul train_test_split dari scikit-learn untuk membagi data dengan benar:
from sklearn.model_selection import train_test_split
train_X,valid_X,train_ground,valid_ground = train_test_split(train_data,
train_data,
test_size=0.2,
random_state=13)Didukung oleh
Catatan: Anda akan menggunakan pembagian data di atas dua kali, sekali untuk tugas rekonstruksi menggunakan convolutional autoencoder yang tidak memerlukan label pelatihan dan pengujian. Itulah sebabnya Anda akan meneruskan gambar pelatihan dua kali. Gambar pelatihan Anda akan berperan sebagai masukan sekaligus ground truth mirip dengan label yang Anda miliki pada tugas klasifikasi.
Namun untuk tugas klasifikasi, Anda juga akan meneruskan label beserta gambar yang akan Anda lakukan nanti dalam tutorial.
Sekarang Anda siap untuk mendefinisikan jaringan dan memasukkan data ke dalam jaringan. Jadi tanpa berlama-lama, mari lanjut ke langkah berikutnya!
Convolutional Autoencoder
Gambar berukuran 28 x 28 x 1 atau vektor berdimensi 30976. Anda mengonversi matriks gambar menjadi array, melakukan penskalaan ulang antara 0 dan 1, membentuk ulang sehingga berukuran 28 x 28 x 1, dan memasukkan ini sebagai input ke jaringan.
Selain itu, Anda akan menggunakan ukuran batch 128; menggunakan ukuran batch yang lebih besar 256 atau 512 juga dapat dipertimbangkan—semuanya bergantung pada sistem tempat Anda melatih model. Ini sangat berkontribusi dalam menentukan parameter pembelajaran dan memengaruhi akurasi prediksi.
batch_size =64
epochs =200
inChannel =1
x, y =28,28
input_img = Input(shape =(x, y, inChannel))
num_classes =10Didukung oleh
Seperti yang mungkin sudah Anda ketahui, autoencoder terbagi menjadi dua bagian: encoder dan decoder.
Encoder: Memiliki 4 blok Konvolusi, tiap blok memiliki lapisan konvolusi diikuti lapisan normalisasi batch. Lapisan max-pooling digunakan setelah blok konvolusi pertama dan kedua.
Blok konvolusi pertama memiliki 32 filter berukuran 3 x 3, diikuti lapisan downsampling (max-pooling),
Blok kedua memiliki 64 filter berukuran 3 x 3, diikuti lapisan downsampling lainnya,
Blok ketiga encoder memiliki 128 filter berukuran 3 x 3,
Blok keempat encoder memiliki 256 filter berukuran 3 x 3.
Decoder: Memiliki 3 blok Konvolusi, tiap blok memiliki lapisan konvolusi diikuti lapisan normalisasi batch. Lapisan upsampling digunakan setelah blok konvolusi kedua dan ketiga.
Blok pertama memiliki 128 filter berukuran 3 x 3,
Blok kedua memiliki 64 filter berukuran 3 x 3 diikuti lapisan upsampling,
Blok ketiga memiliki 32 filter berukuran 3 x 3 diikuti lapisan upsampling,
Lapisan terakhir encoder memiliki 1 filter berukuran 3 x 3 yang akan merekonstruksi kembali input yang memiliki satu kanal.
Lapisan max-pooling akan melakukan downsampling input sebanyak dua kali setiap kali digunakan, sementara lapisan upsampling akan melakukan upsampling input sebanyak dua kali setiap kali digunakan.
Catatan: Jumlah filter, ukuran filter, jumlah lapisan, jumlah epoch pelatihan model, semuanya adalah hiperparameter dan harus diputuskan berdasarkan intuisi Anda sendiri; Anda bebas mencoba eksperimen baru dengan mengutak-atik hiperparameter ini dan mengukur performa model Anda. Dan dari situlah Anda perlahan belajar seni deep learning!
Mari buat fungsi encoder dan decoder terpisah karena Anda akan menggunakan bobot encoder nanti untuk tujuan klasifikasi!
defencoder(input_img):#encoder#input = 28 x 28 x 1 (wide and thin)
conv1 = Conv2D(32,(3,3), activation='relu', padding='same')(input_img)#28 x 28 x 32
conv1 = BatchNormalization()(conv1)
conv1 = Conv2D(32,(3,3), activation='relu', padding='same')(conv1)
conv1 = BatchNormalization()(conv1)
pool1 = MaxPooling2D(pool_size=(2,2))(conv1)#14 x 14 x 32
conv2 = Conv2D(64,(3,3), activation='relu', padding='same')(pool1)#14 x 14 x 64
conv2 = BatchNormalization()(conv2)
conv2 = Conv2D(64,(3,3), activation='relu', padding='same')(conv2)
conv2 = BatchNormalization()(conv2)
pool2 = MaxPooling2D(pool_size=(2,2))(conv2)#7 x 7 x 64
conv3 = Conv2D(128,(3,3), activation='relu', padding='same')(pool2)#7 x 7 x 128 (small and thick)
conv3 = BatchNormalization()(conv3)
conv3 = Conv2D(128,(3,3), activation='relu', padding='same')(conv3)
conv3 = BatchNormalization()(conv3)
conv4 = Conv2D(256,(3,3), activation='relu', padding='same')(conv3)#7 x 7 x 256 (small and thick)
conv4 = BatchNormalization()(conv4)
conv4 = Conv2D(256,(3,3), activation='relu', padding='same')(conv4)
conv4 = BatchNormalization()(conv4)return conv4
defdecoder(conv4):#decoder
conv5 = Conv2D(128,(3,3), activation='relu', padding='same')(conv4)#7 x 7 x 128
conv5 = BatchNormalization()(conv5)
conv5 = Conv2D(128,(3,3), activation='relu', padding='same')(conv5)
conv5 = BatchNormalization()(conv5)
conv6 = Conv2D(64,(3,3), activation='relu', padding='same')(conv5)#7 x 7 x 64
conv6 = BatchNormalization()(conv6)
conv6 = Conv2D(64,(3,3), activation='relu', padding='same')(conv6)
conv6 = BatchNormalization()(conv6)
up1 = UpSampling2D((2,2))(conv6)#14 x 14 x 64
conv7 = Conv2D(32,(3,3), activation='relu', padding='same')(up1)# 14 x 14 x 32
conv7 = BatchNormalization()(conv7)
conv7 = Conv2D(32,(3,3), activation='relu', padding='same')(conv7)
conv7 = BatchNormalization()(conv7)
up2 = UpSampling2D((2,2))(conv7)# 28 x 28 x 32
decoded = Conv2D(1,(3,3), activation='sigmoid', padding='same')(up2)# 28 x 28 x 1return decoded
Didukung oleh
Setelah model dibuat, Anda harus mengompilasinya menggunakan optimizer RMSProp.
Perhatikan bahwa Anda juga harus menentukan jenis loss melalui argumen loss. Dalam kasus ini, yaitu mean squared error, karena loss setelah setiap batch akan dihitung antara batch keluaran yang diprediksi dan ground truth menggunakan mean squared error per piksel:
autoencoder = Model(input_img, decoder(encoder(input_img)))
autoencoder.compile(loss='mean_squared_error', optimizer = RMSprop())Didukung oleh
Mari visualisasikan lapisan yang Anda buat pada langkah di atas menggunakan fungsi summary. Ini akan menampilkan jumlah parameter (bobot dan bias) di setiap lapisan dan juga total parameter dalam model Anda.
Akhirnya saatnya melatih model dengan fungsi fit() Keras! Model dilatih selama 200 epoch. Fungsi fit() akan mengembalikan objek history; Dengan menyimpan hasil fungsi ini pada autoencoder_train, Anda dapat menggunakannya nanti untuk memplot kurva loss antara pelatihan dan validasi yang akan membantu Anda menganalisis performa model secara visual.
Latih Model
autoencoder_train = autoencoder.fit(train_X, train_ground, batch_size=batch_size,epochs=epochs,verbose=1,validation_data=(valid_X, valid_ground))Didukung oleh
Akhirnya! Anda melatih model pada dataset fashion-mnist selama 100 epoch, Sekarang, mari plot kurva loss antara data pelatihan dan validasi untuk memvisualisasikan performa model.
loss = autoencoder_train.history['loss']
val_loss = autoencoder_train.history['val_loss']
epochs =range(200)
plt.figure()
plt.plot(epochs, loss,'bo', label='Training loss')
plt.plot(epochs, val_loss,'b', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()
plt.show()Didukung oleh
Akhirnya, Anda dapat melihat bahwa loss validasi dan loss pelatihan selaras. Ini menunjukkan bahwa model Anda tidak overfitting: loss validasi menurun dan tidak meningkat, dan jarang ada celah antara loss pelatihan dan validasi sepanjang fase pelatihan.
Karena itu, dapat dikatakan kemampuan generalisasi model Anda baik.
Tetapi ingat, tugas kita adalah menggunakan bagian encoder dari model yang telah dilatih di atas untuk mengklasifikasikan gambar fashion mnist. Jadi, mari lanjut ke bagian berikutnya sekarang!
Simpan Model
Karena Anda akan memerlukan bobot encoder dalam tugas klasifikasi, pertama mari simpan bobot autoencoder lengkap. Anda akan mempelajari cara mengekstrak bobot encoder segera.
autoencoder.save_weights('autoencoder.h5')Didukung oleh
Menyegmentasi Gambar Fashion Mnist
Sekarang Anda akan menggunakan bagian kepala autoencoder terlatih, yaitu bagian encoder, dan akan memuat bobot autoencoder yang baru saja Anda latih hanya ke bagian encoder dari model.
Anda akan menambahkan beberapa lapisan dense atau fully connected pada encoder untuk mengklasifikasikan gambar fashion mnist.
Mari terlebih dahulu mengonversi label menjadi vektor one-hot encoding.
Bagi Anda yang belum tahu tentang one-hot encoding:
Dalam one-hot encoding, Anda mengonversi data kategorikal menjadi vektor angka. Alasan mengapa Anda mengonversi data kategorikal ke one-hot encoding adalah karena algoritme pembelajaran mesin tidak dapat bekerja langsung dengan data kategorikal. Anda membuat satu kolom boolean untuk setiap kategori atau kelas. Hanya satu dari kolom ini yang dapat bernilai 1 untuk setiap sampel. Karena itulah disebut one-hot encoding.
Untuk pernyataan masalah Anda, one hot encoding akan berupa vektor baris, dan untuk setiap gambar, dimensinya 1 x 10. Hal penting yang perlu diperhatikan di sini adalah vektor terdiri dari semua nol kecuali untuk kelas yang diwakilinya, dan untuk kelas itu nilainya 1.
Jadi mari konversi label menjadi vektor one-hot encoding:
# Change the labels from categorical to one-hot encoding
train_Y_one_hot = to_categorical(train_labels)
test_Y_one_hot = to_categorical(test_labels)# Display the change for category label using one-hot encodingprint('Original label:', train_labels[0])print('After conversion to one-hot:', train_Y_one_hot[0])Didukung oleh
('Original label:',9)('After conversion to one-hot:',array([0.,0.,0.,0.,0.,0.,0.,0.,0.,1.]))Didukung oleh
Cukup jelas, bukan?
Langkah terakhir ini krusial dan sudah pernah Anda lakukan saat fase pelatihan autoencoder, yaitu membagi data menjadi pelatihan dan validasi. Jadi mari cepat lakukan langkah itu untuk klasifikasi juga. Perhatikan bahwa Anda akan menggunakan random state yang sama seperti sebelumnya dan kali ini Anda juga akan meneruskan label yang baru saja Anda konversi menjadi vektor one-hot encoding.
train_X,valid_X,train_label,valid_label = train_test_split(train_data,train_Y_one_hot,test_size=0.2,random_state=13)Didukung oleh
Untuk terakhir kalinya mari periksa bentuk set pelatihan dan validasi.
train_X.shape,valid_X.shape,train_label.shape,valid_label.shape
Didukung oleh
((48000,28,28,1),(12000,28,28,1),(48000,10),(12000,10))Didukung oleh
Sekarang, mari definisikan model klasifikasi. Ingat bahwa Anda akan menggunakan bagian encoder yang persis sama seperti yang digunakan pada arsitektur autoencoder.
defencoder(input_img):#encoder#input = 28 x 28 x 1 (wide and thin)
conv1 = Conv2D(32,(3,3), activation='relu', padding='same')(input_img)#28 x 28 x 32
conv1 = BatchNormalization()(conv1)
conv1 = Conv2D(32,(3,3), activation='relu', padding='same')(conv1)
conv1 = BatchNormalization()(conv1)
pool1 = MaxPooling2D(pool_size=(2,2))(conv1)#14 x 14 x 32
conv2 = Conv2D(64,(3,3), activation='relu', padding='same')(pool1)#14 x 14 x 64
conv2 = BatchNormalization()(conv2)
conv2 = Conv2D(64,(3,3), activation='relu', padding='same')(conv2)
conv2 = BatchNormalization()(conv2)
pool2 = MaxPooling2D(pool_size=(2,2))(conv2)#7 x 7 x 64
conv3 = Conv2D(128,(3,3), activation='relu', padding='same')(pool2)#7 x 7 x 128 (small and thick)
conv3 = BatchNormalization()(conv3)
conv3 = Conv2D(128,(3,3), activation='relu', padding='same')(conv3)
conv3 = BatchNormalization()(conv3)
conv4 = Conv2D(256,(3,3), activation='relu', padding='same')(conv3)#7 x 7 x 256 (small and thick)
conv4 = BatchNormalization()(conv4)
conv4 = Conv2D(256,(3,3), activation='relu', padding='same')(conv4)
conv4 = BatchNormalization()(conv4)return conv4
Didukung oleh
Mari definisikan lapisan fully connected yang akan Anda tumpuk dengan fungsi encoder.
deffc(enco):
flat = Flatten()(enco)
den = Dense(128, activation='relu')(flat)
out = Dense(num_classes, activation='softmax')(den)return out
Didukung oleh
encode = encoder(input_img)
full_model = Model(input_img,fc(encode))Didukung oleh
for l1,l2 inzip(full_model.layers[:19],autoencoder.layers[0:19]):
l1.set_weights(l2.get_weights())Didukung oleh
Catatan: Langkah berikut cukup penting. Untuk memastikan apakah bobot pada bagian encoder autoencoder serupa dengan bobot yang Anda muat ke fungsi encoder model klasifikasi, Anda sebaiknya selalu mencetak bobot salah satu lapisan yang sama dari kedua model. Jika tidak serupa, maka tidak ada gunanya menggunakan strategi klasifikasi autoencoder.
Mari cetak bobot lapisan pertama dari kedua model.
array([[[0.22935028,-0.800786,0.42421195,-0.6509941,-0.82958347,-0.44448015,0.04182598,-0.05483926,0.44611776,0.7123421,-0.4499234,0.16125064,0.1174996,0.12156075,0.8391102,-0.44067,0.02915774,-0.7223025,0.33398604,-0.69252896,0.04369332,-0.3793029,0.37535954,0.34269437,0.8863593,-0.2114254,0.21323568,-0.4076597,0.2965019,0.11617199,-0.22282824,-0.9501956]],[[0.23096658,0.3701021,0.78717273,-0.5014979,-1.3326751,-0.73818666,2.6434395,-0.7560537,-0.52561104,-0.67917436,2.0205429,0.14013338,-0.9140436,0.169709,0.09063474,-0.20975377,-0.11247484,-0.09702996,0.17846109,0.40699893,-0.5722246,-1.0119121,0.30877167,0.6645408,-0.68007207,-0.57144946,-0.68339616,0.45407826,1.0148963,0.88867754,-0.57179326,0.01268557]],[[0.23020297,0.14018346,-0.37600747,-0.6213855,-0.4104492,-0.2036299,0.12469969,0.08351921,0.20644444,-0.01170571,-0.07618313,0.23164392,-0.38417578,0.3481844,-0.8055927,0.76824665,0.06819476,0.93830526,0.31898668,0.51119566,0.4445658,-0.4568496,0.1269397,-0.34482956,-1.3285302,-0.20479,-0.17618039,-0.22546193,-0.35588196,0.9971566,-0.03546353,-0.7294457]]],
dtype=float32)Didukung oleh
array([[[0.22935028,-0.800786,0.42421195,-0.6509941,-0.82958347,-0.44448015,0.04182598,-0.05483926,0.44611776,0.7123421,-0.4499234,0.16125064,0.1174996,0.12156075,0.8391102,-0.44067,0.02915774,-0.7223025,0.33398604,-0.69252896,0.04369332,-0.3793029,0.37535954,0.34269437,0.8863593,-0.2114254,0.21323568,-0.4076597,0.2965019,0.11617199,-0.22282824,-0.9501956]],[[0.23096658,0.3701021,0.78717273,-0.5014979,-1.3326751,-0.73818666,2.6434395,-0.7560537,-0.52561104,-0.67917436,2.0205429,0.14013338,-0.9140436,0.169709,0.09063474,-0.20975377,-0.11247484,-0.09702996,0.17846109,0.40699893,-0.5722246,-1.0119121,0.30877167,0.6645408,-0.68007207,-0.57144946,-0.68339616,0.45407826,1.0148963,0.88867754,-0.57179326,0.01268557]],[[0.23020297,0.14018346,-0.37600747,-0.6213855,-0.4104492,-0.2036299,0.12469969,0.08351921,0.20644444,-0.01170571,-0.07618313,0.23164392,-0.38417578,0.3481844,-0.8055927,0.76824665,0.06819476,0.93830526,0.31898668,0.51119566,0.4445658,-0.4568496,0.1269397,-0.34482956,-1.3285302,-0.20479,-0.17618039,-0.22546193,-0.35588196,0.9971566,-0.03546353,-0.7294457]]],
dtype=float32)Didukung oleh
Voila! Kedua array terlihat persis sama. Jadi, tanpa berlama-lama, mari kompilasi model dan mulai pelatihan.
Selanjutnya, Anda akan menjadikan bagian encoder yaitu sembilan belas lapisan pertama model tidak dapat dilatih. Karena bagian encoder sudah dilatih, Anda tidak perlu melatihnya. Anda hanya akan melatih bagian Fully Connected.
for layer in full_model.layers[0:19]:
layer.trainable =FalseDidukung oleh
Mari kompilasi model!
full_model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adam(),metrics=['accuracy'])Didukung oleh
Mari cetak ringkasan model juga. Seharusnya ada parameter yang tidak dapat dilatih karena Anda menjadikan lima belas lapisan pertama model tidak dapat dilatih.
Akhirnya saatnya melatih model dengan fungsi fit() Keras! Model dilatih selama 10 epoch. Fungsi fit() akan mengembalikan objek history; Dengan menyimpan hasil fungsi ini pada fashion_train, Anda dapat menggunakannya nanti untuk memplot akurasi dan loss antara pelatihan dan validasi yang akan membantu Anda menganalisis performa model secara visual.
classify_train = full_model.fit(train_X, train_label, batch_size=64,epochs=100,verbose=1,validation_data=(valid_X, valid_label))Didukung oleh
Akhirnya! Anda melatih model pada fashion-MNIST hanya selama 10 epoch, dan dengan mengamati akurasi dan loss pelatihan, Anda dapat mengatakan bahwa model bekerja dengan sangat baik karena setelah 10 epoch akurasi pelatihan 99% dan loss validasi 98%.
Mari simpan model klasifikasi!
full_model.save_weights('autoencoder_classification.h5')Didukung oleh
Selanjutnya, Anda akan melatih ulang model dengan menjadikan sembilan belas lapisan pertama dapat dilatih True alih-alih menjaganya False! Jadi, mari cepat lakukan itu.
for layer in full_model.layers[0:19]:
layer.trainable =TrueDidukung oleh
full_model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adam(),metrics=['accuracy'])Didukung oleh
Sekarang mari latih seluruh model untuk terakhir kalinya!
classify_train = full_model.fit(train_X, train_label, batch_size=64,epochs=100,verbose=1,validation_data=(valid_X, valid_label))Didukung oleh
Dari dua plot di atas, Anda dapat melihat bahwa model mengalami overfitting karena ada celah besar antara loss pelatihan dan validasi. Untuk mengatasi overfitting, Anda mungkin harus menggunakan beberapa teknik regularisasi seperti Dropout. Anda dapat mengikuti tutorial ini tentang CNN di Python dengan keras.
Evaluasi Model pada Set Uji
Terakhir, mari evaluasi model Anda juga pada data uji dan lihat bagaimana performanya!
test_eval = full_model.evaluate(test_data, test_Y_one_hot, verbose=0)Didukung oleh
print('Test loss:', test_eval[0])print('Test accuracy:', test_eval[1])Didukung oleh
('Test loss:',0.7068972043234281)('Test accuracy:',0.9205)Didukung oleh
Prediksi Label
predicted_classes = full_model.predict(test_data)Didukung oleh
Karena prediksi yang Anda dapatkan berupa nilai floating point, tidak akan mudah membandingkan label yang diprediksi dengan label uji yang benar. Jadi, Anda akan membulatkan keluaran yang akan mengonversi nilai float menjadi integer. Selanjutnya, Anda akan menggunakan np.argmax() untuk memilih nomor indeks yang memiliki nilai lebih tinggi dalam satu baris.
Misalnya, anggap satu prediksi untuk satu gambar uji adalah [0 1 0 0 0 0 0 0 0 0], keluaran untuk ini seharusnya label kelas 1.
predicted_classes = np.argmax(np.round(predicted_classes),axis=1)Didukung oleh
predicted_classes.shape, test_labels.shape
Didukung oleh
Laporan klasifikasi akan membantu Anda mengidentifikasi kelas yang salah klasifikasi secara lebih rinci. Anda akan dapat mengamati untuk kelas mana model berkinerja buruk dari sepuluh kelas yang ada.
from sklearn.metrics import classification_report
target_names =["Class {}".format(i)for i inrange(num_classes)]print(classification_report(test_labels, predicted_classes, target_names=target_names))Didukung oleh
precision recall f1-score support
Class 00.830.890.861000
Class 10.990.990.991000
Class 20.890.870.881000
Class 30.920.930.921000
Class 40.850.900.881000
Class 50.990.990.991000
Class 60.810.720.761000
Class 70.960.980.971000
Class 80.980.980.981000
Class 90.980.960.971000
avg / total 0.920.920.9210000Didukung oleh
Ingin menggali lebih dalam?
Tutorial ini merupakan awal yang baik untuk menggunakan autoencoder dan convolutional neural network yang fully connected dengan Python dan Keras. Jika Anda dapat mengikutinya dengan mudah atau bahkan dengan sedikit usaha lebih, bagus! Cobalah melakukan beberapa eksperimen mungkin dengan arsitektur model yang sama tetapi menggunakan berbagai jenis dataset publik yang tersedia.
Masih banyak yang harus dipelajari, jadi mengapa tidak mengambil kursus Deep Learning in Python dari DataCamp? Sambil menunggu, pastikan juga untuk memeriksa dokumentasi Keras, jika Anda belum melakukannya. Anda akan menemukan lebih banyak contoh dan informasi tentang semua fungsi, argumen, lebih banyak lapisan, dan lain-lain. Ini pasti akan menjadi sumber yang tak tergantikan saat Anda belajar cara bekerja dengan neural network di Python!
Jika Anda lebih suka membaca buku yang menjelaskan dasar-dasar deep learning (dengan Keras) beserta penggunaannya dalam praktik, Anda harus membaca buku Deep Learning in Python karya François Chollet.
Temukan alasan mengapa Anda sebaiknya (tidak) menggunakan spaghetti plot untuk menyampaikan ketidakpastian jalur prediksi badai serta dampaknya terhadap interpretasi.
Kuasai pertanyaan wawancara basis data, dari konsep SQL dasar hingga skenario desain sistem tingkat lanjut. Panduan mendalam ini mencakup semua yang Anda perlukan untuk sukses di wawancara DBMS dan meraih peran berikutnya.
Catatan: Tutorial ini terutama akan membahas implementasi praktis klasifikasi menggunakan convolutional neural network dan convolutional autoencoder. Jadi, jika Anda belum familiar dengan convolutional neural network (CNN) dan autoencoder, Anda mungkin ingin melihat tutorial CNN dan Autoencoder.
Secara lebih spesifik, Anda akan membahas topik-topik berikut dalam tutorial hari ini:
Kumpulan Data Fashion-MNIST
Sebelum mulai memuat dataset dan memprosesnya, ada baiknya memiliki gambaran singkat tentang seperti apa jenis datasetnya, bagaimana dimensinya, dan berapa banyak kelas berbeda yang ada dalam dataset.
Dataset Fashion-MNIST berisi gambar grayscale 28x28 dari 70.000 produk fesyen dari 10 kategori, dengan 7.000 gambar per kategori. Set pelatihan memiliki 60.000 gambar, dan set pengujian memiliki 10.000 gambar. Fashion-MNIST merupakan pengganti dataset MNIST asli untuk menghasilkan hasil yang lebih baik; dimensi gambar serta pembagian pelatihan dan uji serupa dengan dataset MNIST asli. Dataset ini tersedia gratis di URL ini dan dapat dimuat menggunakan tensorflow maupun keras sebagai kerangka kerja tanpa harus mengunduhnya ke komputer Anda.
Mirip dengan MNIST, Fashion-MNIST juga terdiri dari 10 kelas, tetapi alih-alih digit tulisan tangan, kita memiliki 10 kelas aksesori fesyen yang berbeda seperti sandal, kemeja, celana, dan sebagainya.
Tugas Anda adalah melatih convolutional autoencoder dan menggunakan bagian encoder dari autoencoder yang digabungkan dengan lapisan fully connected untuk mengenali sampel baru dari set uji secara benar.
Tip: jika Anda ingin belajar cara mengimplementasikan Multi-Layer Perceptron (MLP) untuk tugas klasifikasi dengan dataset MNIST, lihat tutorial ini.
Pada kode di bawah, Anda pada dasarnya menetapkan variabel lingkungan di notebook menggunakan os.environ. Sebaiknya lakukan hal berikut sebelum menginisialisasi Keras untuk membatasi backend TensorFlow Keras agar menggunakan GPU pertama. Jika mesin tempat Anda melatih memiliki GPU di 0, pastikan menggunakan 0 alih-alih 1. Anda bisa memeriksanya dengan menjalankan perintah sederhana di terminal: misalnya, nvidia-smi
Memuat Data
Selanjutnya, Anda mengimpor semua modul yang diperlukan seperti numpy, matplotlib, dan yang terpenting Keras, karena dalam tutorial hari ini Anda akan menggunakan keras sebagai kerangka kerja!
Di sini, Anda mendefinisikan fungsi yang membuka file
gzip, membaca file menggunakanbytestream.read(). Anda meneruskan dimensi gambar dan jumlah total gambar ke fungsi ini. Lalu, menggunakannp.frombuffer(), Anda mengonversi string yang disimpan dalam variabelbufmenjadi array NumPy bertipefloat32.Setelah dikonversi menjadi array NumPy, Anda membentuk ulang array menjadi array tiga dimensi atau tensor di mana dimensi pertama adalah jumlah gambar, dan dimensi kedua dan ketiga adalah dimensi gambar. Terakhir, Anda mengembalikan array NumPy
data.Sekarang Anda akan memanggil fungsi
extract_data()dengan meneruskan file pelatihan dan pengujian beserta jumlah gambar masing-masing.Demikian pula, Anda mendefinisikan fungsi ekstraksi label yang membuka file
gzip, membaca file menggunakanbytestream.read(), yang Anda beri dimensi label (1) dan jumlah total gambar. Lalu, menggunakannp.frombuffer(), Anda mengonversi string yang disimpan dalam variabelbufmenjadi array NumPy bertipeint64.Kali ini, Anda tidak perlu membentuk ulang array karena variabel
labelsakan mengembalikan vektor kolom berdimensi 60.000 x 1. Terakhir, Anda mengembalikan array NumPylabels.Sekarang Anda akan memanggil fungsi ekstrak label dengan meneruskan file label pelatihan dan pengujian beserta jumlah gambar masing-masing.
Setelah Anda memuat data pelatihan dan pengujian, Anda siap untuk menganalisis data guna mendapatkan intuisi tentang dataset yang akan Anda gunakan dalam tutorial hari ini!
Eksplorasi Data
Sekarang mari kita analisis seperti apa tampilan gambar dalam dataset dan lihat juga dimensi gambarnya dengan bantuan atribut array NumPy
.shape:Dari output di atas, Anda dapat melihat bahwa data pelatihan memiliki bentuk 60000 x 28 x 28 karena ada 60.000 sampel pelatihan masing-masing berupa matriks berdimensi 28 x 28. Demikian pula, data uji memiliki bentuk 10000 x 28 x 28 karena ada 10.000 sampel uji.
Catatan bahwa dalam tugas rekonstruksi menggunakan convolutional autoencoder Anda tidak memerlukan label pelatihan dan pengujian. Gambar pelatihan Anda akan berperan sebagai masukan sekaligus ground truth mirip dengan label yang Anda miliki pada tugas klasifikasi.
Namun untuk tugas klasifikasi Anda juga akan membutuhkan label beserta gambar, yang akan Anda lakukan nanti dalam tutorial. Meskipun tugas saat ini hanya berurusan dengan gambar pelatihan dan pengujian, untuk tujuan eksplorasi yang mungkin memberi Anda intuisi lebih baik tentang data, Anda akan memanfaatkan label.
Mari buat kamus yang berisi nama kelas dengan label kelas kategorikal yang sesuai:
Sekarang, mari lihat beberapa gambar dalam dataset Anda:
Keluaran dari dua plot di atas adalah salah satu gambar sampel dari data pelatihan dan pengujian, dan gambar-gambar ini diberi label kelas
0atauAdi satu sisi, dan4atauEdi sisi lain. Demikian pula, alfabet lain akan memiliki label berbeda, tetapi alfabet yang sama akan memiliki label yang sama. Ini berarti semua 6.000 gambar kelasEakan memiliki label kelas4.Prapemrosesan Data
Gambar dalam dataset memang merupakan gambar grayscale dengan nilai piksel antara 0 hingga 255 dengan dimensi 28 x 28, jadi sebelum kita memasukkan data ke dalam model, sangat penting untuk memprosesnya terlebih dahulu. Anda akan terlebih dahulu mengonversi setiap gambar 28 x 28 dari set train dan test menjadi matriks berukuran 28 x 28 x 1, yang dapat Anda masukkan ke dalam jaringan:
Selanjutnya, pastikan untuk memeriksa tipe data array NumPy pelatihan dan pengujian, seharusnya dalam format float32; jika tidak, Anda perlu mengonversinya ke format ini, tetapi karena Anda sudah mengonversinya saat membaca data, Anda tidak perlu melakukannya lagi. Anda juga harus melakukan penskalaan ulang nilai piksel ke rentang 0 - 1 inklusif. Mari kita lakukan!
Jangan lupa untuk memverifikasi tipe data pelatihan dan pengujian:
Selanjutnya, skala ulang data pelatihan dan pengujian dengan nilai piksel maksimum dari data pelatihan dan pengujian:
Mari verifikasi nilai maksimum data pelatihan dan pengujian yang seharusnya 1.0 setelah penskalaan ulang!
Setelah semua ini, penting untuk melakukan partisi data. Agar model kita dapat melakukan generalisasi dengan baik, Anda membagi data pelatihan menjadi dua bagian: set pelatihan dan validasi. Anda akan melatih model pada 80% data dan memvalidasinya pada 20% sisa data pelatihan.
Ini juga akan membantu mengurangi kemungkinan overfitting, karena Anda akan memvalidasi model pada data yang tidak dilihat saat fase pelatihan.
Anda dapat menggunakan modul
train_test_splitdari scikit-learn untuk membagi data dengan benar:Catatan: Anda akan menggunakan pembagian data di atas dua kali, sekali untuk tugas rekonstruksi menggunakan convolutional autoencoder yang tidak memerlukan label pelatihan dan pengujian. Itulah sebabnya Anda akan meneruskan gambar pelatihan dua kali. Gambar pelatihan Anda akan berperan sebagai masukan sekaligus ground truth mirip dengan label yang Anda miliki pada tugas klasifikasi.
Namun untuk tugas klasifikasi, Anda juga akan meneruskan label beserta gambar yang akan Anda lakukan nanti dalam tutorial.
Sekarang Anda siap untuk mendefinisikan jaringan dan memasukkan data ke dalam jaringan. Jadi tanpa berlama-lama, mari lanjut ke langkah berikutnya!
Convolutional Autoencoder
Gambar berukuran 28 x 28 x 1 atau vektor berdimensi 30976. Anda mengonversi matriks gambar menjadi array, melakukan penskalaan ulang antara 0 dan 1, membentuk ulang sehingga berukuran 28 x 28 x 1, dan memasukkan ini sebagai input ke jaringan.
Selain itu, Anda akan menggunakan ukuran batch 128; menggunakan ukuran batch yang lebih besar 256 atau 512 juga dapat dipertimbangkan—semuanya bergantung pada sistem tempat Anda melatih model. Ini sangat berkontribusi dalam menentukan parameter pembelajaran dan memengaruhi akurasi prediksi.
Seperti yang mungkin sudah Anda ketahui, autoencoder terbagi menjadi dua bagian: encoder dan decoder.
Encoder: Memiliki 4 blok Konvolusi, tiap blok memiliki lapisan konvolusi diikuti lapisan normalisasi batch. Lapisan max-pooling digunakan setelah blok konvolusi pertama dan kedua.
Decoder: Memiliki 3 blok Konvolusi, tiap blok memiliki lapisan konvolusi diikuti lapisan normalisasi batch. Lapisan upsampling digunakan setelah blok konvolusi kedua dan ketiga.
Lapisan max-pooling akan melakukan downsampling input sebanyak dua kali setiap kali digunakan, sementara lapisan upsampling akan melakukan upsampling input sebanyak dua kali setiap kali digunakan.
Catatan: Jumlah filter, ukuran filter, jumlah lapisan, jumlah epoch pelatihan model, semuanya adalah hiperparameter dan harus diputuskan berdasarkan intuisi Anda sendiri; Anda bebas mencoba eksperimen baru dengan mengutak-atik hiperparameter ini dan mengukur performa model Anda. Dan dari situlah Anda perlahan belajar seni deep learning!
Mari buat fungsi encoder dan decoder terpisah karena Anda akan menggunakan bobot encoder nanti untuk tujuan klasifikasi!
Setelah model dibuat, Anda harus mengompilasinya menggunakan optimizer RMSProp.
Perhatikan bahwa Anda juga harus menentukan jenis loss melalui argumen loss. Dalam kasus ini, yaitu mean squared error, karena loss setelah setiap batch akan dihitung antara batch keluaran yang diprediksi dan ground truth menggunakan mean squared error per piksel:
Mari visualisasikan lapisan yang Anda buat pada langkah di atas menggunakan fungsi summary. Ini akan menampilkan jumlah parameter (bobot dan bias) di setiap lapisan dan juga total parameter dalam model Anda.
Akhirnya saatnya melatih model dengan fungsi fit() Keras! Model dilatih selama 200 epoch. Fungsi fit() akan mengembalikan objek history; Dengan menyimpan hasil fungsi ini pada autoencoder_train, Anda dapat menggunakannya nanti untuk memplot kurva loss antara pelatihan dan validasi yang akan membantu Anda menganalisis performa model secara visual.
Latih Model
Akhirnya! Anda melatih model pada dataset fashion-mnist selama 100 epoch, Sekarang, mari plot kurva loss antara data pelatihan dan validasi untuk memvisualisasikan performa model.
Akhirnya, Anda dapat melihat bahwa loss validasi dan loss pelatihan selaras. Ini menunjukkan bahwa model Anda tidak overfitting: loss validasi menurun dan tidak meningkat, dan jarang ada celah antara loss pelatihan dan validasi sepanjang fase pelatihan.
Karena itu, dapat dikatakan kemampuan generalisasi model Anda baik.
Tetapi ingat, tugas kita adalah menggunakan bagian encoder dari model yang telah dilatih di atas untuk mengklasifikasikan gambar fashion mnist. Jadi, mari lanjut ke bagian berikutnya sekarang!
Simpan Model
Karena Anda akan memerlukan bobot encoder dalam tugas klasifikasi, pertama mari simpan bobot autoencoder lengkap. Anda akan mempelajari cara mengekstrak bobot encoder segera.
Menyegmentasi Gambar Fashion Mnist
Sekarang Anda akan menggunakan bagian kepala autoencoder terlatih, yaitu bagian encoder, dan akan memuat bobot autoencoder yang baru saja Anda latih hanya ke bagian encoder dari model.
Anda akan menambahkan beberapa lapisan dense atau fully connected pada encoder untuk mengklasifikasikan gambar fashion mnist.
Bagi Anda yang belum tahu tentang one-hot encoding:
Dalam one-hot encoding, Anda mengonversi data kategorikal menjadi vektor angka. Alasan mengapa Anda mengonversi data kategorikal ke one-hot encoding adalah karena algoritme pembelajaran mesin tidak dapat bekerja langsung dengan data kategorikal. Anda membuat satu kolom boolean untuk setiap kategori atau kelas. Hanya satu dari kolom ini yang dapat bernilai 1 untuk setiap sampel. Karena itulah disebut one-hot encoding.
Untuk pernyataan masalah Anda, one hot encoding akan berupa vektor baris, dan untuk setiap gambar, dimensinya 1 x 10. Hal penting yang perlu diperhatikan di sini adalah vektor terdiri dari semua nol kecuali untuk kelas yang diwakilinya, dan untuk kelas itu nilainya 1.
Jadi mari konversi label menjadi vektor one-hot encoding:
Cukup jelas, bukan?
Untuk terakhir kalinya mari periksa bentuk set pelatihan dan validasi.
Sekarang, mari definisikan model klasifikasi. Ingat bahwa Anda akan menggunakan bagian encoder yang persis sama seperti yang digunakan pada arsitektur autoencoder.
Mari definisikan lapisan fully connected yang akan Anda tumpuk dengan fungsi encoder.
Catatan: Langkah berikut cukup penting. Untuk memastikan apakah bobot pada bagian encoder autoencoder serupa dengan bobot yang Anda muat ke fungsi encoder model klasifikasi, Anda sebaiknya selalu mencetak bobot salah satu lapisan yang sama dari kedua model. Jika tidak serupa, maka tidak ada gunanya menggunakan strategi klasifikasi autoencoder.
Mari cetak bobot lapisan pertama dari kedua model.
Voila! Kedua array terlihat persis sama. Jadi, tanpa berlama-lama, mari kompilasi model dan mulai pelatihan.
Selanjutnya, Anda akan menjadikan bagian encoder yaitu sembilan belas lapisan pertama model tidak dapat dilatih. Karena bagian encoder sudah dilatih, Anda tidak perlu melatihnya. Anda hanya akan melatih bagian Fully Connected.
Mari kompilasi model!
Mari cetak ringkasan model juga. Seharusnya ada parameter yang tidak dapat dilatih karena Anda menjadikan lima belas lapisan pertama model tidak dapat dilatih.
Latih Model
Akhirnya saatnya melatih model dengan fungsi fit() Keras! Model dilatih selama 10 epoch. Fungsi fit() akan mengembalikan objek history; Dengan menyimpan hasil fungsi ini pada fashion_train, Anda dapat menggunakannya nanti untuk memplot akurasi dan loss antara pelatihan dan validasi yang akan membantu Anda menganalisis performa model secara visual.
Akhirnya! Anda melatih model pada fashion-MNIST hanya selama 10 epoch, dan dengan mengamati akurasi dan loss pelatihan, Anda dapat mengatakan bahwa model bekerja dengan sangat baik karena setelah 10 epoch akurasi pelatihan 99% dan loss validasi 98%.
Mari simpan model klasifikasi!
Selanjutnya, Anda akan melatih ulang model dengan menjadikan sembilan belas lapisan pertama dapat dilatih True alih-alih menjaganya False! Jadi, mari cepat lakukan itu.
Sekarang mari latih seluruh model untuk terakhir kalinya!
Mari simpan model untuk terakhir kalinya.
Mari letakkan evaluasi model Anda dalam perspektif dan plot kurva akurasi dan loss antara data pelatihan dan validasi:
Dari dua plot di atas, Anda dapat melihat bahwa model mengalami overfitting karena ada celah besar antara loss pelatihan dan validasi. Untuk mengatasi overfitting, Anda mungkin harus menggunakan beberapa teknik regularisasi seperti Dropout. Anda dapat mengikuti tutorial ini tentang CNN di Python dengan keras.
Evaluasi Model pada Set Uji
Terakhir, mari evaluasi model Anda juga pada data uji dan lihat bagaimana performanya!
Prediksi Label
Karena prediksi yang Anda dapatkan berupa nilai floating point, tidak akan mudah membandingkan label yang diprediksi dengan label uji yang benar. Jadi, Anda akan membulatkan keluaran yang akan mengonversi nilai float menjadi integer. Selanjutnya, Anda akan menggunakan np.argmax() untuk memilih nomor indeks yang memiliki nilai lebih tinggi dalam satu baris.
Misalnya, anggap satu prediksi untuk satu gambar uji adalah [0 1 0 0 0 0 0 0 0 0], keluaran untuk ini seharusnya label kelas 1.
Laporan Klasifikasi
Laporan klasifikasi akan membantu Anda mengidentifikasi kelas yang salah klasifikasi secara lebih rinci. Anda akan dapat mengamati untuk kelas mana model berkinerja buruk dari sepuluh kelas yang ada.
Ingin menggali lebih dalam?
Tutorial ini merupakan awal yang baik untuk menggunakan autoencoder dan convolutional neural network yang fully connected dengan Python dan Keras. Jika Anda dapat mengikutinya dengan mudah atau bahkan dengan sedikit usaha lebih, bagus! Cobalah melakukan beberapa eksperimen mungkin dengan arsitektur model yang sama tetapi menggunakan berbagai jenis dataset publik yang tersedia.
Masih banyak yang harus dipelajari, jadi mengapa tidak mengambil kursus Deep Learning in Python dari DataCamp? Sambil menunggu, pastikan juga untuk memeriksa dokumentasi Keras, jika Anda belum melakukannya. Anda akan menemukan lebih banyak contoh dan informasi tentang semua fungsi, argumen, lebih banyak lapisan, dan lain-lain. Ini pasti akan menjadi sumber yang tak tergantikan saat Anda belajar cara bekerja dengan neural network di Python!
Jika Anda lebih suka membaca buku yang menjelaskan dasar-dasar deep learning (dengan Keras) beserta penggunaannya dalam praktik, Anda harus membaca buku Deep Learning in Python karya François Chollet.