标签: autoencoder

在场景 1 中，我有一个多层稀疏自动编码器，它试图重现我的输入，因此我的所有层都与随机启动的权重一起训练。没有监督层，在我的数据上这没有学到任何相关信息（代码工作正常，经过验证，因为我已经在许多其他深度神经网络问题中使用了它）

在场景 2 中，我只是在类似于深度学习的贪婪逐层训练中训练多个自动编码器（但最终没有监督步骤），每一层都在前一个自动编码器的隐藏层的输出上。他们现在将分别学习一些模式（正如我从可视化权重中看到的），但并不像我从单层 AE 中所期望的那样出色。

所以我决定尝试现在连接到 1 个多层 AE 的预训练层是否可以比随机初始化版本表现更好。如您所见，这与深度神经网络中微调步骤的想法相同。

但是在我的微调过程中，所有层的神经元似乎都没有得到改进，而是迅速收敛到一个完全相同的模式，最终什么也没学到。

问题：训练完全无监督的多层重建神经网络的最佳配置是什么？首先分层，然后进行某种微调？为什么我的配置不起作用？

我正在尝试使用神经网络进行图像修复，并使用去噪自动编码器预先训练权重。全部根据https://papers.nips.cc/paper/4686-image-denoising-and-inpainting-with-deep-neural-networks.pdf

我已经制作了他们正在使用的自定义损失函数。

我的集合是图像的一批重叠补丁 (196x32x32)。我的输入是损坏的图像批次，输出应该是清理后的图像。

我的损失函数的一部分是

dif_y = tf.subtract(y_xi,y_)

dif_norm = tf.norm(dif_y, ord = 'euclidean', axis = (1,2))

其中 y_xi(196 x 1 x 3072) 是重建的干净图像，y_ (196 x 1 x 3072) 是真实的干净图像。所以我实际上从损坏的版本中减去所有图像，然后将所有这些差异相加。我觉得这个数字很大很正常。

train_step = tf.train.AdamOptimizer().minimize(loss)

损失值开始于 3*10^7 左右，并在 200 次运行（我循环 1000 次）后收敛于接近值。所以我的输出图像将与原始图像相差数英里。

编辑：从 3.02391e+07 开始并收敛到 3.02337e+07

有什么办法我的损失值是正确的吗？如果是这样，我怎样才能大幅减少它？

谢谢

编辑2：我的损失函数

dif_y = tf.subtract(y,y_)
dif_norm = tf.norm(dif_y, ord = 'euclidean', axis = (1,2))
sqr_norm = tf.square(dif_norm)
prod = tf.multiply(sqr_norm,0.5)
sum_norm2 = tf.reduce_sum(prod,0)
error_1 = tf.divide(sum_norm2,196)

我正在尝试运行一个简单的自动编码器,所有的训练输入都是一样的.训练数据特征等于3,隐藏层中有3个节点.我用该输入训练自动编码器,然后我再次尝试预测它(编码/解码)(所以如果自动编码器按原样传递一切而没有任何改变它应该工作)

无论如何,情况并非如此,我有点难以理解为什么.我不确定我的代码或者我对autoencdoer实现的理解是否有问题.这是代码供参考.

PS我玩了多个epoches,训练集中的例子数量,批量大小,使训练数据值在0-1之间,并且跟踪损失值,但这也没有帮助.

`

from keras.layers import Input, Dense
from keras.models import Model
import numpy as np 
# this is the size of our encoded representations
encoding_dim = 3

x_train=np.array([[1,2,3],[1,2,3],[1,2,3],[1,2,3],[1,2,3],[1,2,3],[1,2,3],[1,2,3],[1,2,3]])
in= Input(shape=(3,))
encoded = Dense(encoding_dim, activation='relu')(in)
decoded = Dense(3, activation='sigmoid')(encoded)

# this model maps an input to its reconstruction
autoencoder = Model(in, decoded)
autoencoder.compile(optimizer='adadelta', loss='mse')

autoencoder.fit(x_train, x_train,
                epochs=100,
                batch_size=4)
autoencoder.predict(x_train)

`

我得到的输出应该与输入相同(或至少接近),但我得到了这个)

