用于异常检测的 LSTM 自动编码器

Question

我正在测试 LSTM 自动编码器在 2D 输入异常检测方面的不同实现。 我的问题不是关于代码本身，而是关于理解每个网络的底层行为。

两种实现都具有相同数量的单元 (16)。模型 2 是一个“典型的”seq to seq 自动编码器，编码器的最后一个序列重复“n”次以匹配解码器的输入。 我想了解为什么模型 1 似乎很容易超过模型 2，以及为什么模型 2 不能做得比平均水平更好？

模型 1：

class LSTM_Detector(Model):
  def __init__(self, flight_len, param_len, hidden_state=16):
    super(LSTM_Detector, self).__init__()
    self.input_dim = (flight_len, param_len)
    self.units = hidden_state
    self.encoder = layers.LSTM(self.units,
                  return_state=True,
                  return_sequences=True,
                  activation="tanh",
                  name='encoder',
                  input_shape=self.input_dim)
    
    self.decoder = layers.LSTM(self.units,
                  return_sequences=True,
                  activation="tanh",
                  name="decoder",
                  input_shape=(self.input_dim[0],self.units))
    
    self.dense = layers.TimeDistributed(layers.Dense(self.input_dim[1]))
    
  def call(self, x):
    output, hs, cs = self.encoder(x)
    encoded_state = [hs, cs] # see https://www.tensorflow.org/guide/keras/rnn  
    decoded = self.decoder(output, initial_state=encoded_state)
    output_decoder = self.dense(decoded)

    return output_decoder

模型 2：

class Seq2Seq_Detector(Model):
  def __init__(self, flight_len, param_len, hidden_state=16):
    super(Seq2Seq_Detector, self).__init__()
    self.input_dim = (flight_len, param_len)
    self.units = hidden_state
    self.encoder = layers.LSTM(self.units,
                  return_state=True,
                  return_sequences=False,
                  activation="tanh",
                  name='encoder',
                  input_shape=self.input_dim)
    
    self.repeat = layers.RepeatVector(self.input_dim[0])
    
    self.decoder = layers.LSTM(self.units,
                  return_sequences=True,
                  activation="tanh",
                  name="decoder",
                  input_shape=(self.input_dim[0],self.units))
    
    self.dense = layers.TimeDistributed(layers.Dense(self.input_dim[1]))
    
  def call(self, x):
    output, hs, cs = self.encoder(x)
    encoded_state = [hs, cs] # see https://www.tensorflow.org/guide/keras/rnn 
    repeated_vec = self.repeat(output)
    decoded = self.decoder(repeated_vec, initial_state=encoded_state)
    output_decoder = self.dense(decoded)

    return output_decoder

我在数据样本(89, 1500, 77) 上为这两个模型拟合了 200 个 Epochs，每个输入都是(1500, 77) 的二维数组。以及测试数据(10,1500,77)。两个模型都只有16 units。

这里还是自动编码器对测试数据的一个特征的结果。

结果模型 1：（黑线为真实，红色为重建图像）

结果模型 2：

我知道第二个更严格，因为来自输入序列的所有信息都被压缩到一个步骤中，但我仍然感到惊讶的是，它几乎无法比预测平均值做得更好。

另一方面，我觉得模型 1 往往更容易受到新数据的“影响”，而没有回馈输入。请参阅下面的模型 1 示例，其中输入为平线：

PS：我知道这种模型的数据不多，我有更多可用的数据，但在这个阶段我只是在试验并试图建立我的理解。

PS 2：两个模型都没有过度拟合他们的数据，训练和验证曲线几乎就像教科书一样。

有谁能解释为什么在行为方面存在如此大的差距？

谢谢

Answer 1

在模型 1 中，77 个特征的每个点都以这种方式压缩和解压缩：77->16->16->77 加上前面步骤中的一些信息。在这种情况下，似乎仅用 TimeDistributed(Dense(...)) 替换 LSTM 也可能有效，但不能肯定地说，因为我不知道数据。第三张图可能会更好。

预测模型 2 的情况通常发生在输入中没有有用信号并且模型可以做的最好的事情（嗯，优化做）只是预测训练集的平均目标值。

在模型 2 中，您有：

...
    self.encoder = layers.LSTM(self.units,
                  return_state=True,
                  return_sequences=False,
...

然后

    self.repeat = layers.RepeatVector(self.input_dim[0])

所以，事实上，当它发生时

    repeated_vec = self.repeat(output)
    decoded = self.decoder(repeated_vec, initial_state=encoded_state)

它只需要编码器的最后一个输出（在这种情况下代表 1500 的最后一步），将其复制 1500 次（input_dim[0]），并尝试从一对夫妇的信息中预测所有 1500 个值最后的。这是模型丢失大部分有用信号的地方。它没有足够/任何关于输入的信息，它可以学习的最好的东西是为了最小化损失函数（我想在这种情况是 MSE 或 MAE）是为了预测每个特征的平均值。

此外，seq to seq 模型通常将解码器步骤的预测作为输入传递给下一个解码器步骤，在当前情况下，它始终是相同的值。

TL;DR 1) seq-to-seq 不是这种情况下的最佳模型； 2) 由于瓶颈，除了预测每个特征的平均值之外，它无法真正学会做任何事情。