Örnekle TensorFlow'da Otomatik Kodlayıcı

Derin Öğrenmede Otomatik Kodlayıcı Nedir?

An Otomatik kodlayıcı Veri kodlamayı verimli bir şekilde öğrenmek için bir araçtır. denetimsiz tarz. Bu bir türüdür. yapay sinir ağı Bu, sinir ağını sinyal gürültüsünü yok sayacak şekilde eğiterek boyut indirgeme için veri kümelerinin temsilini öğrenmenize yardımcı olan harika bir araçtır. Girişi yeniden oluşturmak için mükemmel bir araçtır.

Basitçe söylemek gerekirse, makine, diyelim ki bir görüntü alıyor ve ona çok benzeyen bir resim üretebiliyor. Bu tür sinir ağlarındaki girdi etiketlenmemiş olduğundan, ağ denetim olmadan öğrenme yeteneğine sahiptir. Daha açık ifadeyle, girdi ağ tarafından yalnızca en kritik özelliğe odaklanacak şekilde kodlanır. Bu, otoenkoderlerin boyut indirgeme için popüler olmasının nedenlerinden biridir. Ayrıca, otoenkoderler üretken öğrenme modelleri oluşturmak için de kullanılabilir. Örneğin, sinir ağı bir dizi yüzle eğitilebilir ve daha sonra yeni yüzler üretebilir.

TensorFlow Otomatik Kodlayıcı nasıl çalışır?

Otomatik kodlayıcının amacı, yalnızca temel özelliklere odaklanarak girişin yaklaşık bir tahminini üretmektir. Çıktıyı üretmek için neden yalnızca girdiyi kopyalayıp yapıştırmayı öğrenmediğinizi düşünebilirsiniz. Aslında bir otomatik kodlayıcı, yalnızca çıktıyı kopyalamaktan farklı olarak ağı verileri temsil etmenin yeni yollarını öğrenmeye zorlayan bir dizi kısıtlamadır.

Tipik bir otoenkoder, bir giriş, bir iç temsil ve bir çıkış (girişin bir yaklaşık değeri) ile tanımlanır. Öğrenme, iç temsile bağlı katmanlarda gerçekleşir. Aslında, geleneksel bir sinir ağına benzeyen iki ana katman bloğu vardır. Küçük bir fark, çıkışı içeren katmanın girişe eşit olması gerektiğidir. Aşağıdaki diyagramda, orijinal giriş, kodlayıcı adı verilen ilk bloğa girer. Bu iç temsil, girişin boyutunu sıkıştırır (küçültür). İkinci blokta girişin yeniden yapılandırılması gerçekleşir. Bu, kod çözme aşamasıdır.

Model, kayıp fonksiyonunu en aza indirerek ağırlıkları güncelleyecektir. Yeniden yapılandırma çıktısı girdiden farklıysa model cezalandırılır.

Somut olarak, 50×50 (yani 2,500 piksel) boyutunda bir resim ve yüz nöron içeren tek bir gizli katmana sahip bir sinir ağı hayal edin. Öğrenme, girişten yirmi beş kat daha küçük bir özellik haritası üzerinde yapılır. Bu, ağın yalnızca 100 nöronluk bir vektör kullanarak 2,500 pikseli yeniden oluşturmanın bir yolunu bulması gerektiği anlamına gelir.

Yığılmış Otomatik Kodlayıcı Örneği

Bu Otomatik Kodlayıcı (Autoencoder) eğitiminde, yığılmış bir otomatik kodlayıcının nasıl kullanılacağını öğreneceksiniz. Mimari, geleneksel bir sinir ağına benzer. Giriş, sıkıştırılmak veya boyutunun küçültülmesi için gizli bir katmana gider ve ardından yeniden yapılandırma katmanlarına ulaşır. Amaç, orijinaline mümkün olduğunca yakın bir çıktı görüntüsü üretmektir. Model, bir dizi kısıtlama altında, yani daha düşük bir boyutta, görevini başarmanın bir yolunu öğrenmelidir.

Günümüzde derin öğrenmede otoenkoderler esas olarak bir görüntüyü gürültüden arındırmak için kullanılmaktadır. Çiziklerle dolu bir görüntüyü düşünün; bir insan yine de içeriği tanıyabilir. Gürültüden arındırma otoenkoderinin temel fikri, ağın verilerin arkasındaki deseni öğrenmesini sağlamak için resme gürültü eklemektir.

