我正在开发一个自动编码器使用张量流。在计算损失函数时，我遇到一个错误，说维数必须相等才能求平均值。所以我显示了输入层和输出层的形状，它们都是不同的，我无法分析问题出在哪里。数据集中使用的图像的形状为(54,96,3)
这是我的密码##--------------------------------------------
import cv2 as cv
import numpy as np
import tensorflow as tf
import argparse
import os
import glob
import matplotlib
import matplotlib.pyplot as plt
from functools import partial
def load_images_from_folder(folder):
images = []
for filename in os.listdir(folder):
img = cv.imread(os.path.join(folder,filename))
if img is not None:
images.append(img)
return np.asarray(images)
def plot_image(image, cmap = "Greys_r"):
plt.imshow(image.reshape([54, 96, 3]).astype(np.uint8),
cmap=cmap,interpolation="nearest")
plt.axis("off")
def _parse_function(filename):
image_string = tf.read_file(filename)
image_decoded = tf.image.decode_jpeg(image_string, channels=3)
image = tf.cast(image_decoded, tf.float32)
return image
## Parameters
n_inputs = 96 * 54
BATCH_SIZE = 150
batch_size = tf.placeholder(tf.int64)
files = list(glob.glob(os.path.join('danceVideoFrame1','*.*')))
dataset = tf.data.Dataset.from_tensor_slices((files))
dataset = dataset.map(_parse_function)
dataset = dataset.batch(BATCH_SIZE)
iterator = dataset.make_one_shot_iterator()
features = iterator.get_next()
with tf.Session() as sess:
#print(sess.run(features).shape)
#plot_image(sess.run(features), cmap = "Greys_r")
#plt.show()
## 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
## Define the Xavier initialization
xav_init =  tf.contrib.layers.xavier_initializer()
## Define the L2 regularizer
l2_regularizer = tf.contrib.layers.l2_regularizer(l2_reg)
## Create the dense layer
dense_layer = partial(tf.layers.dense,
activation=tf.nn.elu,
kernel_initializer=xav_init,
kernel_regularizer=l2_regularizer)
## 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)
print (outputs.shape)
print (features.shape)
#loss function
loss = tf.reduce_mean(tf.square(outputs - features))
## Optimize
loss = tf.reduce_mean(tf.square(outputs - features))
optimizer = tf.train.AdamOptimizer(learning_rate)
train  = optimizer.minimize(loss)
输出：
^{pr2}$

自编码器
文章目录
自编码器
简介
特点
应用
结构
分层训练方法
香草自编码器
栈式自编码器
1.捆绑权重
2.一次训练一个自编码器
3.进行无监督预训练
去噪自编码器
变分自编码器

简介
神经网络就是一种特殊的自编码器，区别在于自编码器的输出和输入是相同的，是一个自监督的过程，通过训练自编码器，得到每一层中的权重参数，自然地我们就得到了输入x的不同的表示（每一层代表一种）这些就是特征，自动编码器就是一种尽可能复现原数据的神经网络。
自编码器通过简单地学习将输入复制到输出来工作。这一任务（就是输入训练数据， 再输出训练数据的任务）听起来似乎微不足道，但通过不同方式对神经网络增加约束，可以使这一任务变得极其困难。比如，可以限制内部表示的尺寸（这就实现降维了），或者对训练数据增加噪声并训练自编码器使其能恢复原有。这些限制条件防止自编码器机械地将输入复制到输出，并强制它学习数据的高效表示。简而言之，编码（就是输入数据的高效表示）是自编码器在一些限制条件下学习恒等函数（identity function）的副产品。
特点
跟数据相关程度很高，这意味着自动编码器只能压缩与训练数据相似的数据，因为使用神经网络提取的特征一般是高度相关于原始的训练集。
压缩后数据是有损的，这是因为降维的过程中不可避免地丢失信息，解压之后的输出和原始的输入相比是退化的。
应用
数据去噪，进行可视化降维。生成数据。
结构

通常使用神经网络作为编码器和解码器，输入的数据经过神经网络降维到一个编码（code），接着又通过另外一个神经网络去解码得到一个与输入原数据一模一样的生成数据，然后通过比较这两个数据，最小化它们之间的差异来训练这个网络中编码器和解码器的参数。
分层训练方法
多层的训练方法：先进行第一层的code的训练，我们将第一层输出的code当成第二层的输入信号，同样最小化重构误差，就会得到第二层的参数，并且得到第二层输出的code，也就是原输入信息的第二个表达了。其他层就同样的方法炮制就行了

