Autoencoder di TensorFlow dengan Contoh

Apa itu Autoencoder dalam Pembelajaran Mendalam?

An Penyandi otomatis adalah alat untuk mempelajari pengkodean data secara efisien tanpa pengawasan. 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 masukan.

Dengan kata sederhana, mesin mengambil, katakanlah sebuah gambar, dan dapat menghasilkan gambar yang berkaitan erat. Masukan dalam jaringan saraf jenis ini tidak berlabel, artinya jaringan mampu belajar tanpa pengawasan. Lebih tepatnya, masukan dikodekan oleh jaringan untuk fokus hanya pada fitur yang paling penting. Inilah salah satu alasan mengapa autoencoder populer untuk pengurangan dimensi. Selain itu, autoencoder dapat digunakan untuk memproduksi model pembelajaran generatif. Misalnya, jaringan saraf dapat dilatih dengan sekumpulan wajah dan kemudian dapat menghasilkan wajah baru.

Bagaimana cara kerja TensorFlow Autoencoder?

Tujuan dari autoencoder adalah untuk menghasilkan perkiraan masukan dengan hanya berfokus pada fitur-fitur penting. Anda mungkin berpikir mengapa tidak mempelajari cara menyalin dan menempelkan masukan saja untuk menghasilkan keluaran. Faktanya, autoencoder adalah sekumpulan batasan yang memaksa jaringan mempelajari cara baru untuk merepresentasikan data, berbeda dari sekadar menyalin output.

Autoencoder tipikal ditentukan dengan masukan, representasi internal, dan keluaran (perkiraan masukan). Pembelajaran terjadi pada lapisan yang melekat pada representasi internal. Faktanya, ada dua blok lapisan utama yang terlihat seperti jaringan saraf tradisional. Sedikit perbedaannya adalah lapisan yang berisi keluaran harus sama dengan masukan. Pada gambar di bawah, masukan asli masuk ke blok pertama yang disebut encoder. Representasi internal ini memampatkan (mengurangi) ukuran masukan. Pada blok kedua terjadi rekonstruksi input. Ini adalah fase decoding.

Model akan memperbarui bobot dengan meminimalkan fungsi kerugian. Model dikenai sanksi jika keluaran rekonstruksi berbeda dengan masukan.

Secara konkret, bayangkan sebuah gambar berukuran 50x50 (yaitu 250 piksel) dan jaringan saraf dengan hanya satu lapisan tersembunyi yang terdiri dari seratus neuron. Pembelajaran dilakukan pada peta fitur yang dua kali lebih kecil dari input. Artinya, jaringan perlu menemukan cara untuk merekonstruksi 250 piksel hanya dengan vektor neuron yang sama dengan 100.

Contoh Autoencoder Bertumpuk

Dalam tutorial Autoencoder ini, Anda akan mempelajari cara menggunakan autoencoder bertumpuk. Arsitekturnya mirip dengan jaringan saraf tradisional. Input masuk ke lapisan tersembunyi untuk dikompresi, atau dikurangi ukurannya, lalu mencapai lapisan rekonstruksi. Tujuannya adalah menghasilkan gambar keluaran yang sedekat mungkin dengan gambar asli. Model harus mempelajari cara untuk mencapai tugasnya di bawah serangkaian kendala, yaitu, dengan dimensi yang lebih rendah.

Saat ini, Autoencoder masuk Belajar mendalam terutama digunakan untuk menolak gambar. Bayangkan sebuah gambar dengan goresan; manusia masih bisa mengenali isinya. Ide untuk menolak autoencoder adalah menambahkan noise pada gambar untuk memaksa jaringan mempelajari pola di balik data.

Kelompok Autoencoder Deep Learning berguna lainnya adalah autoencoder variasional. Jenis jaringan ini dapat menghasilkan gambar baru. Bayangkan Anda melatih jaringan dengan gambar seorang pria; jaringan seperti itu bisa melahirkan wajah-wajah baru.

Cara Membuat Autoencoder dengan TensorFlow

Dalam tutorial ini, Anda akan mempelajari cara membuat autoencoder bertumpuk untuk merekonstruksi gambar.

Anda akan menggunakan Dataset CIFAR-10 yang berisi 60000 gambar berwarna 32×32. Kumpulan data Autoencoder sudah dibagi antara 50000 gambar untuk pelatihan dan 10000 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 mengekstraknya. Folder for-10-batches-py berisi lima kumpulan data dengan masing-masing 10000 gambar dalam urutan acak.

