Apa itu Autoencoder?
An Autoencoder adalah alat untuk data pengekodan cekap secara tanpa pengawasan pembelajaran. Ini adalah sejenis rangkaian saraf tiruan yang membantu anda mempelajari representasi kumpulan data untuk pengurangan dimensi dengan melatih rangkaian saraf untuk mengabaikan kebisingan isyarat. Ini adalah alat yang bagus untuk mencipta semula input.
Dengan kata mudah, mesin mengambil, katakan gambar, dan dapat menghasilkan gambar yang berkait rapat. Input dalam rangkaian saraf semacam ini tidak berlabel, yang bermaksud rangkaian itu mampu belajar tanpa pengawasan. Lebih tepat lagi, input dikodkan oleh rangkaian untuk hanya memfokuskan pada ciri yang paling kritikal. Ini adalah salah satu sebab mengapa autoencoder popular untuk pengurangan dimensi. Selain itu, autoencoder dapat digunakan untuk menghasilkan model pembelajaran generatif . Sebagai contoh, rangkaian saraf dapat dilatih dengan sekumpulan wajah dan kemudian dapat menghasilkan wajah baru.
Dalam tutorial TensorFlow Autoencoder ini, anda akan belajar:
- Apa itu Autoencoder?
- Bagaimana Autoencoder berfungsi?
- Contoh Autoencoder Bertumpuk
- Bina Autoencoder dengan TensorFlow
- Pemprosesan gambar
- Tetapkan Pengukur Data
- Bina rangkaian
Bagaimana Autoencoder berfungsi?
Tujuan autoencoder adalah untuk menghasilkan penghampiran input dengan hanya memfokuskan pada ciri-ciri penting. Anda mungkin berfikir mengapa tidak hanya belajar menyalin dan menampal input untuk menghasilkan output. Sebenarnya, autoencoder adalah sekumpulan kekangan yang memaksa rangkaian mempelajari cara baru untuk mewakili data, berbeza daripada hanya menyalin output.
Autoencoder khas didefinisikan dengan input, representasi dalaman dan output (perkiraan input). Pembelajaran berlaku pada lapisan yang melekat pada perwakilan dalaman. Sebenarnya, terdapat dua blok lapisan utama yang kelihatan seperti rangkaian saraf tradisional. Perbezaan sedikit adalah lapisan yang mengandungi output harus sama dengan input. Dalam gambar di bawah, input asal masuk ke blok pertama yang disebut encoder . Perwakilan dalaman ini memampatkan (mengurangkan) ukuran input. Pada blok kedua berlaku pembinaan semula input. Ini adalah fasa penyahkodan.
Bekerja Autoencoder
Model akan mengemas kini bobot dengan meminimumkan fungsi kerugian. Modelnya dikenakan hukuman jika output pembinaan semula berbeza dengan input.
Secara konkrit, bayangkan gambar dengan ukuran 50x50 (iaitu, 250 piksel) dan rangkaian saraf dengan hanya satu lapisan tersembunyi yang terdiri daripada seratus neuron. Pembelajaran dilakukan pada peta ciri yang dua kali lebih kecil daripada input. Ini bermaksud rangkaian perlu mencari jalan untuk menyusun semula 250 piksel dengan hanya vektor neuron sama dengan 100.
Contoh Autoencoder Bertumpuk
Dalam tutorial Autoencoder ini, anda akan belajar bagaimana menggunakan autoencoder bertumpuk. Seni bina serupa dengan rangkaian neural tradisional. Input masuk ke lapisan tersembunyi untuk dimampatkan, atau mengurangi ukurannya, dan kemudian mencapai lapisan pembinaan semula. Objektifnya adalah untuk menghasilkan gambar output sedekat yang asal. Model harus belajar cara untuk mencapai tugasnya di bawah sekumpulan kekangan, iaitu dengan dimensi yang lebih rendah.
Pada masa kini, Autoencoders dalam Pembelajaran Dalam digunakan terutamanya untuk membuat gambar. Bayangkan gambar dengan calar; seorang manusia masih dapat mengenali kandungannya. Idea untuk membuat autoencoder adalah menambahkan bunyi pada gambar untuk memaksa rangkaian mempelajari corak di sebalik data.
Keluarga berguna Autoencoder Deep Learning adalah autoencoder variasional. Rangkaian jenis ini dapat menghasilkan gambar baru. Bayangkan anda melatih rangkaian dengan imej lelaki; rangkaian seperti itu dapat menghasilkan wajah baru.
Bina Autoencoder dengan TensorFlow
Dalam tutorial ini, anda akan belajar bagaimana membina autoencoder bertumpuk untuk membina semula gambar.
Anda akan menggunakan set data CIFAR-10 yang mengandungi 60000 gambar 32x32 warna. Set data Autoencoder sudah dibahagikan antara 50000 gambar untuk latihan dan 10000 untuk ujian. Terdapat sehingga sepuluh kelas:
- Kapal terbang
- Kereta
- Burung
- Kucing
- Rusa
- Anjing
- Katak
- Kuda
- Kapal
- Lori
Anda perlu memuat turun gambar di URL ini https://www.cs.toronto.edu/~kriz/cifar.html dan nyahzipnya. Folder untuk-10-batches-py mengandungi lima kumpulan data dengan masing-masing 10000 gambar dalam urutan rawak.
Sebelum anda membina dan melatih model anda, anda perlu menerapkan beberapa pemprosesan data. Anda akan meneruskan seperti berikut:
- Import data
- Tukarkan data ke format hitam putih
- Tambahkan semua kumpulan
- Bina set data latihan
- Bina visualizer gambar
Pemprosesan gambar
Langkah 1) Import data.
Menurut laman web rasmi, anda boleh memuat naik data dengan kod berikut. Kod Autoencoder akan memuatkan data dalam kamus dengan data dan label . Perhatikan bahawa kodnya adalah 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) Tukarkan data ke format hitam putih
Untuk kesederhanaan, anda akan menukar data ke skala kelabu. Maksudnya, dengan hanya satu dimensi berbanding tiga untuk gambar warna. Sebilangan besar rangkaian saraf berfungsi hanya dengan input satu dimensi.
def grayscale(im):return im.reshape(im.shape[0], 3, 32, 32).mean(1).reshape(im.shape[0], -1)
Langkah 3) Tambahkan semua kumpulan
Sekarang kedua fungsi dibuat dan set data dimuat, anda boleh menulis gelung untuk menambahkan data dalam memori. Sekiranya anda memeriksa dengan teliti, fail unzip dengan data tersebut diberi nama data_batch_ dengan nombor dari 1 hingga 5. Anda boleh melingkar fail dan menambahkannya ke data.
Apabila langkah ini selesai, anda menukar data warna ke format skala kelabu. Seperti yang anda lihat, bentuk data adalah 50000 dan 1024. Piksel 32 * 32 kini rata hingga 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: Tukar './cifar-10-batches-py/data_batch_' ke lokasi sebenar fail anda. Sebagai contoh untuk mesin Windows, jalannya dapat berupa nama file = 'E: \ cifar-10-batches-py \ data_batch_' + str (i)
Langkah 4) Bina set data latihan
Untuk menjadikan latihan lebih pantas dan mudah, anda akan melatih model pada gambar kuda sahaja. Kuda adalah kelas ketujuh dalam data label. Seperti yang disebutkan dalam dokumentasi kumpulan data CIFAR-10, setiap kelas berisi 5000 gambar. Anda boleh mencetak bentuk data untuk mengesahkan terdapat 5.000 gambar dengan 1024 lajur seperti yang ditunjukkan dalam langkah contoh TensorFlow Autoencoder di bawah.
horse_i = np.where(y == 7)[0]horse_x = x[horse_i]print(np.shape(horse_x))(5000, 1024)
Langkah 5) Bina visualizer gambar
Akhirnya, anda membina fungsi untuk memplot gambar. Anda memerlukan fungsi ini untuk mencetak gambar yang dibina semula dari autoencoder.
Cara mudah untuk mencetak gambar adalah dengan menggunakan objek yang ditunjukkan dari perpustakaan matplotlib. Perhatikan bahawa, anda perlu menukar bentuk data dari 1024 hingga 32 * 32 (iaitu 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 ini mengambil 3 argumen:
- Imej: input
- Bentuk: senarai, dimensi gambar
- Cmap: pilih peta warna. Secara lalai, kelabu
Anda boleh mencuba gambar pertama dalam set data. Anda mesti melihat seorang lelaki di atas kuda.
plot_image(horse_x[1], shape=[32, 32], cmap = "Greys_r")
Tetapkan Pengukur Data
Baiklah, setelah set data siap digunakan, anda boleh mula menggunakan Tensorflow. Sebelum membina model, mari kita gunakan penganggar Dataset Tensorflow untuk memberi makan rangkaian.
Anda akan membina Dataset dengan TensorFlow estimator. Untuk menyegarkan fikiran, anda perlu menggunakan:
- dari_tensor_slice
- ulangi
- kumpulan
Kod penuh untuk membina set data adalah:
dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)
Perhatikan bahawa, x adalah tempat letak dengan bentuk berikut:
- [Tidak ada, n_inputs]: Tetapkan ke Tidak ada kerana jumlah umpan gambar ke rangkaian sama dengan ukuran kumpulan.
untuk perinciannya, sila rujuk tutorial regresi linier.
Selepas itu, anda perlu membuat iterator. Tanpa garis kod ini, data tidak akan melalui saluran paip.
iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()
Sekarang saluran paip sudah siap, anda dapat memeriksa apakah gambar pertama sama seperti sebelumnya (iaitu, seorang lelaki berkuda).
Anda menetapkan ukuran kumpulan menjadi 1 kerana anda hanya mahu memasukkan set data dengan satu gambar. Anda dapat melihat dimensi data dengan cetakan (sess.run (ciri). Bentuk). Ia sama dengan (1, 1024). 1 bermaksud hanya satu gambar dengan 1024 setiap suapan. Sekiranya ukuran kumpulan ditetapkan menjadi dua, maka dua gambar akan melalui saluran paip. (Jangan ubah ukuran kumpulan. Jika tidak, ia akan menimbulkan kesalahan. Hanya satu gambar pada satu masa yang dapat pergi 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)
Bina rangkaian
Sudah tiba masanya untuk membina rangkaian. Anda akan melatih autoencoder bertumpuk, iaitu rangkaian dengan beberapa lapisan tersembunyi.
Rangkaian anda akan mempunyai satu lapisan input dengan 1024 titik, iaitu 32x32, bentuk gambar.
Blok pengekod akan mempunyai satu lapisan tersembunyi atas dengan 300 neuron, lapisan pusat dengan 150 neuron. Blok penyahkod adalah simetri dengan pengekod. Anda dapat menggambarkan rangkaian dalam gambar di bawah. Perhatikan bahawa anda boleh mengubah nilai lapisan tersembunyi dan tengah.
Membina rangkaian untuk Autoencoder
Membina autoencoder sangat serupa dengan model pembelajaran mendalam yang lain.
Anda akan membina model mengikuti langkah-langkah berikut:
- Tentukan parameter
- Tentukan lapisan
- Tentukan seni bina
- Tentukan pengoptimuman
- Jalankan model
- Nilaikan model
Pada bahagian sebelumnya, anda belajar bagaimana membuat saluran paip untuk memberi makan model, jadi tidak perlu membuat sekali lagi set data. Anda akan membina autoencoder dengan empat lapisan. Anda menggunakan inisialisasi Xavier. Ini adalah teknik untuk menetapkan berat awal sama dengan varians input dan output. Akhirnya, anda menggunakan fungsi pengaktifan elu. Anda mengatur fungsi kehilangan dengan pengatur L2.
Langkah 1) Tentukan parameter
Langkah pertama menyiratkan untuk menentukan bilangan neuron di setiap lapisan, kadar pembelajaran dan hiperparameter pengatur.
Sebelum itu, anda mengimport fungsi sebahagiannya. Ini adalah kaedah yang lebih baik untuk menentukan parameter lapisan yang padat. Kod di bawah menentukan nilai seni bina autoencoder. Seperti yang disenaraikan sebelumnya, autoencoder mempunyai dua lapisan, dengan 300 neuron di lapisan pertama dan 150 di lapisan kedua. Nilai mereka disimpan dalam n_hidden_1 dan n_hidden_2.
Anda perlu menentukan kadar pembelajaran dan hiperparameter 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 contrib penganggar. Dalam penganggar yang sama, anda boleh menambahkan pengatur 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 lapisan
Semua parameter lapisan padat telah ditetapkan; anda boleh mengemas segala-galanya dalam pemboleh ubah dense_layer dengan menggunakan objek separa. dense_layer yang menggunakan pengaktifan 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 seni bina
Sekiranya anda melihat gambar seni bina, anda perhatikan bahawa rangkaian menumpuk tiga lapisan dengan lapisan output. Dalam kod di bawah, anda menyambungkan lapisan yang sesuai. Sebagai contoh, lapisan pertama menghitung produk titik antara ciri matriks input dan matriks yang mengandungi 300 berat. Setelah produk titik dihitung, output akan menuju ke fungsi pengaktifan Elu. Keluaran menjadi input lapisan seterusnya, sebab itulah anda menggunakannya untuk mengira tersembunyi_2 dan seterusnya. Pendaraban matriks adalah sama untuk setiap lapisan kerana anda menggunakan fungsi pengaktifan yang sama. Perhatikan bahawa lapisan terakhir, output, tidak menerapkan fungsi pengaktifan. Ia masuk akal kerana ini adalah input yang dibina semula
## 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 pengoptimuman
Langkah terakhir adalah membina pengoptimum. Anda menggunakan Ralat Persegi Mean sebagai fungsi kehilangan. Sekiranya anda mengingati tutorial mengenai regresi linier, anda tahu bahawa MSE dihitung dengan perbezaan antara output yang diramalkan dan label sebenar. Di sini, label adalah ciri kerana model cuba menyusun semula input. Oleh itu, anda mahukan nilai bagi jumlah perbezaan segi empat sama antara output dan input yang diramalkan. Dengan TensorFlow, anda dapat mengkod fungsi kehilangan seperti berikut:
loss = tf.reduce_mean(tf.square(outputs - features))
Kemudian, anda perlu mengoptimumkan fungsi kerugian. Anda menggunakan pengoptimum Adam untuk mengira kecerunan. Fungsi objektif adalah untuk mengurangkan kerugian.
## Optimizeloss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)
Satu lagi pengaturan sebelum melatih model. Anda ingin menggunakan ukuran kumpulan 150, iaitu memberi makan saluran paip dengan 150 gambar setiap lelaran. Anda perlu mengira bilangan lelaran secara manual. Perkara ini sangat mustahak untuk dilakukan:
Sekiranya anda ingin menyampaikan 150 gambar setiap kali dan anda tahu terdapat 5000 gambar dalam set data, jumlah lelaran sama dengan. Di python, anda boleh menjalankan kod berikut dan memastikan outputnya 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
Akhir sekali, latih model. Anda melatih model dengan 100 zaman. Maksudnya, model akan melihat 100 kali gambar hingga berat yang dioptimumkan.
Anda sudah biasa dengan kod untuk melatih model di Tensorflow. Perbezaan sedikit adalah memasukkan data sebelum menjalankan latihan. Dengan cara ini, model melatih dengan lebih pantas.
Anda berminat mencetak kerugian setelah sepuluh zaman untuk melihat apakah model itu mempelajari sesuatu (iaitu, kerugiannya semakin berkurang). Latihan mengambil masa 2 hingga 5 minit, bergantung pada perkakasan 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) Nilaikan model
Sekarang setelah anda melatih model anda, inilah masanya untuk menilai. Anda perlu mengimport sert ujian 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, kod menjadi test_data = unsickle (r "E: \ cifar-10-batches-py \ test_batch")
Anda boleh mencetak gambar 13, yang merupakan kuda
plot_image(test_x[13], shape=[32, 32], cmap = "Greys_r")
Untuk menilai model, anda akan menggunakan nilai piksel gambar ini dan melihat apakah pengekod dapat membina semula gambar yang sama setelah menyusut 1024 piksel. Perhatikan bahawa, anda menentukan fungsi untuk menilai model pada gambar yang berbeza. Model harus berfungsi lebih baik hanya pada kuda.
Fungsi ini mengambil dua argumen:
- df: Import data ujian
- number_number: nyatakan gambar yang hendak diimport
Fungsi ini terbahagi kepada tiga bahagian:
- Bentuk semula gambar ke dimensi yang betul iaitu 1, 1024
- Umpan model dengan gambar yang tidak kelihatan, encode / decode gambar
- Cetak gambar yang sebenar dan dibina semula
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()
Setelah fungsi penilaian ditentukan, anda dapat melihat nombor gambar yang dibina semula tiga belas
reconstruct_image(df =test_x, image_number = 13)
INFO:tensorflow:Restoring parameters from ./model.ckptModel restored.(1, 1024)
Ringkasan
Tujuan utama autoencoder adalah memampatkan data input, dan kemudian memampatkannya menjadi output yang mirip dengan data asalnya.
Seni bina autodenoder simetris dengan lapisan pangsi bernama lapisan tengah.
Anda boleh membuat autoencoder menggunakan:
- Sebahagian: untuk membuat lapisan padat dengan tetapan khas:
-
tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer
- dense_layer (): untuk membuat pendaraban matriks
anda boleh menentukan fungsi kerugian dan pengoptimuman dengan:
loss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)
Terakhir menjalankan sesi untuk melatih model.