Otomatik kodlayıcıların diğer kullanışlı ailesi Derin Öğrenme Varyasyonel otoenkoderdir. Bu tür ağlar yeni görüntüler üretebilir. Bir adamın görüntüsüyle bir ağı eğittiğinizi düşünün; böyle bir ağ yeni yüzler üretebilir.

Aşağıdaki tabloda, bu eğitimde oluşturulan yığılmış otoenkoder, karşılaşmanız muhtemel diğer ailelerin yanına yerleştirilmiştir; böylece her birinin eklediği kısıtlamayı karşılaştırmak kolaylaşır.

TensorFlow ile Otomatik Kodlayıcı Nasıl Oluşturulur

Bu eğitimde, bir görüntüyü yeniden oluşturmak için yığılmış bir otomatik kodlayıcının nasıl oluşturulacağını öğreneceksiniz.

60000 adet 32x32 renkli görüntü içeren CIFAR-10 veri setini kullanacaksınız. Otomatik kodlayıcı veri seti, eğitim için 50000 ve test için 10000 görüntü olmak üzere ikiye ayrılmıştır. On adede kadar sınıf bulunmaktadır:

• Uçak
• Otomobil
• Kuş
• Kedi
• Geyik
• Köpek
• Kurbağa
• at
• Gemi
• kamyon

Görselleri şuradan indirmeniz gerekiyor: CIFAR-10 veri seti sayfası Arşivi açın. cifar-10-batches-py klasörü, her biri 10000 görüntü içeren ve rastgele sıralanmış beş veri grubu içerir.

Modelinizi oluşturup eğitmeden önce bazı veri işlemlerini uygulamanız gerekir. Aşağıdaki gibi ilerleyeceksin:

1. Verileri içeri aktarın
2. Verileri siyah beyaz formata dönüştürün
3. Tüm grupları ekle
4. Eğitim veri kümesini oluşturma
5. Bir görüntü görselleştirici oluşturun

Sürüm notu: Bu eğitimdeki kod TensorFlow 1.x'i hedeflemektedir. TensorFlow 2'de tf.contrib modülü artık mevcut değildir ve yer tutucular, oturumlar ve başlatılabilir yineleyici tf.compat.v1 altında yer almaktadır. İçe aktarma işleminden sonra tf.compat.v1.disable_v2_behavior() çağrısını yapmak, kodları değiştirmeden çalıştırmanın en hızlı yoludur.

Görüntü ön işleme

Adım 1) Verileri içe aktarın

Resmi web sitesine göre, verileri aşağıdaki kodla yükleyebilirsiniz. Otomatik kodlayıcı kodu, verileri ve etiketleri içeren bir sözlükte yükleyecektir. Kodun bir fonksiyon olduğunu unutmayın.

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

Adım 2) Verileri siyah beyaz formata dönüştürün

Basit olması açısından verileri gri tonlamaya dönüştüreceksiniz. Yani, renkli görüntü için üç boyuta karşı yalnızca bir boyut vardır. Sinir ağlarının çoğu yalnızca tek boyutlu girişle çalışır.

def grayscale(im):
    return im.reshape(im.shape[0], 3, 32, 32).mean(1).reshape(im.shape[0], -1)

Adım 3) Tüm partileri ekleyin

Artık her iki fonksiyon da oluşturulduğuna ve veri seti yüklendiğine göre, verileri belleğe eklemek için bir döngü yazabilirsiniz. Dikkatlice incelerseniz, verilerin bulunduğu sıkıştırılmış dosyanın adı 1 ile 5 arasında bir sayı olan `data_batch_` şeklindedir. Dosyalar üzerinde döngü yaparak verileri `data`'ya ekleyebilirsiniz.

Bu adım tamamlandığında, renk verilerini gri tonlamalı bir biçime dönüştürürsünüz. Gördüğünüz gibi, verilerin şekli 50000 ve 1024'tür. 32*32 piksel artık 1024'e düzleştirilmiştir.

# 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)

Not: './cifar-10-batches-py/data_batch_' ifadesini dosyanızın gerçek konumuyla değiştirin. Örneğin, bir dosya için Windows yol dosya adı = 'E:\cifar-10-batches-py\data_batch_' + str(i) olabilir

Adım 4) Eğitim veri kümesini oluşturun