Sebelum membuat dan melatih model, Anda perlu menerapkan beberapa pemrosesan data. Anda akan melanjutkan sebagai berikut:

1. Impor data
2. Ubah data menjadi format hitam putih
3. Tambahkan semua batch
4. Buatlah kumpulan data pelatihan
5. Membangun visualisator gambar

Pra-pemrosesan gambar

Langkah 1) Impor data

Menurut situs web resmi, 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 np
import tensorflow as tf
import pickle
def unpickle(file):
    import pickle
    with open(file, 'rb') as fo:
        dict = pickle.load(fo, encoding='latin1')
    return dict

Langkah 2) Ubah data menjadi format hitam putih

Untuk mempermudah, Anda akan mengonversi data menjadi skala abu-abu. Artinya, dengan hanya satu dimensi berbanding tiga untuk gambar berwarna. Sebagian besar jaringan saraf hanya bekerja dengan masukan 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 batch

Sekarang setelah kedua fungsi dibuat dan kumpulan data dimuat, Anda dapat menulis perulangan untuk menambahkan data ke memori. Jika Anda memeriksanya dengan cermat, file unzip yang berisi data tersebut diberi nama data_batch_ dengan nomor dari 1 hingga 5. Anda dapat mengulang file tersebut dan menambahkannya ke data.

Ketika 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 tahun 2014.

# Load the data into memory
data, labels = [], []
## Loop over the b
for 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 file Anda. Misalnya untuk Windows mesin, jalurnya bisa berupa nama file = 'E:\cifar-10-batches-py\data_batch_' + str(i)

Langkah 4) Buat kumpulan data pelatihan

Untuk mempercepat dan mempermudah pelatihan, Anda akan melatih model pada gambar kuda saja. Kuda-kuda tersebut merupakan kelas ketujuh dalam data label. Seperti disebutkan dalam dokumentasi dataset CIFAR-10, setiap kelas berisi 5000 gambar. Anda dapat mencetak bentuk data untuk mengonfirmasi terdapat 5.000 gambar dengan 1024 kolom seperti gambar di bawah ini TensorFlow Langkah contoh autoencoder.

horse_i = np.where(y == 7)[0]
horse_x = x[horse_i]
print(np.shape(horse_x)) 
(5000, 1024)

Langkah 5) Buat visualisator gambar

Terakhir, Anda membuat fungsi untuk memplot gambar. Anda memerlukan fungsi ini untuk mencetak gambar yang direkonstruksi dari autoencoder.

Cara mudah untuk mencetak gambar adalah dengan menggunakan objek imshow dari perpustakaan matplotlib. Perhatikan bahwa, Anda perlu mengonversi bentuk data dari 1024 menjadi 32*32 (yaitu format gambar).

# To plot pretty figures
%matplotlib inline
import matplotlib
import matplotlib.pyplot as plt
def plot_image(image, shape=[32, 32], cmap = "Greys_r"):
    plt.imshow(image.reshape(shape), cmap=cmap,interpolation="nearest")
    plt.axis("off")   

Fungsi ini membutuhkan 3 argumen:

• Gambar: masukan
• Bentuknya: daftar, dimensi gambar
• cma:pilih peta warna. Secara default, abu-abu

Anda dapat mencoba memplot gambar pertama dalam kumpulan data. Anda akan melihat seorang pria menunggang kuda.

plot_image(horse_x[1], shape=[32, 32], cmap = "Greys_r")

Tetapkan Penaksir Kumpulan Data

Baiklah, setelah dataset siap digunakan, Anda bisa mulai menggunakan Tensorflow. Sebelum membuat model, mari kita gunakan estimator Dataset Tensorflow untuk memberi masukan pada jaringan.

Anda akan membuat Kumpulan Data dengan estimator TensorFlow. Untuk menyegarkan pikiran Anda, Anda perlu menggunakan:

• dari_tensor_slices
• ulangi
• sekumpulan

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]: Diatur ke Tidak Ada karena jumlah umpan gambar ke jaringan sama dengan ukuran batch.

untuk detailnya silahkan lihat tutorial di regresi linier.

Setelah itu, Anda perlu membuat iterator. Tanpa baris kode ini, tidak ada data yang akan melewati pipeline.

iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()

Sekarang pipeline sudah siap, Anda dapat memeriksa apakah gambar pertama sama dengan sebelumnya (yaitu, seorang pria di atas kuda).