当input的维度大于code的维度的时候，表示该变换是一种降维的操作
当input的维度小于code的维度的时候，即稀疏编码器
香草自编码器
香草自编码器（Vanilla Autoencoder），只有三层网络，即只有一个隐藏层的神经网络。它的输入和输出是相同的，可通过使用Adam优化器和均方误差损失函数，来学习如何重构输入。
隐藏层的压缩维度为32，小于输入维度784，因此这个编码器是有损的，通过这个约束，来迫使神经网络来学习数据的压缩表征。
栈式自编码器
和其他的神经网络一样，自编码器可以有多个隐层，这被称作栈式自编码器（或者深度自编码器）。增加隐层可以学到更复杂的编码，但千万不能使自编码器过于强大。
栈式自编码器的架构一般是关于中间隐层对称的。

1.捆绑权重
如果一个自编码器的层次是严格轴对称的，一个常用的技术是将decoder层的权重捆绑到encoder层。这使得模型参数减半，加快了训练速度并降低了过拟合风险
2.一次训练一个自编码器
与之前训练整个栈式自编码器不同，可以训练多个浅层的自编码器，然后再将它们合并为一体，这样要快得多。
例如：第一个自编码器学习去重建输入。然后，第二个自编码器学习去重建第一个自编码器隐层的输出。最后，这两个自编码器被整合到一起，如图15-4。可以使用这种方式，创建一个很深的栈式自编码器。

3.进行无监督预训练
如果有一个很大的数据集但绝大部分是未标注数据，可以使用所有的数据先训练一个栈式自编码器，然后复用低层来完成真正的任务。

去噪自编码器
制自编码器学习有用特征的方式是在输入增加噪声，通过训练之后得到无噪声的输出。这防止了自编码器简单的将输入复制到输出，从而提取出数据中有用的模式
噪声可以是添加到输入的纯高斯噪声，也可以是随机丢弃输入层的某个特征，类似于dropout。

变分自编码器
我们想利用现有的样本去生成一些新的样本，从而扩大数据量。如果我们能知道原始数据集x的分布p(x),那么我们直接从这个分布中采样就可以得到新的样本。而在现实中，我们无法得到数据集的真实分布，于是变分编码器利用了一个隐分布z，通过z来生成新的样本，从概率角度来说就是p(x) = p(z)×p(x|z)。通过构造隐变量，让我们可以近似等于从原始分布中采样来组成新样本，而效果的好坏就靠模型来实现了。

首先想到的是用神经网络来训练参数，那么当训练好模型后，我们输入x，可以生成新的样本x’，且他们近似都是从原始数据集分布中采样出来的，故可以参与训练其他模型，也就完成了数据增强。那么第一个损失函数就应运而生，即比较生成的x’和原始样本x的差距，差距越小效果越好。

但是这样自然是不可行的，因为既然训练的目的是使输出样本和原样本相似度最高，那么我们直接拷贝一份原数据就行了，就不需要训练了。也就是说，数据增强的目的不仅要保证增强的数据都服从和源数据一样的分布，而且要有多样性，即有一些源数据没有的特征，这样才能达到数据增强的目的。

于是我们考虑采样，因为采样的数据服从同一分布，但又各不相同，就可以满足多样性这一要求。

考虑从隐分布z来进行数据采样，一个很自然的想法就是采用标准正态分布，但是如果对于所有的样本，训练的时候我们都从z中进行采样，然后用于训练，那么也就和原始的输入数据没什么关系了，即采样出的z不知道是由哪一个原始数据x生成的，这样也就没法进行损失计算，也就没法训练神经网络了。于是考虑如何把生成的数据和原始数据能一一对应起来，变分编码器让每个样本都服从一个正态分布，但这个正态分布又各不相同，即正态分布的两个参数均值和方差各不相同，那么这样输入输出就可以一一对应了。