Eğitimi daha hızlı ve kolay hale getirmek için, modeli yalnızca at resimleri üzerinde eğiteceksiniz. Atlar, etiket verilerinde 7 numaralı etiketi taşır. CIFAR-10 veri setinin dokümantasyonunda belirtildiği gibi, her sınıf 5000 resim içerir. Aşağıdaki TensorFlow Otomatik Kodlayıcı örnek adımında gösterildiği gibi, 1024 sütunlu 5,000 resim olduğunu doğrulamak için verilerin şeklini yazdırabilirsiniz.

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

Adım 5) Bir görüntü görselleştirici oluşturun

Son olarak, görüntüleri çizmek için bir işlev oluşturursunuz. Yeniden oluşturulan görüntüyü otomatik kodlayıcıdan yazdırmak için bu işleve ihtiyacınız olacaktır.

Görüntüleri yazdırmanın kolay bir yolu, Matplotlib kütüphanesindeki imshow() fonksiyonunu kullanmaktır. Ancak, verilerin şeklini 1024'ten 32*32'ye (yani bir görüntünün formatına) dönüştürmeniz gerektiğini unutmayın.

# 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")   

Fonksiyon 3 argüman alır:

• Görüntü: giriş
• Şekil: liste, görüntünün boyutu
• Cmap: Renk haritasını seçin. Varsayılan olarak gri.

Veri kümesindeki ilk görüntüyü çizmeyi deneyebilirsiniz. At üstünde bir adam görmelisin.

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

Çağrı, aşağıdaki gri tonlamalı küçük resmi döndürür ve 1024 değerden 32×32 görüntüye yeniden şekillendirmenin doğru olduğunu doğrular.

Veri Kümesi Tahmincisini Ayarla

Tamam, veri seti kullanıma hazır olduğuna göre, TensorFlow'u kullanmaya başlayabilirsiniz. Modeli oluşturmadan önce, ağı beslemek için TensorFlow'un Veri Seti tahmin aracını kullanın.

TensorFlow tahmincisi ile bir Veri Kümesi oluşturacaksınız. Zihninizi yenilemek için şunları kullanmanız gerekir:

• from_tensor_slices
• tekrar et
• yığın

Veri kümesini oluşturmak için gereken kodun tamamı şöyledir:

dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)

x'in [None,n_inputs] şeklinde bir yer tutucu olduğunu unutmayın. İlk boyut None olarak ayarlanmıştır çünkü ağa beslenen görüntü sayısı, yalnızca çalışma zamanında belirlenen toplu işlem boyutuna eşittir. Ayrıntılar için lütfen ilgili eğitime bakın. TensorFlow ile doğrusal regresyon.

Bundan sonra yineleyiciyi oluşturmanız gerekir. Bu kod satırı olmadan hiçbir veri işlem hattından geçemez.

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

Artık boru hattı hazır olduğuna göre, ilk görüntünün öncekiyle aynı olup olmadığını kontrol edebilirsiniz (ör. at üzerindeki bir adam).

Toplu işlem boyutunu 1 olarak ayarladınız çünkü veri setine yalnızca tek bir görüntü beslemek istiyorsunuz. Verinin boyutunu print(sess.run(features).shape) ile görebilirsiniz. Bu, (1, 1024) değerine eşittir. 1, her seferinde 1024 değerden oluşan tek bir görüntünün beslendiği anlamına gelir. Toplu işlem boyutu ikiye ayarlanırsa, işlem hattından iki görüntü geçecektir. Toplu işlem boyutunu değiştirmeyin, aksi takdirde hata verecektir çünkü plot_image() fonksiyonuna aynı anda yalnızca bir görüntü gidebilir.

## 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)

İşlem hattı, NumPy matrisinden doğrudan çizilen aynı sürücüyü döndürüyor; bu da yer tutucunun, yineleyicinin ve toplu işlem boyutunun doğru şekilde bağlandığını kanıtlıyor.

Ağı oluşturun

Ağı kurmanın zamanı geldi. Yığılmış bir otomatik kodlayıcıyı, yani birden fazla gizli katmana sahip bir ağı eğiteceksiniz.

Ağınızda, görüntünün şekli olan 32×32 boyutunda, yani 1024 noktadan oluşan tek bir giriş katmanı olacaktır.

Kodlayıcı blok, 300 nöronlu bir üst gizli katmana ve 150 nöronlu bir merkezi katmana sahip olacaktır. Kod çözücü blok, kodlayıcıya simetriktir. Ağı aşağıdaki diyagramda görselleştirebilirsiniz. Gizli ve merkezi katmanların değerlerini değiştirebileceğinizi unutmayın.

