Apa itu Autoencoder?
Sebuah Autoencoder adalah alat untuk data coding secara efisien dengan cara yang tanpa pengawasan belajar. Ini adalah jenis jaringan saraf tiruan yang membantu Anda mempelajari representasi kumpulan data untuk pengurangan dimensi dengan melatih jaringan saraf untuk mengabaikan gangguan sinyal. Ini adalah alat yang hebat untuk membuat ulang input.
Dengan kata sederhana, mesin mengambil, katakanlah sebuah gambar, dan dapat menghasilkan gambar yang berkaitan erat. Masukan dalam jaringan saraf semacam ini tidak berlabel, artinya jaringan tersebut mampu belajar tanpa pengawasan. Lebih tepatnya, input dikodekan oleh jaringan untuk fokus hanya pada fitur yang paling kritis. Inilah salah satu alasan mengapa autoencoder populer untuk pengurangan dimensi. Selain itu, autoencoder dapat digunakan untuk menghasilkan model pembelajaran generatif . Misalnya, jaringan saraf dapat dilatih dengan sekumpulan wajah dan kemudian dapat menghasilkan wajah baru.
Dalam tutorial TensorFlow Autoencoder ini, Anda akan mempelajari:
- Apa itu Autoencoder?
- Bagaimana cara kerja Autoencoder?
- Contoh Stacked Autoencoder
- Buat Autoencoder dengan TensorFlow
- Pemrosesan awal gambar
- Tetapkan Estimator Set Data
- Bangun jaringan
Bagaimana cara kerja Autoencoder?
Tujuan autoencoder adalah untuk menghasilkan perkiraan input dengan hanya berfokus pada fitur-fitur penting. Anda mungkin berpikir mengapa tidak hanya mempelajari cara menyalin dan menempelkan masukan untuk menghasilkan keluaran. Faktanya, autoencoder adalah sekumpulan batasan yang memaksa jaringan untuk mempelajari cara baru untuk merepresentasikan data, berbeda dari hanya menyalin output.
Autoencoder tipikal didefinisikan dengan input, representasi internal, dan output (perkiraan input). Pembelajaran terjadi pada lapisan yang melekat pada representasi internal. Faktanya, ada dua blok lapisan utama yang terlihat seperti jaringan neural tradisional. Perbedaan kecilnya adalah lapisan yang berisi keluaran harus sama dengan masukan. Pada gambar di bawah ini, input asli masuk ke blok pertama yang disebut encoder . Representasi internal ini memampatkan (mengurangi) ukuran input. Pada blok kedua terjadi rekonstruksi input. Ini adalah fase decoding.
Bekerja dari Autoencoder
Model akan memperbarui bobot dengan meminimalkan fungsi kerugian. Model akan dikenakan sanksi jika keluaran rekonstruksi berbeda dengan masukan.
Secara konkret, bayangkan gambar dengan ukuran 50x50 (yaitu 250 piksel) dan jaringan saraf dengan hanya satu lapisan tersembunyi yang terdiri dari seratus neuron. Pembelajaran dilakukan pada peta fitur yang berukuran dua kali lebih kecil dari input. Artinya, jaringan perlu menemukan cara untuk merekonstruksi 250 piksel dengan hanya satu vektor neuron yang sama dengan 100.
Contoh Stacked Autoencoder
Dalam tutorial Autoencoder ini, Anda akan mempelajari cara menggunakan autoencoder bertumpuk. Arsitekturnya mirip dengan jaringan saraf tradisional. Masukan masuk ke lapisan tersembunyi untuk dikompresi, atau dikurangi ukurannya, dan kemudian mencapai lapisan rekonstruksi. Tujuannya adalah untuk menghasilkan gambar keluaran yang mendekati aslinya. Model harus mempelajari cara untuk mencapai tugasnya di bawah sekumpulan kendala, yaitu dengan dimensi yang lebih rendah.
Saat ini, Autoencoder dalam Pembelajaran Mendalam terutama digunakan untuk menolak gambar. Bayangkan sebuah gambar dengan goresan; manusia masih bisa mengenali isinya. Ide denoising autoencoder adalah menambahkan noise ke gambar untuk memaksa jaringan mempelajari pola di balik data.
Keluarga berguna lainnya dari Autoencoder Deep Learning adalah autoencoder variasional. Jenis jaringan ini dapat menghasilkan gambar baru. Bayangkan Anda melatih jaringan dengan citra seorang pria; jaringan seperti itu dapat menghasilkan wajah-wajah baru.
Buat Autoencoder dengan TensorFlow
Dalam tutorial ini, Anda akan belajar cara membuat autoencoder bertumpuk untuk merekonstruksi gambar.
Anda akan menggunakan dataset CIFAR-10 yang berisi 60.000 gambar berwarna 32x32. Dataset Autoencoder sudah dibagi antara 50000 gambar untuk pelatihan dan 10.000 untuk pengujian. Ada hingga sepuluh kelas:
- Pesawat terbang
- Mobil
- Burung
- Kucing
- Rusa
- Anjing
- Katak
- Kuda
- Kapal
- Truk
Anda perlu mengunduh gambar di URL ini https://www.cs.toronto.edu/~kriz/cifar.html dan unzip. Folder untuk-10-batch-py berisi lima kumpulan data dengan masing-masing 10.000 gambar dalam urutan acak.
Sebelum Anda membuat dan melatih model Anda, Anda perlu menerapkan beberapa pemrosesan data. Anda akan melanjutkan sebagai berikut:
- Impor datanya
- Ubah data menjadi format hitam dan putih
- Tambahkan semua kelompok
- Buat set data pelatihan
- Bangun visualisator gambar
Pemrosesan awal gambar
Langkah 1) Impor data.
Menurut situs resminya, Anda dapat mengunggah data dengan kode berikut. Kode Autoencoder akan memuat data dalam kamus dengan data dan label . Perhatikan bahwa kode tersebut adalah sebuah fungsi.
import numpy as npimport tensorflow as tfimport pickledef unpickle(file):import picklewith open(file, 'rb') as fo:dict = pickle.load(fo, encoding='latin1')return dict
Langkah 2) Ubah data menjadi format hitam putih
Untuk kesederhanaan, Anda akan mengubah data menjadi skala abu-abu. Artinya, dengan hanya satu dimensi berbanding tiga untuk gambar berwarna. Sebagian besar jaringan neural hanya berfungsi dengan satu masukan dimensi.
def grayscale(im):return im.reshape(im.shape[0], 3, 32, 32).mean(1).reshape(im.shape[0], -1)
Langkah 3) Tambahkan semua batch
Sekarang setelah kedua fungsi dibuat dan set data dimuat, Anda dapat menulis loop untuk menambahkan data ke memori. Jika Anda memeriksa dengan teliti, file unzip dengan datanya dinamai data_batch_ dengan nomor dari 1 hingga 5. Anda dapat mengulang file dan menambahkannya ke data.
Saat langkah ini selesai, Anda mengonversi data warna ke format skala abu-abu. Seperti yang Anda lihat, bentuk datanya adalah 50000 dan 1024. 32 * 32 piksel sekarang diratakan ke 2014.
# Load the data into memorydata, labels = [], []## Loop over the bfor i in range(1, 6):filename = './cifar-10-batches-py/data_batch_' + str(i)open_data = unpickle(filename)if len(data)> 0:data = np.vstack((data, open_data['data']))labels = np.hstack((labels, open_data['labels']))else:data = open_data['data']labels = open_data['labels']data = grayscale(data)x = np.matrix(data)y = np.array(labels)print(x.shape)(50000, 1024)
Catatan: Ubah './cifar-10-batches-py/data_batch_' ke lokasi sebenarnya dari file Anda. Misalnya untuk mesin Windows, jalurnya bisa menjadi nama file = 'E: \ cifar-10-batches-py \ data_batch_' + str (i)
Langkah 4) Buat set data pelatihan
Untuk membuat pelatihan lebih cepat dan mudah, Anda hanya akan melatih model pada gambar kuda. Kuda-kuda itu adalah kelas ketujuh dalam data label. Seperti yang disebutkan dalam dokumentasi set data CIFAR-10, setiap kelas berisi 5.000 gambar. Anda dapat mencetak bentuk data untuk mengonfirmasi bahwa ada 5.000 gambar dengan 1024 kolom seperti yang ditunjukkan pada contoh langkah TensorFlow Autoencoder di bawah ini.
horse_i = np.where(y == 7)[0]horse_x = x[horse_i]print(np.shape(horse_x))(5000, 1024)
Langkah 5) Buatlah visualisator gambar
Terakhir, Anda membuat fungsi untuk memplot gambar. Anda akan membutuhkan fungsi ini untuk mencetak gambar yang direkonstruksi dari autoencoder.
Cara mudah untuk mencetak gambar adalah dengan menggunakan objek imshow dari pustaka matplotlib. Perhatikan bahwa, Anda perlu mengubah bentuk data dari 1024 menjadi 32 * 32 (yaitu format gambar).
# To plot pretty figures%matplotlib inlineimport matplotlibimport matplotlib.pyplot as pltdef plot_image(image, shape=[32, 32], cmap = "Greys_r"):plt.imshow(image.reshape(shape), cmap=cmap,interpolation="nearest")plt.axis("off")
Fungsi tersebut membutuhkan 3 argumen:
- Gambar: masukan
- Bentuk: daftar, dimensi gambar
- Cmap: pilih peta warna. Secara default, abu-abu
Anda dapat mencoba memplot gambar pertama dalam kumpulan data. Anda harus melihat seorang pria di atas kuda.
plot_image(horse_x[1], shape=[32, 32], cmap = "Greys_r")
Tetapkan Estimator Set Data
Baiklah, sekarang set data siap digunakan, Anda bisa mulai menggunakan Tensorflow. Sebelum membuat model, mari gunakan estimator Kumpulan Data dari Tensorflow untuk memberi makan jaringan.
Anda akan membuat Set Data dengan estimator TensorFlow. Untuk menyegarkan pikiran Anda, Anda perlu menggunakan:
- from_tensor_slices
- ulang
- batch
Kode lengkap untuk membangun dataset adalah:
dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)
Perhatikan bahwa, x adalah placeholder dengan bentuk berikut:
- [Tidak ada, n_inputs]: Setel ke Tidak ada karena jumlah umpan gambar ke jaringan sama dengan ukuran kumpulan.
untuk lebih jelasnya silahkan merujuk ke tutorial tentang regresi linier.
Setelah itu, Anda perlu membuat iterator. Tanpa baris kode ini, tidak ada data yang akan melalui pipeline.
iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()
Sekarang pipeline telah siap, Anda dapat memeriksa apakah gambar pertama sama dengan sebelumnya (misalnya, seorang pria di atas kuda).
Anda menyetel ukuran tumpukan ke 1 karena Anda hanya ingin memberi makan kumpulan data dengan satu gambar. Anda dapat melihat dimensi data dengan print (sess.run (features) .shape). Ini sama dengan (1, 1024). 1 berarti hanya satu gambar dengan 1024 diumpankan masing-masing. Jika ukuran tumpukan disetel ke dua, maka dua gambar akan melalui pipeline. (Jangan mengubah ukuran batch. Jika tidak, itu akan membuat kesalahan. Hanya satu gambar pada satu waktu yang dapat masuk ke fungsi plot_image ().
## Parametersn_inputs = 32 * 32BATCH_SIZE = 1batch_size = tf.placeholder(tf.int64)# using a placeholderx = tf.placeholder(tf.float32, shape=[None,n_inputs])## Datasetdataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()## Print the imagewith tf.Session() as sess:# feed the placeholder with datasess.run(iter.initializer, feed_dict={x: horse_x,batch_size: BATCH_SIZE})print(sess.run(features).shape)plot_image(sess.run(features), shape=[32, 32], cmap = "Greys_r")(1, 1024)
Bangun jaringan
Saatnya membangun jaringan. Anda akan melatih autoencoder bertumpuk, yaitu jaringan dengan beberapa lapisan tersembunyi.
Jaringan Anda akan memiliki satu lapisan masukan dengan 1024 titik, yaitu 32x32, bentuk gambar.
Blok encoder akan memiliki satu lapisan tersembunyi atas dengan 300 neuron, satu lapisan tengah dengan 150 neuron. Blok dekoder simetris dengan pembuat enkode. Anda dapat memvisualisasikan jaringan pada gambar di bawah ini. Perhatikan bahwa Anda dapat mengubah nilai lapisan tersembunyi dan tengah.
Membangun jaringan untuk Autoencoder
Membangun autoencoder sangat mirip dengan model pembelajaran mendalam lainnya.
Anda akan membuat model mengikuti langkah-langkah berikut:
- Tentukan parameternya
- Tentukan lapisannya
- Tentukan arsitekturnya
- Tentukan pengoptimalan
- Jalankan modelnya
- Evaluasi modelnya
Di bagian sebelumnya, Anda telah mempelajari cara membuat pipeline untuk memberi makan model, jadi tidak perlu lagi membuat set data lagi. Anda akan membuat autoencoder dengan empat lapisan. Anda menggunakan inisialisasi Xavier. Ini adalah teknik untuk menetapkan bobot awal yang sama dengan varians input dan output. Terakhir, Anda menggunakan fungsi aktivasi elu. Anda mengatur fungsi kerugian dengan pengatur L2.
Langkah 1) Tentukan parameternya
Langkah pertama menyiratkan untuk menentukan jumlah neuron di setiap lapisan, kecepatan pembelajaran dan hyperparameter dari pengatur.
Sebelumnya, Anda mengimpor sebagian fungsi. Ini adalah metode yang lebih baik untuk menentukan parameter lapisan padat. Kode di bawah ini mendefinisikan nilai-nilai arsitektur autoencoder. Seperti yang disebutkan sebelumnya, autoencoder memiliki dua lapisan, dengan 300 neuron di lapisan pertama dan 150 di lapisan kedua. Nilainya disimpan di n_hidden_1 dan n_hidden_2.
Anda perlu menentukan kecepatan pemelajaran dan hyperparameter L2. Nilai disimpan dalam learning_rate dan l2_reg
from functools import partial## Encodern_hidden_1 = 300n_hidden_2 = 150 # codings## Decodern_hidden_3 = n_hidden_1n_outputs = n_inputslearning_rate = 0.01l2_reg = 0.0001
Teknik inisialisasi Xavier disebut dengan objek xavier_initializer dari kontrib penduga. Dalam estimator yang sama, Anda dapat menambahkan regulator dengan l2_regularizer
## Define the Xavier initializationxav_init = tf.contrib.layers.xavier_initializer()## Define the L2 regularizerl2_regularizer = tf.contrib.layers.l2_regularizer(l2_reg)
Langkah 2) Tentukan lapisannya
Semua parameter dari lapisan padat telah diatur; Anda dapat mengemas semuanya dalam variabel dense_layer dengan menggunakan objek parsial. dense_layer yang menggunakan aktivasi ELU, inisialisasi Xavier, dan regularisasi L2.
## Create the dense layerdense_layer = partial(tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer)
Langkah 3) Tentukan arsitekturnya
Jika Anda melihat pada gambar arsitektur, Anda perhatikan bahwa jaringan menumpuk tiga lapisan dengan lapisan keluaran. Pada kode di bawah ini, Anda menghubungkan lapisan yang sesuai. Misalnya, lapisan pertama menghitung perkalian titik antara fitur matriks masukan dan matriks yang berisi 300 bobot. Setelah produk titik dihitung, keluarannya menuju ke fungsi aktivasi Elu. Outputnya menjadi input dari layer berikutnya, itulah mengapa Anda menggunakannya untuk menghitung hidden_2 dan seterusnya. Perkalian matriks sama untuk setiap lapisan karena Anda menggunakan fungsi aktivasi yang sama. Perhatikan bahwa lapisan terakhir, keluaran, tidak menerapkan fungsi aktivasi. Masuk akal karena ini adalah masukan yang direkonstruksi
## Make the mat mulhidden_1 = dense_layer(features, n_hidden_1)hidden_2 = dense_layer(hidden_1, n_hidden_2)hidden_3 = dense_layer(hidden_2, n_hidden_3)outputs = dense_layer(hidden_3, n_outputs, activation=None)
Langkah 4) Tentukan pengoptimalan
Langkah terakhir adalah membangun pengoptimal. Anda menggunakan Mean Square Error sebagai fungsi kerugian. Jika Anda mengingat tutorial tentang regresi linier, Anda tahu bahwa MSE dihitung dengan selisih antara keluaran yang diprediksi dan label sebenarnya. Di sini, label adalah fitur karena model mencoba merekonstruksi masukan. Oleh karena itu, Anda menginginkan rata-rata jumlah selisih kuadrat antara keluaran dan masukan yang diprediksi. Dengan TensorFlow, Anda dapat mengkodekan fungsi kerugian sebagai berikut:
loss = tf.reduce_mean(tf.square(outputs - features))
Kemudian, Anda perlu mengoptimalkan fungsi kerugian. Anda menggunakan pengoptimal Adam untuk menghitung gradien. Fungsi tujuannya adalah meminimalkan kerugian.
## Optimizeloss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)
Satu pengaturan lagi sebelum melatih model. Anda ingin menggunakan ukuran batch 150, yaitu memberi makan pipeline dengan 150 gambar untuk setiap iterasi. Anda perlu menghitung jumlah iterasi secara manual. Ini sepele untuk dilakukan:
Jika Anda ingin mengirimkan 150 gambar setiap kali dan Anda tahu ada 5000 gambar dalam dataset, jumlah iterasi sama dengan. Di python Anda dapat menjalankan kode berikut dan memastikan outputnya adalah 33:
BATCH_SIZE = 150### Number of batches : length dataset / batch sizen_batches = horse_x.shape[0] // BATCH_SIZEprint(n_batches)33
Langkah 5) Jalankan model
Terakhir, latih modelnya. Anda melatih model dengan 100 periode. Artinya, model akan melihat 100 kali gambar dengan bobot yang dioptimalkan.
Anda sudah terbiasa dengan kode untuk melatih model di Tensorflow. Perbedaan kecilnya adalah menyalurkan data sebelum menjalankan pelatihan. Dengan cara ini, modelnya berlatih lebih cepat.
Anda tertarik untuk mencetak kerugian setelah sepuluh periode untuk melihat apakah model mempelajari sesuatu (yaitu, kerugian berkurang). Pelatihan membutuhkan waktu 2 hingga 5 menit, tergantung pada perangkat keras mesin Anda.
## Set paramsn_epochs = 100## Call Saver to save the model and re-use it later during evaluationsaver = tf.train.Saver()with tf.Session() as sess:sess.run(tf.global_variables_initializer())# initialise iterator with train datasess.run(iter.initializer, feed_dict={x: horse_x,batch_size: BATCH_SIZE})print('Training… ')print(sess.run(features).shape)for epoch in range(n_epochs):for iteration in range(n_batches):sess.run(train)if epoch % 10 == 0:loss_train = loss.eval() # not shownprint("\r{}".format(epoch), "Train MSE:", loss_train)#saver.save(sess, "./my_model_all_layers.ckpt")save_path = saver.save(sess, "./model.ckpt")print("Model saved in path: %s" % save_path)Training… (150, 1024)0 Train MSE: 2934.45510 Train MSE: 1672.67620 Train MSE: 1514.70930 Train MSE: 1404.311840 Train MSE: 1425.05850 Train MSE: 1479.063160 Train MSE: 1609.525970 Train MSE: 1482.322380 Train MSE: 1445.703590 Train MSE: 1453.8597Model saved in path: ./model.ckpt
Langkah 6) Evaluasi model
Sekarang setelah model Anda dilatih, sekarang saatnya untuk mengevaluasinya. Anda perlu mengimpor sert uji dari file / cifar-10-batches-py /.
test_data = unpickle('./cifar-10-batches-py/test_batch')test_x = grayscale(test_data['data'])#test_labels = np.array(test_data['labels'])
CATATAN: Untuk mesin Windows, kode menjadi test_data = unpickle (r "E: \ cifar-10-batches-py \ test_batch")
Anda dapat mencoba mencetak gambar 13, yang merupakan kuda
plot_image(test_x[13], shape=[32, 32], cmap = "Greys_r")
Untuk mengevaluasi model, Anda akan menggunakan nilai piksel dari gambar ini dan melihat apakah pembuat enkode dapat merekonstruksi gambar yang sama setelah mengecilkan 1024 piksel. Perhatikan bahwa, Anda menentukan fungsi untuk mengevaluasi model pada gambar yang berbeda. Model harus bekerja lebih baik hanya pada kuda.
Fungsi tersebut membutuhkan dua argumen:
- df: Impor data pengujian
- image_number: menunjukkan gambar apa yang akan diimpor
Fungsinya dibagi menjadi tiga bagian:
- Bentuk kembali gambar tersebut ke dimensi yang benar, yaitu 1, 1024
- Beri makan model dengan gambar yang tidak terlihat, encode / decode gambar
- Cetak gambar asli dan hasil rekonstruksi
def reconstruct_image(df, image_number = 1):## Part 1: Reshape the image to the correct dimension i.e 1, 1024x_test = df[image_number]x_test_1 = x_test.reshape((1, 32*32))## Part 2: Feed the model with the unseen image, encode/decode the imagewith tf.Session() as sess:sess.run(tf.global_variables_initializer())sess.run(iter.initializer, feed_dict={x: x_test_1,batch_size: 1})## Part 3: Print the real and reconstructed image# Restore variables from disk.saver.restore(sess, "./model.ckpt")print("Model restored.")# Reconstruct imageoutputs_val = outputs.eval()print(outputs_val.shape)fig = plt.figure()# Plot realax1 = fig.add_subplot(121)plot_image(x_test_1, shape=[32, 32], cmap = "Greys_r")# Plot estimatedax2 = fig.add_subplot(122)plot_image(outputs_val, shape=[32, 32], cmap = "Greys_r")plt.tight_layout()fig = plt.gcf()
Sekarang setelah fungsi evaluasi ditentukan, Anda dapat melihat gambar nomor tiga belas yang direkonstruksi
reconstruct_image(df =test_x, image_number = 13)
INFO:tensorflow:Restoring parameters from ./model.ckptModel restored.(1, 1024)
Ringkasan
Tujuan utama autoencoder adalah untuk memampatkan data masukan, dan kemudian mengekstraknya menjadi keluaran yang mirip dengan data aslinya.
Arsitektur simetris autoencoder dengan lapisan pivot dinamai lapisan tengah.
Anda dapat membuat autoencoder menggunakan:
- Parsial: untuk membuat lapisan padat dengan pengaturan tipikal:
-
tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer
- dense_layer (): untuk membuat perkalian matriks
Anda dapat menentukan fungsi kerugian dan pengoptimalan dengan:
loss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)
Terakhir jalankan sesi untuk melatih model.