Anda menyetel ukuran batch ke 1 karena Anda hanya ingin memasukkan satu gambar ke dalam kumpulan data. Anda dapat melihat dimensi data dengan print(sess.run(features).shape). Nilainya sama dengan (1, 1024). 1 berarti hanya satu gambar dengan 1024 gambar yang dimasukkan masing-masing. Jika ukuran batch disetel ke dua, maka dua gambar akan masuk ke dalam alur kerja. (Jangan ubah ukuran batch. Jika tidak, akan muncul kesalahan. Hanya satu gambar dalam satu waktu yang dapat masuk ke fungsi plot_image().)

## Parameters
n_inputs = 32 * 32
BATCH_SIZE = 1
batch_size = tf.placeholder(tf.int64)

# using a placeholder
x = tf.placeholder(tf.float32, shape=[None,n_inputs])
## Dataset
dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)
iter = dataset.make_initializable_iterator() # create the iterator
features = iter.get_next()

## Print the image
with tf.Session() as sess:
    # feed the placeholder with data
    sess.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 32×32, bentuk gambar.

Blok encoder akan memiliki satu lapisan tersembunyi teratas dengan 300 neuron, lapisan tengah dengan 150 neuron. Blok decoder simetris dengan encoder. Anda dapat memvisualisasikan jaringan pada gambar di bawah ini. Perhatikan bahwa Anda dapat mengubah nilai lapisan tersembunyi dan tengah.

Membangun autoencoder sangat mirip dengan model pembelajaran mendalam lainnya.

Anda akan membangun model dengan mengikuti langkah-langkah berikut:

1. Tentukan parameternya
2. Tentukan lapisannya
3. Tentukan arsitekturnya
4. Tentukan optimasi
5. Jalankan modelnya
6. Evaluasi modelnya

Di bagian sebelumnya, Anda telah mempelajari cara membuat alur untuk memasukkan model, sehingga tidak perlu membuat kumpulan data lagi. Anda akan membuat autoencoder dengan empat lapisan. Anda menggunakan inisialisasi Xavier. Ini adalah teknik untuk menetapkan bobot awal 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 adalah menentukan jumlah neuron di setiap lapisan, kecepatan pembelajaran, dan hyperparameter pengatur.

Sebelum itu, Anda mengimpor sebagian fungsi tersebut. Ini adalah metode yang lebih baik untuk menentukan parameter lapisan padat. Kode di bawah ini menentukan nilai arsitektur autoencoder. Seperti yang tercantum sebelumnya, autoencoder memiliki dua lapisan, dengan 300 neuron di lapisan pertama dan 150 di lapisan kedua. Nilainya disimpan dalam n_hidden_1 dan n_hidden_2.

Anda perlu menentukan kecepatan pembelajaran dan hyperparameter L2. Nilainya disimpan di learning_rate dan l2_reg

from functools import partial

## Encoder
n_hidden_1 = 300
n_hidden_2 = 150  # codings

## Decoder
n_hidden_3 = n_hidden_1
n_outputs = n_inputs

learning_rate = 0.01
l2_reg = 0.0001

Teknik inisialisasi Xavier disebut dengan objek xavier_initializer dari estimator contrib. Di estimator yang sama, Anda dapat menambahkan regularizer dengan l2_regularizer

## Define the Xavier initialization
xav_init =  tf.contrib.layers.xavier_initializer()
## Define the L2 regularizer
l2_regularizer = tf.contrib.layers.l2_regularizer(l2_reg)

Langkah 2) Tentukan lapisannya

Semua parameter lapisan padat telah ditetapkan; Anda dapat mengemas semuanya ke dalam variabel solid_layer dengan menggunakan objek parsial. padat_lapisan yang menggunakan aktivasi ELU, inisialisasi Xavier, dan regularisasi L2.

## Create the dense layer
dense_layer = partial(tf.layers.dense,
                         activation=tf.nn.elu,
                         kernel_initializer=xav_init,
                         kernel_regularizer=l2_regularizer)

Langkah 3) Tentukan arsitekturnya

Jika Anda melihat gambar arsitekturnya, Anda akan melihat bahwa jaringan menumpuk tiga lapisan dengan lapisan keluaran. Dalam kode di bawah ini, Anda menghubungkan lapisan yang sesuai. Misalnya, lapisan pertama menghitung produk titik antara fitur matriks masukan dan matriks yang berisi 300 bobot. Setelah produk titik dihitung, keluaran masuk ke fungsi aktivasi Elu. Keluaran menjadi masukan dari lapisan berikutnya, itulah sebabnya 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 mul
hidden_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 optimasi