Otomatik kodlayıcı oluşturmak diğer derin öğrenme modellerine çok benzer.

Modeli şu adımları izleyerek oluşturacaksınız:

1. Parametreleri tanımlayın
2. Katmanları tanımlayın
3. Mimariyi tanımlayın
4. Optimizasyonu tanımlayın
5. Modeli çalıştırın
6. Modeli değerlendirin

Önceki bölümde, modeli beslemek için bir veri hattı oluşturmayı öğrendiniz, bu nedenle veri setini tekrar oluşturmanıza gerek yok. Dört katmanlı bir otoenkoder oluşturacaksınız. Xavier başlatma yöntemini kullanacaksınız. Bu, hem giriş hem de çıkışın varyansına göre başlangıç ​​ağırlıklarını ayarlama tekniğidir. Son olarak, ELU aktivasyon fonksiyonunu kullanacaksınız. Kayıp fonksiyonunu bir L2 düzenleyici ile düzenleyeceksiniz.

Adım 1) Parametreleri tanımlayın

İlk adım, her katmandaki nöron sayısını, öğrenme hızını ve düzenleyicinin hiperparametresini tanımlamayı gerektirir.

Bundan önce, kısmi fonksiyonu içe aktarıyorsunuz. Bu, yoğun katmanların parametrelerini tanımlamak için daha iyi bir yöntemdir. Aşağıdaki kod, otoenkoder mimarisinin değerlerini tanımlar. Daha önce belirtildiği gibi, kodlayıcının iki katmanı vardır; birinci katmanda 300, ikinci katmanda ise 150 nöron bulunur. Değerleri n_hidden_1 ve n_hidden_2'de saklanır.

Öğrenme oranını ve L2 hiperparametresini tanımlamanız gerekiyor. Değerler learning_rate ve l2_reg değişkenlerinde saklanır.

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

Xavier başlatma tekniği, estimator contrib'deki xavier_initializer nesnesiyle çağrılır. Aynı estimator'da, l2_regularizer ile düzenleyiciyi ekleyebilirsiniz.

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

Sürüm notu: `tf.contrib` TensorFlow 2'de kaldırıldı. Doğrudan yerine geçenler `xavier_initializer()` için `tf.keras.initializers.GlorotUniform()` ve `l2_regularizer()` için `tf.keras.regularizers.l2()`'dir.

Adım 2) Katmanları tanımlayın

Yoğun katmanların tüm parametreleri ayarlanmıştır; partial nesnesini kullanarak her şeyi dense_layer değişkenine paketleyebilirsiniz. dense_layer daha sonra her çağrıda ELU aktivasyonunu, Xavier başlatmasını ve L2 düzenlemesini kullanır.

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

Adım 3) Mimariyi tanımlayın

Mimari diyagramına bakarsanız, ağın bir çıkış katmanıyla birlikte üç katmandan oluştuğunu görürsünüz. Aşağıdaki kodda, uygun katmanları birbirine bağlıyorsunuz. Örneğin, ilk katman, giriş matris özelliklerini ve 300 ağırlığı içeren matrisi nokta çarpımıyla hesaplar. Nokta çarpımı hesaplandıktan sonra, çıktı ELU aktivasyon fonksiyonuna gider. Çıktı, bir sonraki katmanın girdisi olur, bu yüzden hidden_2'yi ve benzerlerini hesaplamak için bunu kullanırsınız. Matris çarpımı her katman için aynıdır çünkü aynı aktivasyon fonksiyonunu kullanırsınız. Son katman olan outputs'un bir aktivasyon fonksiyonu uygulamadığını unutmayın. Bu mantıklıdır çünkü bu yeniden yapılandırılmış giriştir.

## 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)

Adım 4) Optimizasyonu tanımlayın

Son adım, optimizasyon algoritmasını oluşturmaktır. Kayıp fonksiyonu olarak Ortalama Kare Hatası (MSE) kullanıyorsunuz. Doğrusal regresyon hakkındaki eğitime bakarsanız, MSE'nin tahmin edilen çıktı ile gerçek etiket arasındaki farkla hesaplandığını biliyorsunuzdur. Burada etiket, modelin girdiyi yeniden oluşturmaya çalıştığı için özelliktir. Bu nedenle, tahmin edilen çıktı ile girdi arasındaki kare farklarının toplamının ortalamasını istiyorsunuz. TensorFlow ile kayıp fonksiyonunu şu şekilde kodlayabilirsiniz:

