Аннотация: в этой статье будут представлены основные знания об автокодировщике без учителя, а затем будет использован регистр рукописных цифр MNIST для проведения сравнительных экспериментов и кластерного анализа.
Эта статья опубликована в сообществе HUAWEI CLOUD.«[Искусственный интеллект Python] Пятнадцать. Принцип самообучающегося автоэнкодера без присмотра и подробное объяснение случая визуализации кластера», Автор: истмаунт.
1. Что такое автоэнкодер
Прежде всего, что такое автоэнкодер? Автоэнкодер — это форма нейронной сети, обратите внимание, что это алгоритм обучения без учителя. Например, сейчас есть картинка, ее нужно закодировать, а затем восстановить картинку, как показано на следующем рисунке:
После того, как изображение сжато, а затем распаковано, исходное качество изображения снижается при сжатии, а при распаковке исходное изображение восстанавливается с небольшим объемом информации, но включаются все ключевые файлы. Зачем ты это делаешь? Иногда нейронной сети необходимо вводить большое количество информации, например, при анализе изображений высокой четкости количество вводимых данных может достигать десятков миллионов, нейронной сети очень сложно учиться на десятках миллионов. , необходимо сжать и извлечь из исходного изображения репрезентативные изображения, информацию или признаки, сжать объем входной информации, а затем поместить сжатую информацию в нейронную сеть для обучения. Это облегчает обучение, поэтому на этом этапе в игру вступает автокодирование.
Как показано на рисунке ниже, белый X исходных данных сжимается и распаковывается в черный X, а затем ошибка получается путем сравнения двух X, а затем выполняется обратная передача для постепенного повышения точности самоанализа. -кодирование.
Для обученного автоэнкодера средняя часть представляет собой суть исходных данных.От начала до конца мы используем только входную переменную X и не используем метку, соответствующую входной переменной, поэтому автоэнкодер является неконтролируемым обучением. алгоритм.
Но когда на самом деле используется автокодирование, обычно только его первая половина, называемая кодировщиком, может быть использована для получения сути исходных данных. Тогда для обучения нужно создать лишь небольшую нейронную сеть, что не только снижает нагрузку на нейронную сеть, но и позволяет добиться хороших результатов.
На следующем рисунке представлены данные, отсортированные с помощью самокодирования, которые могут суммировать характеристики каждого типа данных.Если эти данные разместить на двумерной картинке, каждый тип данных можно хорошо отличить от исходных данных по своей сущности. . Автокодирование может извлекать функции данных, аналогичные PCA (анализ основных компонентов), а также может использоваться для уменьшения размерности, а его эффект уменьшения размерности даже превосходит PCA.
2. Автоэнкодер анализирует данные MNIST
Алгоритм Autoencoder относится к неконтролируемому обучению, Это процесс сжатия признаков данных, а затем распаковки сжатых признаков, что похоже на сжатие с уменьшением размерности PCA.
Код этой статьи состоит из двух частей:
-
Часть 1: Используя набор данных MNIST, с помощью сжатия и распаковки признаков сравните распакованное изображение и изображение до сжатия, чтобы увидеть, согласуются ли они Желаемый эффект эксперимента аналогичен эффекту до сжатия изображения.
-
Вторая часть: вывести результат кодировщика, сжать его в два элемента и отобразить визуально. На отображаемых изображениях один и тот же цвет представляет изображения одного и того же типа, например, тип 1 (номер 1), тип 2 (номер 2) и т. д., и, наконец, достигается неконтролируемая кластеризация.
Разница между обучением с учителем и обучением без учителя (1) Метод обучения с учителем должен иметь обучающий набор и тестовую выборку. Найдите шаблоны в обучающем наборе и используйте этот шаблон для тестовых образцов. иНеконтролируемое обучение не имеет обучающего набора, существует только один набор данных, и шаблон находится в этом наборе данных. (2) Метод обучения с учителем заключается в распознавании вещей, а результатом распознавания является добавление меток к распознаваемым данным. Следовательно, обучающая выборка должна состоять из размеченных выборок. иНеконтролируемые методы обучения имеют только набор данных для анализа и не имеют заранее меток.Если обнаруживается, что набор данных демонстрирует какую-либо агрегацию, его можно классифицировать в соответствии с естественной агрегацией, но не с целью какой-либо предварительной классификации.
Приступаем к кодированию!
Первый шаг — открыть Anaconda, затем выбрать созданную среду «tensorflow» и запустить Spyder.
Второй шаг — импорт пакета расширения.
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow.examples.tutorials.mnist import input_data
Третий шаг — загрузить набор данных.
Поскольку набор данных MNIST является образцом данных TensorFlow, нам нужна только следующая строка кода для чтения набора данных. Если набор данных не существует, он будет загружен онлайн, если набор данных уже загружен, он будет вызван напрямую.
# 下载手写数字图像数据集
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
Четвертый шаг – определение параметров.
Изображение MNIST имеет размер 28*28 пикселей, а его входной признак n_input равен 784. Этот признак непрерывно сжимается, сначала сжимается до 256, а затем сжимается до 128 через скрытый слой. Затем увеличьте 128, распакуйте 256 и распакуйте 784. Наконец, стоимость распакованного 784 и исходных функций 784 сравнивается, и точность автоэнкодера повышается в зависимости от стоимости.
#-------------------------------------初始化设置-------------------------------------------
# 基础参数设置
learning_rate = 0.01 #学习效率
training_epochs = 5 #5组训练
batch_size = 256 #batch大小
display_step = 1
examples_to_show = 10 #显示10个样本
# 神经网络输入设置
n_input = 784 #MNIST输入数据集(28*28)
# 隐藏层设置
n_hidden_1 = 256 #第一层特征数量
n_hidden_2 = 128 #第二层特征数量
weights = {
'encoder_h1': tf.Variable(tf.random_normal([n_input, n_hidden_1])),
'encoder_h2': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2])),
'decoder_h1': tf.Variable(tf.random_normal([n_hidden_2, n_hidden_1])),
'decoder_h2': tf.Variable(tf.random_normal([n_hidden_1, n_input]))
}
biases = {
'encoder_b1': tf.Variable(tf.random_normal([n_hidden_1])),
'encoder_b2': tf.Variable(tf.random_normal([n_hidden_2])),
'decoder_b1': tf.Variable(tf.random_normal([n_hidden_1])),
'decoder_b2': tf.Variable(tf.random_normal([n_input]))
}
Пятым шагом является написание основного кода, то есть определение функций кодировщика и декодера для реализации операций сжатия и распаковки.
Кодировщик представляет собой двухуровневый Layer, который сжимается до 256 элементов и 128 элементов соответственно. Декодер также включает в себя два слоя, которые соответственно распаковываются на 256 и 784 элемента.
#---------------------------------压缩和解压函数定义---------------------------------------
# Building the encoder
def encoder(x):
# 第一层Layer压缩成256个元素 压缩函数为sigmoid(压缩值为0-1范围内)
layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, weights['encoder_h1']),
biases['encoder_b1']))
# 第二层Layer压缩成128个元素
layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, weights['encoder_h2']),
biases['encoder_b2']))
return layer_2
# Building the decoder
def decoder(x):
# 解压隐藏层调用sigmoid激活函数
layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, weights['decoder_h1']),
biases['decoder_b1']))
# 第二层Layer解压成784个元素
layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, weights['decoder_h2']),
biases['decoder_b2']))
return layer_2
#-----------------------------------压缩和解压操作---------------------------------------
# 压缩：784 => 128
encoder_op = encoder(X)
# 解压：784 => 128
decoder_op = decoder(encoder_op)
Следует отметить, что в наборе данных MNIST максимальное значение данных xs равно 1, а минимальное значение равно 0, а не максимальное значение изображения 255, поскольку здесь оно было нормализовано сигмовидной функцией.
batch_xs, batch_ys = mnist.train.next_batch(batch_size) # max(x) = 1, min(x) = 0
Шестой шаг заключается в определении метода расчета погрешности.
Среди них y_pred представляет прогнозируемый результат, вызывает функцию распаковки decoder_op, а decoder_op продолжает вызывать функции распаковки декодера и сжатия кодировщика для обработки набора данных изображения X.
#--------------------------------对比预测和真实结果---------------------------------------
# 预测
y_pred = decoder_op
# 输入数据的类标(Labels)
y_true = X
# 定义loss误差计算 最小化平方差
cost = tf.reduce_mean(tf.pow(y_true - y_pred, 2))
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)
Седьмой шаг — определить код обучения и визуализации, который является основным кодом, который выполняет нейронная сеть.
Сначала выполните операцию инициализации init, а затем проведите обучение в 5 группах экспериментов. реальное изображение и предсказанное изображение.
#-------------------------------------训练及可视化-------------------------------------
# 初始化
init = tf.initialize_all_variables()
# 训练集可视化操作
with tf.Session() as sess:
sess.run(init)
total_batch = int(mnist.train.num_examples/batch_size)
# 训练数据 training_epochs为5组实验
for epoch in range(training_epochs):
# Loop over all batches
for i in range(total_batch):
batch_xs, batch_ys = mnist.train.next_batch(batch_size) # max(x)=1 min(x)=0
# 运行初始化和误差计算操作
_, c = sess.run([optimizer, cost], feed_dict={X: batch_xs})
# 每个epoch显示误差值
if epoch % display_step == 0:
print("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(c))
print("Optimization Finished!")
Восьмой шаг, вызовите библиотеку matplotlib, чтобы нарисовать картинку и визуально сравнить исходное изображение и предсказанное изображение.
# 压缩和解压测试集
encode_decode = sess.run(
y_pred, feed_dict={X: mnist.test.images[:examples_to_show]})
# 比较原始图像和预测图像数据
f, a = plt.subplots(2, 10, figsize=(10, 2))
# 显示结果 上面10个样本是真实数据 下面10个样本是预测结果
for i in range(examples_to_show):
a[0][i].imshow(np.reshape(mnist.test.images[i], (28, 28)))
a[1][i].imshow(np.reshape(encode_decode[i], (28, 28)))
plt.show()
Девятый шаг, запустить код и проанализировать результаты.
Результат показан на рисунке ниже, и ошибка уменьшается, что указывает на то, что наша неконтролируемая нейронная сеть изучила знания.
Extracting MNIST_data\train-images-idx3-ubyte.gz
Extracting MNIST_data\train-labels-idx1-ubyte.gz
Extracting MNIST_data\t10k-images-idx3-ubyte.gz
Extracting MNIST_data\t10k-labels-idx1-ubyte.gz
Epoch: 0001 cost= 0.097888887
Epoch: 0002 cost= 0.087600455
Epoch: 0003 cost= 0.083100438
Epoch: 0004 cost= 0.078879632
Epoch: 0005 cost= 0.069106154
Optimization Finished!
После 5 пакетов обучения результаты отображения показаны на следующем рисунке, вверху — реальное исходное изображение, а внизу — данные сжатого и распакованного изображения. Обратите внимание, что на самом деле 5 групп обучения — это очень мало, и в обычных условиях требуется больше тренировок.
Полный код:
# -*- coding: utf-8 -*-
"""
Created on Wed Jan 15 15:35:47 2020
@author: xiuzhang Eastmount CSDN
"""
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow.examples.tutorials.mnist import input_data
#-----------------------------------初始化设置---------------------------------------
# 基础参数设置
learning_rate = 0.01 #学习效率
training_epochs = 5 #5组训练
batch_size = 256 #batch大小
display_step = 1
examples_to_show = 10 #显示10个样本
# 神经网络输入设置
n_input = 784 #MNIST输入数据集(28*28)
# 输入变量(only pictures)
X = tf.placeholder("float", [None, n_input])
# 隐藏层设置
n_hidden_1 = 256 #第一层特征数量
n_hidden_2 = 128 #第二层特征数量
weights = {
'encoder_h1': tf.Variable(tf.random_normal([n_input, n_hidden_1])),
'encoder_h2': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2])),
'decoder_h1': tf.Variable(tf.random_normal([n_hidden_2, n_hidden_1])),
'decoder_h2': tf.Variable(tf.random_normal([n_hidden_1, n_input]))
}
biases = {
'encoder_b1': tf.Variable(tf.random_normal([n_hidden_1])),
'encoder_b2': tf.Variable(tf.random_normal([n_hidden_2])),
'decoder_b1': tf.Variable(tf.random_normal([n_hidden_1])),
'decoder_b2': tf.Variable(tf.random_normal([n_input]))
}
# 导入MNIST数据
mnist = input_data.read_data_sets("MNIST_data", one_hot=False)
#---------------------------------压缩和解压函数定义---------------------------------------
# Building the encoder
def encoder(x):
# 第一层Layer压缩成256个元素 压缩函数为sigmoid(压缩值为0-1范围内)
layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, weights['encoder_h1']),
biases['encoder_b1']))
# 第二层Layer压缩成128个元素
layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, weights['encoder_h2']),
biases['encoder_b2']))
return layer_2
# Building the decoder
def decoder(x):
# 解压隐藏层调用sigmoid激活函数(范围内为0-1区间)
layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, weights['decoder_h1']),
biases['decoder_b1']))
# 第二层Layer解压成784个元素
layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, weights['decoder_h2']),
biases['decoder_b2']))
return layer_2
#-----------------------------------压缩和解压操作---------------------------------------
# Construct model
# 压缩：784 => 128
encoder_op = encoder(X)
# 解压：784 => 128
decoder_op = decoder(encoder_op)
#--------------------------------对比预测和真实结果---------------------------------------
# 预测
y_pred = decoder_op
# 输入数据的类标(Labels)
y_true = X
# 定义loss误差计算 最小化平方差
cost = tf.reduce_mean(tf.pow(y_true - y_pred, 2))
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)
#-------------------------------------训练及可视化-------------------------------------
# 初始化
init = tf.initialize_all_variables()
# 训练集可视化操作
with tf.Session() as sess:
sess.run(init)
total_batch = int(mnist.train.num_examples/batch_size)
# 训练数据 training_epochs为5组实验
for epoch in range(training_epochs):
# Loop over all batches
for i in range(total_batch):
batch_xs, batch_ys = mnist.train.next_batch(batch_size) # max(x)=1 min(x)=0
# 运行初始化和误差计算操作
_, c = sess.run([optimizer, cost], feed_dict={X: batch_xs})
# 每个epoch显示误差值
if epoch % display_step == 0:
print("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(c))
print("Optimization Finished!")
# 压缩和解压测试集
encode_decode = sess.run(
y_pred, feed_dict={X: mnist.test.images[:examples_to_show]})
# 比较原始图像和预测图像数据
f, a = plt.subplots(2, 10, figsize=(10, 2))
# 显示结果 上面10个样本是真实数据 下面10个样本是预测结果
for i in range(examples_to_show):
a[0][i].imshow(np.reshape(mnist.test.images[i], (28, 28)))
a[1][i].imshow(np.reshape(encode_decode[i], (28, 28)))
plt.show()
3. Кластерный анализ признаков
Завершена первая часть эксперимента, в которой сравниваются 10 исходных и предсказанных изображений. Затем мы разделяем эксперименты второй части, создавая кластерный граф.
Первым шагом является изменение параметров.
Модификация выглядит следующим образом: эффективность обучения установлена на 0,001, а тренировочная партия установлена на 20.
# 基础参数设置
learning_rate = 0.001 #学习效率
training_epochs = 20 #20组训练
batch_size = 256 #batch大小
display_step = 1
Второй шаг — увеличить количество слоев кодировщика и декодера и изменить параметры.
Мы устанавливаем скрытый слой на 4 слоя, что будет работать лучше. Сначала сжатие с 784 до 128, затем сжатие до 64, 10 и, наконец, сжатие только до 2 элементов (признаков) для отображения на 2D-изображении. В то же время обновите значение веса и значение смещения, и кодировщик, и декодер установлены на 4 уровня.
# 隐藏层设置
n_hidden_1 = 128 #第一层特征数量
n_hidden_2 = 64 #第二层特征数量
n_hidden_3 = 10 #第三层特征数量
n_hidden_4 = 2 #第四层特征数量
weights = {
'encoder_h1': tf.Variable(tf.random_normal([n_input, n_hidden_1])),
'encoder_h2': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2])),
'encoder_h3': tf.Variable(tf.random_normal([n_hidden_2, n_hidden_3])),
'encoder_h4': tf.Variable(tf.random_normal([n_hidden_3, n_hidden_4])),
'decoder_h1': tf.Variable(tf.random_normal([n_hidden_4, n_hidden_3])),
'decoder_h2': tf.Variable(tf.random_normal([n_hidden_3, n_hidden_2])),
'decoder_h3': tf.Variable(tf.random_normal([n_hidden_2, n_hidden_1])),
'decoder_h4': tf.Variable(tf.random_normal([n_hidden_1, n_input]))
}
biases = {
'encoder_b1': tf.Variable(tf.random_normal([n_hidden_1])),
'encoder_b2': tf.Variable(tf.random_normal([n_hidden_2])),
'encoder_b3': tf.Variable(tf.random_normal([n_hidden_3])),
'encoder_b4': tf.Variable(tf.random_normal([n_hidden_4])),
'decoder_b1': tf.Variable(tf.random_normal([n_hidden_3])),
'decoder_b2': tf.Variable(tf.random_normal([n_hidden_2])),
'decoder_b3': tf.Variable(tf.random_normal([n_hidden_1])),
'decoder_b4': tf.Variable(tf.random_normal([n_input])),
}
Третий шаг заключается в изменении функций определения сжатия и распаковки, которые также увеличены до четырех уровней.
#---------------------------------压缩和解压函数定义---------------------------------------
# Building the encoder
def encoder(x):
# 压缩隐藏层调用函数sigmoid(压缩值为0-1范围内)
layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, weights['encoder_h1']),
biases['encoder_b1']))
layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, weights['encoder_h2']),
biases['encoder_b2']))
layer_3 = tf.nn.sigmoid(tf.add(tf.matmul(layer_2, weights['encoder_h3']),
biases['encoder_b3']))
# 输出范围为负无穷大到正无穷大 调用matmul函数
layer_4 = tf.add(tf.matmul(layer_3, weights['encoder_h4']),
biases['encoder_b4'])
return layer_4
# Building the decoder
def decoder(x):
# 解压隐藏层调用sigmoid激活函数(范围内为0-1区间)
layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, weights['decoder_h1']),
biases['decoder_b1']))
layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, weights['decoder_h2']),
biases['decoder_b2']))
layer_3 = tf.nn.sigmoid(tf.add(tf.matmul(layer_2, weights['decoder_h3']),
biases['decoder_b3']))
layer_4 = tf.nn.sigmoid(tf.add(tf.matmul(layer_3, weights['decoder_h4']),
biases['decoder_b4']))
return layer_4
Четвертый шаг, наконец, модифицируем код обучения, мы больше не смотрим его результаты обучения, а наблюдаем за его результатами до распаковки.
# 观察解压前的结果
encoder_result = sess.run(encoder_op, feed_dict={X: mnist.test.images})
# 显示encoder压缩成2个元素的预测结果
plt.scatter(encoder_result[:, 0], encoder_result[:, 1], c=mnist.test.labels)
plt.colorbar()
plt.show()
Полный код выглядит следующим образом:
# -*- coding: utf-8 -*-
"""
Created on Wed Jan 15 15:35:47 2020
@author: xiuzhang Eastmount CSDN
"""
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow.examples.tutorials.mnist import input_data
#-----------------------------------初始化设置---------------------------------------
# 基础参数设置
learning_rate = 0.001 #学习效率
training_epochs = 20 #20组训练
batch_size = 256 #batch大小
display_step = 1
examples_to_show = 10 #显示10个样本
# 神经网络输入设置
n_input = 784 #MNIST输入数据集(28*28)
# 输入变量(only pictures)
X = tf.placeholder("float", [None, n_input])
# 隐藏层设置
n_hidden_1 = 128 #第一层特征数量
n_hidden_2 = 64 #第二层特征数量
n_hidden_3 = 10 #第三层特征数量
n_hidden_4 = 2 #第四层特征数量
weights = {
'encoder_h1': tf.Variable(tf.random_normal([n_input, n_hidden_1])),
'encoder_h2': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2])),
'encoder_h3': tf.Variable(tf.random_normal([n_hidden_2, n_hidden_3])),
'encoder_h4': tf.Variable(tf.random_normal([n_hidden_3, n_hidden_4])),
'decoder_h1': tf.Variable(tf.random_normal([n_hidden_4, n_hidden_3])),
'decoder_h2': tf.Variable(tf.random_normal([n_hidden_3, n_hidden_2])),
'decoder_h3': tf.Variable(tf.random_normal([n_hidden_2, n_hidden_1])),
'decoder_h4': tf.Variable(tf.random_normal([n_hidden_1, n_input]))
}
biases = {
'encoder_b1': tf.Variable(tf.random_normal([n_hidden_1])),
'encoder_b2': tf.Variable(tf.random_normal([n_hidden_2])),
'encoder_b3': tf.Variable(tf.random_normal([n_hidden_3])),
'encoder_b4': tf.Variable(tf.random_normal([n_hidden_4])),
'decoder_b1': tf.Variable(tf.random_normal([n_hidden_3])),
'decoder_b2': tf.Variable(tf.random_normal([n_hidden_2])),
'decoder_b3': tf.Variable(tf.random_normal([n_hidden_1])),
'decoder_b4': tf.Variable(tf.random_normal([n_input])),
}
# 导入MNIST数据
mnist = input_data.read_data_sets("MNIST_data", one_hot=False)
#---------------------------------压缩和解压函数定义---------------------------------------
# Building the encoder
def encoder(x):
# 压缩隐藏层调用函数sigmoid(压缩值为0-1范围内)
layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, weights['encoder_h1']),
biases['encoder_b1']))
layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, weights['encoder_h2']),
biases['encoder_b2']))
layer_3 = tf.nn.sigmoid(tf.add(tf.matmul(layer_2, weights['encoder_h3']),
biases['encoder_b3']))
# 输出范围为负无穷大到正无穷大 调用matmul函数
layer_4 = tf.add(tf.matmul(layer_3, weights['encoder_h4']),
biases['encoder_b4'])
return layer_4
# Building the decoder
def decoder(x):
# 解压隐藏层调用sigmoid激活函数(范围内为0-1区间)
layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, weights['decoder_h1']),
biases['decoder_b1']))
layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, weights['decoder_h2']),
biases['decoder_b2']))
layer_3 = tf.nn.sigmoid(tf.add(tf.matmul(layer_2, weights['decoder_h3']),
biases['decoder_b3']))
layer_4 = tf.nn.sigmoid(tf.add(tf.matmul(layer_3, weights['decoder_h4']),
biases['decoder_b4']))
return layer_4
#-----------------------------------压缩和解压操作---------------------------------------
# Construct model
# 压缩：784 => 128
encoder_op = encoder(X)
# 解压：784 => 128
decoder_op = decoder(encoder_op)
#--------------------------------对比预测和真实结果---------------------------------------
# 预测
y_pred = decoder_op
# 输入数据的类标(Labels)
y_true = X
# 定义loss误差计算 最小化平方差
cost = tf.reduce_mean(tf.pow(y_true - y_pred, 2))
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)
#-------------------------------------训练及可视化-------------------------------------
# 初始化
init = tf.initialize_all_variables()
# 训练集可视化操作
with tf.Session() as sess:
sess.run(init)
total_batch = int(mnist.train.num_examples/batch_size)
# 训练数据
for epoch in range(training_epochs):
# Loop over all batches
for i in range(total_batch):
batch_xs, batch_ys = mnist.train.next_batch(batch_size) # max(x)=1 min(x)=0
# 运行初始化和误差计算操作
_, c = sess.run([optimizer, cost], feed_dict={X: batch_xs})
# 每个epoch显示误差值
if epoch % display_step == 0:
print("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(c))
print("Optimization Finished!")
# 观察解压前的结果
encoder_result = sess.run(encoder_op, feed_dict={X: mnist.test.images})
# 显示encoder压缩成2个元素的预测结果
plt.scatter(encoder_result[:, 0], encoder_result[:, 1], c=mnist.test.labels)
plt.colorbar()
plt.show()
Этот тренировочный процесс занимает немного времени, а беговой результат показан на следующем рисунке:
Результат отображения кластеризации показан на рисунке ниже, где разные цвета сгруппированы в стопку, соответствующую разным числам. Например, набор данных в нижнем левом углу сгруппирован как число 0 путем обучения без учителя, а другая сторона — это другие данные.
Но результаты его кластеризации можно улучшить, потому что это всего лишь простой пример автоэнкодера. Я надеюсь, что эта статья поможет блоггерам понять и понять алгоритмы обучения без учителя и автоэнкодера, а в дальнейшем автор более подробно поделится хорошими примерами.
использованная литература:
[1] Ян Сючжан, Ян На. Сканирование и анализ сетевых данных Python от входа до овладения (анализ) [M].Пекин: Пекинский университет аэронавтики и астронавтики, 2018.
[2] Облачный видео-адрес NetEase «Не беспокойтесь о Боге»
[3] Study.163.com/course/Соберитесь…
[4] GitHub.com/FourUCApress/CNN…
[5] GitHub.com/east смонтировать…
[6] «Машинное обучение» Чжоу Чжихуа
[7] Глубокое обучение (07) RNN-рекуррентная нейронная сеть-02- реализация в Tensorflow
Нажмите «Подписаться», чтобы впервые узнать о новых технологиях HUAWEI CLOUD~