Изображение покрытия Джастин Линкольн, на Flickr
Узнайте о AutoEncoders в этой статье Патрика Д. Смита, наука о данных приводят к Excella в Арлингтоне, штат Вирджиния, где он основал науку и учебную команду машины.
AutoEncoders.
AutoEncoders и их рамки энкодера/декодера являются вдохновением за генеративными моделями. Они являются самоуправляемой техникой для изучения представления, где наша сеть учится о его входе, чтобы она мог создавать новые данные как в качестве ввода. В этом разделе мы узнаем о своей архитектуре и используем в качестве введения в генеративные сети, которые они вдохновляют.
Сетевая архитектура
AutoEncoders работают, принимая вход и генерацию меньших векторных представлений на более поздний реконструируя свой вклад Отказ Они делают это с помощью энкодера, чтобы наложить информационное узкое место при входящих данных, а затем использование декодера для воссоздания входных данных на основе этого представления. Это основано на идее того, что существуют структуры в данных (то есть корреляции и т. Д.), которые существуют, но это не очевидно. AutoEncoders – это средство автоматического изучения этих отношений без явного этого.
Конструктивно, автозаветы состоят из Входной слой , а Скрытый слой и Выходной слой , как продемонстрировано на следующей диаграмме:
Энкодер учится сохранять как можно больше соответствующей информации в ограниченном кодировании, и интеллектуально отбрасывает неактуальные части. Это заставляет сеть поддерживать только данные, необходимые для воссоздания ввода; Мы делаем это, используя потери реконструкции с помощью термина регуляризации, чтобы предотвратить переопределение. Поскольку задача AutoEncoders состоит в том, чтобы воссоздать их вывод, они используют тип функции потери, известной как Потеря реконструкции Отказ Эти функции потери обычно Средняя ошибка в квадрате или Крест энтропия Функции потери, которые наказывают сеть для создания вывода, заметно отличаются от ввода.
Информационное узкое место является ключом, чтобы помочь нам минимизировать эту потерю реконструкции; Если не было узкого места, информация может течь слишком быстро с входа к выходу, а сеть, вероятно, переполнена от изучения общих представлений. Идеальный AutoEncoder – это оба из следующих:
- Достаточно чувствительный к его входным данным, что это может точно восстановить его
- Достаточно нечувствителен к его входным данным, что модель не страдает от перенапряжения этих данных
Процесс перехода от высокого входного измерения до низкого входного измерения в процессе энкодера представляет собой метод уменьшения размерности, который практически идентичен Главный компонентный анализ (PCA) Отказ Разница заключается в том, что PCA ограничена Линейные многообразии , в то время как автозаветы могут обрабатывать нет -нолинные многообразии. Коллектор представляет собой непрерывную, не пересекающуюся поверхность. Ради функций нейронных сетей, обучения и потери, обязательно всегда думайте о многообразиях как топологическую карту.
Строительство автозагрузчика
Если вы думаете, что задача реконструкции вывода не кажется, что полезная, вы не одиноки. Для чего именно мы используем эти сети? AutoEncoders поможет извлечь функции, когда нет известных помеченных функций под рукой. Чтобы проиллюстрировать, как это работает, давайте пройдемся через пример с помощью Tensorflow. Мы собираемся реконструировать набор данных Mnist здесь, и, позже, мы будем сравнивать производительность стандарта AutoEncoder против вариационного автозавета по отношению к той же задаче.
Давайте начнем с нашими импортами и данными. Mnist содержится в результате Tensorflow, поэтому мы можем легко импортировать его:
import tensorflow as tf
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)
Для простоты мы можем построить автокодер с TF.Layers библиотека. Мы захотим нашу архитектуру AutoEncoder, чтобы следить за шаблоном сверточного/декорирования, где входной слой декодера соответствует размеру ввода и последующего слоя, сквошащего данные в меньшее и меньшее представление. Декодер будет одной и той же архитектурой, отменившейся, начиная с небольшого представления и работает больше.
Все вместе мы хотим, чтобы это выглядеть что-то вроде следующего:
Давайте начнем с энкодера; Сначала мы определим инициализатор для факторов веса и смещения, а затем определите кодировщик как функцию, которая принимает и вводится, x. Затем мы будем использовать tf.layers.dense Функция для создания стандартных, полностью подключенных слоев нейронных сетей. Кодировщик будет иметь три слоя, причем первый размер слоя соответствует входным размерам входных данных ( 784 ), с последующими слоями постоянно меньше:
initializer = tf.contrib.layers.xavier_initializer()
def encoder(x):
input_layer = tf.layers.dense(inputs=x, units=784,
activation=tf.nn.relu,
kernel_initializer=initializer,
bias_initializer=initializer)
z_prime = tf.layers.dense(inputs=input_layer, units=256,
activation=tf.nn.relu,
kernel_initializer=initializer,
bias_initializer=initializer)
z = tf.layers.dense(inputs=z_prime, units=128,
activation=tf.nn.relu,
kernel_initializer=initializer,
bias_initializer=initializer)
return z
Далее давайте построим наш декодер; Он будет использовать тот же тип и инициализатор слоя, что и инициализатор, как и кодер, только теперь мы инвертируем слои, чтобы первый слой декодера – самый маленький, а последний является крупнейшим.
def decoder(x):
x_prime_one = tf.layers.dense(inputs=x, units=128,
activation=tf.nn.relu,
kernel_initializer=initializer,
bias_initializer=initializer)
x_prime_two = tf.layers.dense(inputs=x_prime_one, units=256,
activation=tf.nn.relu,
kernel_initializer=initializer,
bias_initializer=initializer)
output_layer = tf.layers.dense(inputs=x_prime_two, units=784,
activation=tf.nn.relu,
kernel_initializer=initializer,
bias_initializer=initializer)
return output_layer
Прежде чем мы добраться до тренировок, давайте определим некоторые гипер-параметры, которые будут необходимы во время тренировочного цикла. Мы установим размер нашего ввода, скорость обучения, количество тренировок, размер партии для цикла обучения, а также как часто мы хотим отображать информацию о нашем прогрессе.
input_dim = 784 learning_rate = 0.001 num_steps = 1000 batch_size = 256 display = 1
Затем мы определим заполнителю для наших входных данных, чтобы мы могли компилировать модель:
x = tf.placeholder("float", [None, input_dim])
И впоследствии мы компилируем модель и оптимизатор:
# Construct the full autoencoder z = encoder(x) ## x_prime represents our predicted distribution x_prime = decoder(z) # Define the loss function and the optimizer loss = tf.reduce_mean(tf.pow(x - x_prime, 2)) optimizer = tf.train.RMSPropOptimizer(learning_rate).minimize(loss)
Наконец, мы будем кодировать тренировочный цикл. Запустите сеанс Tensorflow и итерации по эпохам/партиям, вычисляем потери и точность в каждой точке:
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
# # Training Loop
for i in range(1, num_steps + 1):
# # Feed Batches of MNIST Data
(batch_x, _) = mnist.train.next_batch(batch_size)
# # Run the Optimization Process
(_, l) = sess.run([optimizer, loss], feed_dict={x: batch_x})
# # Display the loss at every 1000 out of 30,000 steps
if i % display == 0 or i == 1:
print 'Step %i: Loss: %f' % (i, l)
Для этого конкретного примера добавьте еще нечто большее в этот процесс; Способ построить реконструированные изображения рядом с их оригинальными версиями. Имейте в виду, что этот код все еще содержится в тренировке, недалеко от петли обучения:
n = 4
canvas_orig = np.empty((28 * n, 28 * n))
canvas_recon = np.empty((28 * n, 28 * n))
for i in range(n):
batch_x, _ = mnist.test.next_batch(n)
# Encode and decode each individual written digit
g = sess.run(decoder, feed_dict={x: batch_x})
# Display original images
for j in range(n):
# Draw the original digits
canvas_orig[i * 28:(i + 1) * 28, j * 28:(j + 1) * 28] = batch_x[j].reshape([28, 28])
# Display reconstructed images
for j in range(n):
# Draw the reconstructed digits
canvas_recon[i * 28:(i + 1) * 28, j * 28:(j + 1) * 28] = g[j].reshape([28, 28])
# Plot the original image vs the reconstructed images.
print("Original Images")
plt.figure(figsize=(n, n))
plt.imshow(canvas_orig, origin="upper", cmap="gray")
plt.show()
print("Reconstructed Images")
plt.figure(figsize=(n, n))
plt.imshow(canvas_recon, origin="upper", cmap="gray")
plt.show()
После тренировки вы должны в конечном итоге в конечном итоге по направлению следующих действий с фактическими цифрами слева и реконструированные цифры справа:
Так что мы здесь сделали? Обучая AutoEncoder на неразмерных цифрах, мы сделали следующее:
- Узнал скрытые функции набора данных без явных меток
- Успешно изучил распределение данных и восстановить изображение с нуля, от этого распределения
Теперь, скажем, мы хотели взять это дальше и генерировать или классифицировать новые цифры, которые мы еще не видели. Для этого мы могли бы удалить декодер и прикрепить классификатор или генераторную сеть:
Таким образом, кодировщик становится средством инициализации контролируемой модели обучения.
Если вы нашли эту статью интересную; Вы можете исследовать Руководство искусственного интеллекта для начинающих Чтобы понять основы искусственного интеллекта и создавать свои собственные интеллектуальные системы с легкостью. Руководство искусственного интеллекта для начинающих научит вас, какой искусственный интеллект и как разработать и строить умные приложения.
Оригинал: “https://dev.to/kayis/building-an-autoencoder-for-generative-models-3e1i”