`Out[180]: 
array([[ 0.80265796,  0.89038897,  0.9100889 ],
       [ 0.80265796,  0.89038897,  0.9100889 ],
       [ 0.80265796,  0.89038897,  0.9100889 ],
       ..., 
       [ …

我正在尝试自动确定Keras自动编码器何时收敛。例如，在“让我们构建尽可能简单的自动编码器”下查看此链接。时期数被硬编码为50（损失值收敛时）。但是，如果您不知道数字为50，您将如何使用Keras对此进行编码？您可以继续打电话fit()吗？

我正在尝试使用autoencoder和Keras检测欺诈.我已将以下代码编写为Notebook:

import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
from sklearn.preprocessing import StandardScaler
from keras.layers import Input, Dense
from keras.models import Model
import matplotlib.pyplot as plt

data = pd.read_csv('../input/creditcard.csv')
data['normAmount'] = StandardScaler().fit_transform(data['Amount'].values.reshape(-1, 1))
data = data.drop(['Time','Amount'],axis=1)

data = data[data.Class != 1]
X = data.loc[:, data.columns != 'Class']

encodingDim = 7
inputShape = X.shape[1]
inputData = Input(shape=(inputShape,))

X = X.as_matrix()

encoded = Dense(encodingDim, activation='relu')(inputData)
decoded = Dense(inputShape, activation='sigmoid')(encoded) …

我想我理解了自动编码变分贝叶斯论文。我正在阅读一些实现本文的张量流代码。但我不明白这些代码中的损失函数。由于很多代码都是以相同的方式编写的，因此我可能是错的。

问题是这样的。以下方程来自AEVB 论文。 损失函数就像这个方程。该方程可以分为两个：正则化项和重构项。因此，就变成了

Loss_function = Regularization_term + Reconstruction_term

然而，许多代码以负号实现此正则化项，例如

Loss_function = -Regularization_term + Reconstruction_term 

例如，在此代码中，第 79 行将正则化项显示为

KLD = -.5 * tf.reduce_sum(1. + enc_logsd - tf.pow(enc_mu, 2) - tf.exp(enc_logsd), reduction_indices=1)

然后，它只是添加到重建术语。

loss = tf.reduce_mean(KLD + BCE)

我不明白。KLD 的符号与论文中的方程相反。类似这样的代码还有很多。我想我错了，但我不知道错在哪里。你能解释一下为什么它应该是这样的吗？

参考代码：代码1、代码2、代码3

我正在尝试使用 LSTM 自动编码器以可变长度的序列作为输入进行序列到序列学习，使用以下代码：

inputs = Input(shape=(None, input_dim))
masked_input = Masking(mask_value=0.0, input_shape=(None,input_dim))(inputs)
encoded = LSTM(latent_dim)(masked_input)

decoded = RepeatVector(timesteps)(encoded)
decoded = LSTM(input_dim, return_sequences=True)(decoded)
sequence_autoencoder = Model(inputs, decoded)
encoder = Model(inputs, encoded)

其中inputs原始序列数据用 0 填充到相同的长度 ( timesteps)。使用上面的代码，输出的长度也是timesteps，但是当我们计算损失函数时，我们只需要Ni输出的第一个元素（其中Ni是输入序列 i 的长度，对于不同的序列可能不同）。有谁知道是否有一些好的方法可以做到这一点？

谢谢！

它可能看起来像很多代码，但是大多数代码都是注释或格式，以使其更具可读性。

给定：
如果我定义感兴趣的变量“序列”，则如下：

# define input sequence
np.random.seed(988) 

#make numbers 1 to 100
sequence = np.arange(0,10, dtype=np.float16)

#shuffle the numbers
sequence = sequence[np.random.permutation(len(sequence))]

#augment the sequence with itself
sequence = np.tile(sequence,[15]).flatten().transpose()

#scale for Relu
sequence = (sequence - sequence.min()) / (sequence.max()-sequence.min())

sequence

# reshape input into [samples, timesteps, features]
n_in = len(sequence)
sequence = sequence.reshape((1, n_in, 1))

问题：
如何在Keras的自动编码器中使用conv1d以合理的准确度估算此序列？

如果conv1d不适合此问题，您能告诉我编码器/解码器更合适的层类型是什么吗？

更多信息：
有关数据的要点：

• 它是10个不同值的重复序列
• 一个10步的滞后可以完美预测序列
• 包含10个元素的字典应给出“预测给出的下一个”

我曾尝试对编码器和解码器部分（LSTM，密集，多层密集）的其他层进行预测，并且它们不断在0.0833的mse处碰到“墙”……这是0到1之间均匀分布的方差对我来说，一个好的自动编码器在解决这个简单问题上应该至少能够获得99.9％的准确度，因此“ mse”的准确度大大低于1％。

我无法转换conv1d，因为我弄乱了输入。关于如何使其工作似乎没有真正的好例子，而且我对这种总体架构还很陌生，对我来说并不明显。

链接：

• https://ramhiser.com/post/2018-05-14-autoencoders-with-keras/
• https://machinelearningmastery.com/lstm-autoencoders/

在 VAE 教程中，两个正态分布的 kl 散度定义为：

而在很多代码中，例如here、here和here，代码实现为：

 KL_loss = -0.5 * torch.sum(1 + logv - mean.pow(2) - logv.exp())

或者

def latent_loss(z_mean, z_stddev):
    mean_sq = z_mean * z_mean
    stddev_sq = z_stddev * z_stddev
    return 0.5 * torch.mean(mean_sq + stddev_sq - torch.log(stddev_sq) - 1)

它们有何关系？为什么代码中没有“tr”或“.transpose()”？

我目前正在尝试训练一个自动编码器，它允许将长度为 128 个整数变量的数组表示为压缩为 64 的数组。该数组包含 128 个整数值，范围从 0 到 255。

我在每个时期使用超过 200 万个数据点来训练模型。每个数组的形式如下：[ 1, 9, 0, 4, 255, 7, 6, ..., 200]

input_img = Input(shape=(128,))
encoded = Dense(128, activation=activation)(input_img)
encoded = Dense(128, activation=activation)(encoded)

encoded = Dense(64, activation=activation)(encoded)

decoded = Dense(128, activation=activation)(encoded)
decoded = Dense(128, activation='linear')(decoded)

autoencoder = Model(input_img, decoded)
autoencoder.compile(optimizer='adam', loss='mse')

history = autoencoder.fit(np.array(training), np.array(training),
                    epochs=50,
                    batch_size=256,
                    shuffle=True,
                    validation_data=(np.array(test), np.array(test)),
                    callbacks=[checkpoint, early_stopping])

我还将上传一张显示训练和验证过程的图表：训练损失图

我怎样才能进一步降低损失呢？到目前为止我已经尝试过的（两种选择都没有成功）：

1. 更长的训练阶段
2. 更多层