那么如何学习输入的每个样本服从的正态分布的均值和方差呢，这个时候就要用到神经网络了，一切不好计算的都用神经网络去拟合，于是对于每个输入样本经过一层或多层神经网络，分别输出均值和方差，然后再从服从此均值和方差的正态分布中去随机采样生成新的样本。
看似已经可以完成数据增强的目的了，但是仔细想想问题还有很多。首先既然损失函数是输出样本和输入样本的相似度，那么网络肯定往减少输出样本和输入样本的差异上去拟合，我们记得输出样本是通过在正态分布上采样得到的，我们知道正态分布的方差越大，则数据越分散，采样得到的数据噪声越大，导致输出样本和输入样本的相似度很小，于是网络训练会尽量减小正态分布的方差，直到接近0，那么还是那个问题，方差接近0，则生成的数据的多样性又减少了。所以这个问题还是没有解决。

变分编码器使神经网络学到的正态分布尽量趋近于标准正态分布，即学到的均值和方差分别趋近于0和1。如何做到呢，那就是再增加一个损失函数。增加的损失函数是衡量网络学习到的正态分布和标准正态分布的差异性，即使用了KL散度。这样，神经网路一方面要学习输入输出的相似性，还要考虑增加一定的噪音，即不使正态分布的方差趋紧于0，也就增加了输出的多样性。


参考：
https://blog.csdn.net/h__ang/article/details/90720579?ops_request_misc=&request_id=&biz_id=102&utm_term=pytorch%E5%AE%9E%E7%8E%B0%E8%87%AA%E7%BC%96%E7%A0%81%E5%99%A8&utm_medium=distribute.pc_search_result.none-task-blog-2allsobaiduweb~default-1-90720579
https://www.cnblogs.com/LXP-Never/p/10921257.html#%E5%9F%BA%E6%9C%AC%E8%87%AA%E7%BC%96%E7%A0%81%E5%99%A8
https://www.cnblogs.com/royhoo/p/Autoencoders.html
https://blog.csdn.net/bobobe/article/details/87543892?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522160021902919724839820054%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=160021902919724839820054&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2allfirst_rank_ecpm_v3~rank_business_v1-1-87543892.ecpm_v3_rank_business_v1&utm_term=%E5%8F%98%E5%88%86%E8%87%AA%E7%BC%96%E7%A0%81%E5%99%A8&spm=1018.2118.3001.4187

	

上期我们一起学习了深度学习中的可视化自编码器和无监督预训练的相关知识，
深度学习算法(第29期)----可视化自编码器和无监督预训练今天我们一起学一下降噪自编码器和稀疏自编码器方面的知识。
降噪自编码器
一般情况下，为了强制自编码器去学习一些有用的特征，往往会对输入数据进行增加一些噪声，然后训练它去恢复原始没有噪声的数据。这就防止了自编码器耍小聪明，去复制输入到输出。因此最终会寻找到输入数据的特征模式。
自20世纪80年代以来，使用自编码器消除噪声的想法已经出现(例如，在 Yann LeCun的1987年硕士论文中提到过)。在2008年的一篇论文中，Pascal Vincent 表明自编码器也可用于特征提取。在2010年的一篇文章中Vincent等人引入栈式降噪自编码器。
噪声可以是纯粹的高斯噪声添加到输入，或者它可以随机关闭输入，就像之前学的dropout，深度学习算法(第7期)----深度学习之避免过拟合(正则化)
如下图： 其中左侧的是对原始数据增加高斯噪声，右边的是利用Dropout方法实现的降噪自编码器。
降噪自编码器的TensorFlow实现
在tensorflow中实现降噪自编码器并不难，首先加入高斯噪声，其他的就像训练一个常规的自编码器一样，而且重构损失是基于原始输入上的，代码如下：
X = tf.placeholder(tf.float32, shape=[None, n_inputs])
X_noisy = X + tf.random_normal(tf.shape(X))
[...]
hidden1 = activation(tf.matmul(X_noisy, weights1) + biases1)
[...]
reconstruction_loss = tf.reduce_mean(tf.square(outputs - X)) # MSE
[...]
而Dropout版本，更为简单，不多歪歪，代码如下：
from tensorflow.contrib.layers import dropout

keep_prob = 0.7

