14) Автоэнкодер Deep Learning

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

Шаг 3) Определите архитектуру

Если вы посмотрите на картину архитектуры, вы заметите, что сеть складывает три слоя с выходным слоем. В приведенном ниже коде вы подключаете соответствующие слои. Например, первый слой вычисляет точечное произведение между входными матричными элементами и матрицами, содержащими 300 весов. После вычисления точечного произведения выход переходит к функции активации Elu. Выходные данные становятся входными данными следующего слоя, поэтому вы используете его для вычисления hidden_2 и так далее. Умножение матриц одинаково для каждого слоя, потому что вы используете одну и ту же функцию активации. Обратите внимание, что последний уровень, выходы, не применяет функцию активации. Это имеет смысл, потому что это восстановленный вход

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

Шаг 4) Определите оптимизацию

Последний шаг заключается в создании оптимизатора. Вы используете среднеквадратическую ошибку в качестве функции потерь. Если вы вспомните учебник по линейной регрессии, вы знаете, что MSE рассчитывается с разницей между прогнозируемым выходным значением и реальной меткой. Здесь метка — это особенность, потому что модель пытается восстановить входные данные. Следовательно, вы хотите получить среднее значение суммы разности квадрата между прогнозируемым выходным значением и входным значением. С TensorFlow вы можете кодировать функцию потерь следующим образом:

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

Затем вам нужно оптимизировать функцию потерь. Вы используете оптимизатор Adam для вычисления градиентов. Задача состоит в том, чтобы минимизировать потери.

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

Еще одна настройка перед тренировкой модели. Вы хотите использовать размер пакета 150, то есть загружать в конвейер 150 изображений в каждой итерации. Вам нужно вычислить количество итераций вручную. Это тривиально сделать:

Если вы хотите передать 150 изображений каждый раз и знаете, что в наборе данных 5000 изображений, число итераций равно. В python вы можете запустить следующие коды и убедиться, что результат равен 33:

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

Шаг 5) Запустите модель

И последнее, но не менее важное: тренируйте модель. Вы тренируете модель со 100 эпохами. То есть модель будет в 100 раз видеть изображения до оптимизированных весов.

Вы уже знакомы с кодами для обучения модели в Tensorflow. Небольшая разница заключается в передаче данных перед запуском тренировки. Таким образом, модель тренируется быстрее.

Вы заинтересованы в том, чтобы напечатать потерю после десяти эпох, чтобы увидеть, изучает ли модель что-то (т.е. потеря уменьшается). Обучение занимает от 2 до 5 минут, в зависимости от аппаратного обеспечения вашего компьютера.

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

Шаг 6) Оцените модель

Теперь, когда вы обучили свою модель, пришло время ее оценить. Вам необходимо импортировать тестовый файл из файла / 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'])

ПРИМЕЧАНИЕ. Для компьютера с Windows код становится test_data = unpickle (r «E: \ cifar-10-batches-py \ test_batch»)

Вы можете попробовать распечатать изображения 13, который является лошадью

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

To evaluate the model, you will use the pixel value of this image and see if the encoder can reconstruct the same image after shrinking 1024 pixels. Note that, you define a function to evaluate the model on different pictures. The model should work better only on horses.

The function takes two arguments:

• df: Import the test data
• image_number: indicate what image to import

The function is divided into three parts:

1. Reshape the image to the correct dimension i.e 1, 1024
2. Feed the model with the unseen image, encode/decode the image
3. Print the real and reconstructed image

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

Теперь, когда функция оценки определена, вы можете взглянуть на восстановленное изображение с номером тринадцать

reconstruct_image(df =test_x, image_number = 13)		

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

Резюме

Основная цель автоэнкодера состоит в том, чтобы сжать входные данные, а затем распаковать их в выходные данные, которые очень похожи на исходные данные.

Архитектура автоэнкодера симметрична с центральным слоем, называемым центральным слоем.

Вы можете создать автоэнкодер используя:

• Частично: создать плотные слои с типичной настройкой:

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

• dens_layer (): сделать умножение матрицы

Вы можете определить функцию потерь и оптимизацию с помощью:

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

Последний сеанс для тренировки модели.