Langkah terakhir adalah membuat 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 prediksi keluaran dan masukan. 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.

## Optimize
loss = 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 memasukkan pipeline dengan 150 gambar setiap iterasi. Anda perlu menghitung jumlah iterasi secara manual. Ini adalah hal yang sepele untuk dilakukan:

Jika Anda ingin mengirimkan 150 gambar setiap kali dan Anda tahu ada 5000 gambar dalam kumpulan data, jumlah iterasinya sama dengan . Dalam python, Anda dapat menjalankan kode berikut dan memastikan outputnya adalah 33:

BATCH_SIZE = 150
### Number of batches :  length dataset / batch size
n_batches = horse_x.shape[0] // BATCH_SIZE
print(n_batches)
33

Langkah 5) Jalankan modelnya

Terakhir, latih modelnya. Anda melatih model dengan 100 epoch. Artinya, model akan melihat gambar 100 kali lipat dari bobot yang dioptimalkan.

Anda sudah familiar dengan kode untuk melatih model di Tensorflow. Sedikit perbedaannya adalah menyalurkan data sebelum menjalankan pelatihan. Dengan cara ini, model berlatih lebih cepat.

Anda tertarik untuk mencetak kerugian setelah sepuluh periode untuk melihat apakah model tersebut mempelajari sesuatu (yaitu, kerugiannya berkurang). Pelatihan ini memakan waktu 2 hingga 5 menit, tergantung pada perangkat keras mesin Anda.

## Set params
n_epochs = 100

## Call Saver to save the model and re-use it later during evaluation
saver = tf.train.Saver()

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    # initialise iterator with train data
    sess.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 shown
            print("\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.455
10 Train MSE: 1672.676
20 Train MSE: 1514.709
30 Train MSE: 1404.3118
40 Train MSE: 1425.058
50 Train MSE: 1479.0631
60 Train MSE: 1609.5259
70 Train MSE: 1482.3223
80 Train MSE: 1445.7035
90 Train MSE: 1453.8597
Model saved in path: ./model.ckpt

Langkah 6) Evaluasi modelnya

Sekarang setelah model Anda dilatih, sekarang saatnya untuk mengevaluasinya. Anda perlu mengimpor tes sert 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 sebuah Windows mesin, kodenya menjadi test_data = unpickle(r”E:\cifar-10-batches-py\test_batch”)

Anda bisa mencoba mencetak gambar 13 yaitu seekor kuda

plot_image(test_x[13], shape=[32, 32], cmap = "Greys_r")

Untuk mengevaluasi model, Anda akan menggunakan nilai piksel gambar ini dan melihat apakah encoder dapat merekonstruksi gambar yang sama setelah menyusutkan 1024 piksel. Perhatikan bahwa, Anda menentukan fungsi untuk mengevaluasi model pada gambar yang berbeda. Model tersebut seharusnya bekerja lebih baik hanya pada kuda.

Fungsi ini membutuhkan dua argumen:

• df: Impor data pengujian
• gambar_nomor: menunjukkan gambar apa yang akan diimpor

Fungsinya dibagi menjadi tiga bagian:

1. Bentuk kembali gambar ke dimensi yang benar yaitu 1, 1024
2. Beri makan model dengan gambar yang tidak terlihat, enkode/dekode gambar
3. 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, 1024
    x_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 image
    with 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 image
        outputs_val = outputs.eval()
        print(outputs_val.shape)
        fig = plt.figure()
      # Plot real
        ax1 = fig.add_subplot(121)
        plot_image(x_test_1, shape=[32, 32], cmap = "Greys_r")
      # Plot estimated
        ax2 = 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.ckpt
Model restored.
(1, 1024)

Ringkasan

• Tujuan utama autoencoder adalah untuk mengompresi data masukan, lalu mengekstraknya menjadi keluaran yang mirip dengan data asli.
• Arsitektur autoencoder simetris dengan lapisan pivot yang dinamakan lapisan pusat.
• Anda dapat membuat autoencoder menggunakan:

Sebagian: untuk membuat lapisan padat dengan pengaturan khas:

  	tf.layers.dense,                         
  	activation=tf.nn.elu,                         
  	kernel_initializer=xav_init,                         
  	kernel_regularizer=l2_regularizer

lapisan_padat(): 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.