is_training = tf.placeholder_with_default(False, shape=(), name='is_training')
X = tf.placeholder(tf.float32, shape=[None, n_inputs])
X_drop = dropout(X, keep_prob, is_training=is_training)
[...]
hidden1 = activation(tf.matmul(X_drop, weights1) + biases1)
[...]
reconstruction_loss = tf.reduce_mean(tf.square(outputs - X)) # MSE
[...]
需要注意的是，正如之前学过的，在训练的时候，需要设置is_training为True.
sess.run(training_op, feed_dict={X: X_batch, is_training: True})
稀疏自编码器
往往提取好的特征的另外一种约束就是稀疏性，通过在损失函数中添加一个合适的项，使得自编码器努力去减少编码层中活跃的神经元。例如，它可以使得编码层平均只有5%的活跃神经元，这就迫使自编码器去将每个输入表示为少量激活的组合。结果，编码层中的每个神经元通常都会代表一个有用的特征(如果您每个月只能说几个字，您肯定会字字千金)。
为了支持稀疏模型，我们首先必须在每次训练迭代中计算编码层的实际稀疏度。 我们通过计算整个训练batch中，编码层中的每个神经元的平均激活情况来实现。 这里的训练batch不能太小，否则平均数不准确。
一旦我们有了每个神经元的平均激活情况，我们希望通过向损失函数添加稀疏损失来惩罚太活跃的神经元。例如，如果我们计算一个神经元的平均激活值为 0.3，但目标稀疏度为0.1，那么它必须受到惩罚才能降低神经元的活跃度。一种方法可以简单地将平方误差(0.3-0.1)^2添加到损失函数中，但实际上更好的方法是使用Kullback-Leibler散度，其具有比均方误差更强的梯度，如下图所示：
假如给定两个离散概率分布P和Q，那么这两个分布之间的KL散度计算如下：
在我们的这个情况下，我们想要计算编码层中的神经元将要激活的目标概率p与实际概率q(即训练batch上的平均激活)之间的散度，那么上面公式则简化为：
一旦我们计算了编码层中每一个神经元的稀疏损失，我们就可以把它们累加起来添加到损失函数中了。为了控制稀疏损失和重构损失的相对重要性，我们可以用稀疏权重这个超参数乘以稀疏损失。如果这个权重太高，模型会紧贴目标稀疏度，但它可能无法正确重建输入，导致模型无用。相反，如果它太低，模型将大多忽略稀疏目标，进而不会学习任何有趣的功能。
稀疏自编码器的TensorFlow实现
介绍完了稀疏自编码器，我们一起看一下，在tensorflow中，它是如何实现的：
def kl_divergence(p, q):
    return p * tf.log(p / q) + (1 - p) * tf.log((1 - p) / (1 - q))

learning_rate = 0.01
sparsity_target = 0.1
sparsity_weight = 0.2

[...] # Build a normal autoencoder (in this example the coding layer is hidden1)

optimizer = tf.train.AdamOptimizer(learning_rate)

hidden1_mean = tf.reduce_mean(hidden1, axis=0) # batch mean
sparsity_loss = tf.reduce_sum(kl_divergence(sparsity_target, hidden1_mean))
reconstruction_loss = tf.reduce_mean(tf.square(outputs - X)) # MSE
loss = reconstruction_loss + sparsity_weight * sparsity_loss
training_op = optimizer.minimize(loss)
需要注意的是，编码层的活跃度必须在0-1之间(不能为0或者1)，否则的话，KL散度将为NaN(一个非数字值)。一个简单的解决方法就是在编码层的激活函数用sigmoid函数，如下：
hidden1 = tf.nn.sigmoid(tf.matmul(X, weights1) + biases1)
这里我们可以用一个小技巧来加快模型的收敛，可以将重构损失设置为具有较大梯度的交叉熵来代替MSE。用交叉熵的话，就需要将输入归一化到0到1之间，并在输出层用sigmoid函数作为激活函数，这样就能保证在输出值也是在0到1之间。tensorflow中sigmoid_cross_entropy_with_logits()函数在输出层应用了sigmoid激活函数：
[...]
logits = tf.matmul(hidden1, weights2) + biases2)
    outputs = tf.nn.sigmoid(logits)

reconstruction_loss = tf.reduce_sum(
    tf.nn.sigmoid_cross_entropy_with_logits(labels=X, logits=logits))