loss = tf.reduce_mean(tf.square(outputs - features))

Ardından, kayıp fonksiyonunu optimize etmeniz gerekiyor. Gradyanları hesaplamak için Adam optimizasyon algoritmasını kullanıyorsunuz. Amaç fonksiyonu, kaybı en aza indirmektir.

## Optimize
loss = tf.reduce_mean(tf.square(outputs - features))
optimizer = tf.train.AdamOptimizer(learning_rate)
train  = optimizer.minimize(loss)

Modeli eğitmeden önce bir ayar daha. 150'lik bir toplu iş boyutu kullanmak, yani ardışık düzeni her yinelemede 150 görüntüyle beslemek istiyorsunuz. Yineleme sayısını manuel olarak hesaplamanız gerekir. Bunu yapmak önemsizdir:

Her seferinde 150 görüntü işlemek istiyorsanız ve veri setinde 5000 görüntü olduğunu biliyorsanız, yineleme sayısı 5000'in 150'ye bölünmesiyle bulunur. Python Aşağıdaki kodları çalıştırarak çıktının 33 olduğundan emin olabilirsiniz:

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

Adım 5) Modeli çalıştırın

Son olarak, modeli eğitin. Modeli 100 epoch ile eğiteceksiniz. Yani, model ağırlıkları optimize ederken görüntüleri 100 kez görecek.

TensorFlow'da model eğitmek için gereken kodlara zaten aşinasınız. Aradaki küçük fark, eğitimi çalıştırmadan önce verileri bir boru hattına (pipe) aktarmaktır. Bu şekilde model daha hızlı eğitilir.

Modelin bir şeyler öğrenip öğrenmediğini (yani kaybın azalıp azalmadığını) görmek için on dönem sonrasındaki kaybı yazdırmakla ilgileniyorsunuz. Eğitim, makine donanımınıza bağlı olarak 2 ila 5 dakika sürer.

## 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

Adım 6) Modeli değerlendirin

Modelinizi eğittiğinize göre, artık onu değerlendirme zamanı geldi. /cifar-10-batches-py/ dosyasından test setini içe aktarmanız gerekiyor.

test_data = unpickle('./cifar-10-batches-py/test_batch')
test_x = grayscale(test_data['data'])
#test_labels = np.array(test_data['labels'])

Not: bir için Windows makinede kod şu şekilde olur: test_data = unpicle(r”E:\cifar-10-batches-py\test_batch”)

13 numaralı görseli, yani at resmini yazdırmayı deneyebilirsiniz.

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

Grafik, test grubunun doğru şekilde yüklendiğini ve 13 numaralı görüntünün modelin eğitildiği sınıfa ait olduğunu doğrulamaktadır.

Modeli değerlendirmek için, bu görüntünün piksel değerini kullanacak ve kodlayıcının görüntüyü 1024 piksele küçülttükten sonra aynı görüntüyü yeniden oluşturup oluşturamayacağını göreceksiniz. Unutmayın, modeli farklı resimler üzerinde değerlendirmek için bir fonksiyon tanımlayacaksınız. Modelin yalnızca atlar üzerinde daha iyi çalışması bekleniyor.

İşlev iki bağımsız değişken alır:

• df: Test verilerini içe aktarın
• resim_numarası: hangi resmin içe aktarılacağını belirtir.

İşlev üç bölüme ayrılmıştır:

1. Görüntüyü doğru boyuta, yani 1, 1024'e yeniden şekillendirin
2. Modeli görünmeyen görüntüyle besleyin, görüntüyü kodlayın/kodunu çözün
3. Gerçek ve yeniden oluşturulmuş görüntüyü yazdırın

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()

Değerlendirme fonksiyonu tanımlandığına göre, yeniden oluşturulan on üçüncü görüntüye göz atabilirsiniz.

reconstruct_image(df =test_x, image_number = 13)

INFO:tensorflow:Restoring parameters from ./model.ckpt
Model restored.
(1, 1024)

Şekilde, orijinal test görüntüsü solda, otoenkoder çıktısı ise sağda yer almaktadır; bu sayede 1024'ten 150'ye sıkıştırma sonrasında ince detay kaybı kolayca değerlendirilebilir.

SSS