需要注意的是，outputs运算操作在实际训练中并不需要，这里我们只是想看一下重构过程。
好了，至此，今天我们简单学习了降噪自编码器和稀疏自编码器的原理及其tensorflow实现的相关知识，希望有些收获，下期我们将学习变分自编码器的相关知识，欢迎留言或进社区共同交流，喜欢的话，就点个赞吧，您也可以置顶公众号，第一时间接收最新内容。
智能算法，与您携手，沉淀自己，引领AI！

	

但是,当我启动完全相同的代码,并使用summary()分析网络架构时,似乎输出大小与输入大小不兼容(在自动编码器的情况下是必需的).这是summary()的输出：
**____________________________________________________________________________________________________
Layer (type)                     Output Shape          Param #     Connected to
====================================================================================================
input_1 (InputLayer)             (None, 1, 28, 28)     0
____________________________________________________________________________________________________
convolution2d_1 (Convolution2D)  (None, 16, 28, 28)    160         input_1[0][0]
____________________________________________________________________________________________________
maxpooling2d_1 (MaxPooling2D)    (None, 16, 14, 14)    0           convolution2d_1[0][0]
____________________________________________________________________________________________________
convolution2d_2 (Convolution2D)  (None, 8, 14, 14)     1160        maxpooling2d_1[0][0]
____________________________________________________________________________________________________
maxpooling2d_2 (MaxPooling2D)    (None, 8, 7, 7)       0           convolution2d_2[0][0]
____________________________________________________________________________________________________
convolution2d_3 (Convolution2D)  (None, 8, 7, 7)       584         maxpooling2d_2[0][0]
____________________________________________________________________________________________________
maxpooling2d_3 (MaxPooling2D)    (None, 8, 3, 3)       0           convolution2d_3[0][0]
____________________________________________________________________________________________________
convolution2d_4 (Convolution2D)  (None, 8, 3, 3)       584         maxpooling2d_3[0][0]
____________________________________________________________________________________________________
upsampling2d_1 (UpSampling2D)    (None, 8, 6, 6)       0           convolution2d_4[0][0]
____________________________________________________________________________________________________
convolution2d_5 (Convolution2D)  (None, 8, 6, 6)       584         upsampling2d_1[0][0]
____________________________________________________________________________________________________
upsampling2d_2 (UpSampling2D)    (None, 8, 12, 12)     0           convolution2d_5[0][0]
____________________________________________________________________________________________________
convolution2d_6 (Convolution2D)  (None, 16, 10, 10)    1168        upsampling2d_2[0][0]
____________________________________________________________________________________________________
upsampling2d_3 (UpSampling2D)    (None, 16, 20, 20)    0           convolution2d_6[0][0]
____________________________________________________________________________________________________
convolution2d_7 (Convolution2D)  (None, 1, 20, 20)     145         upsampling2d_3[0][0]
====================================================================================================
Total params: 4385
____________________________________________________________________________________________________**
解决方法:
请注意,您在前一个卷积层中缺少border_mode选项.
from keras.layers import Input, Dense, Convolution2D, MaxPooling2D, UpSampling2D
from keras.models import Model
input_img = Input(shape=(1, 28, 28))
x = Convolution2D(16, 3, 3, activation='relu', border_mode='same')(input_img)
x = MaxPooling2D((2, 2), border_mode='same')(x)
x = Convolution2D(8, 3, 3, activation='relu', border_mode='same')(x)
x = MaxPooling2D((2, 2), border_mode='same')(x)
x = Convolution2D(8, 3, 3, activation='relu', border_mode='same')(x)
encoded = MaxPooling2D((2, 2), border_mode='same')(x)
# at this point the representation is (8, 4, 4) i.e. 128-dimensional
x = Convolution2D(8, 3, 3, activation='relu', border_mode='same')(encoded)
x = UpSampling2D((2, 2))(x)
x = Convolution2D(8, 3, 3, activation='relu', border_mode='same')(x)
x = UpSampling2D((2, 2))(x)
x = Convolution2D(16, 3, 3, activation='relu', border_mode='same')(x)
x = UpSampling2D((2, 2))(x)
decoded = Convolution2D(1, 3, 3, activation='sigmoid', border_mode='same')(x)
autoencoder = Model(input_img, decoded)
autoencoder.compile(optimizer='adadelta', loss='binary_crossentropy')
这应该工作正常
标签：python,neural-network,deep-learning,keras,autoencoder