LSTM自动编码器的这些实现之间的区别？

引起这个问题的具体原因是return_sequenceTensorFlow的LSTM层版本的争论。

文档说：

布尔值。是否返回最后的输出。在输出序列或完整序列中。默认值：False。

我已经看到了一些实现，尤其是自动编码器，该编码器使用此参数剥离除输出序列中的最后一个元素以外的所有内容，作为自动编码器一半的“编码器”的输出。

以下是三种不同的实现。我想了解差异背后的原因，因为看起来差异非常大，但所有人都称自己是同一回事。

示例1（TensorFlow）：

此实现剥离了LSTM的所有输出（序列的最后一个元素除外），然后重复该元素几次以重建序列：

model = Sequential()
model.add(LSTM(100, activation='relu', input_shape=(n_in,1)))
# Decoder below
model.add(RepeatVector(n_out))
model.add(LSTM(100, activation='relu', return_sequences=True))
model.add(TimeDistributed(Dense(1)))

在PyTorch中查看自动编码器的实现时，我没有看到作者这样做。取而代之的是，它们将LSTM的整个输出用于编码器（有时紧随其后是密集层，有时则不行）。

示例1（PyTorch）：

此实现在应用LSTM层之前训练了一个嵌入...似乎几乎破坏了基于LSTM的自动编码器的想法...序列在到达LSTM层时已经被编码。

class EncoderLSTM(nn.Module):
  def __init__(self, input_size, hidden_size, n_layers=1, drop_prob=0):
    super(EncoderLSTM, self).__init__()
    self.hidden_size = hidden_size
    self.n_layers = n_layers

    self.embedding = nn.Embedding(input_size, hidden_size)
    self.lstm = nn.LSTM(hidden_size, hidden_size, n_layers, dropout=drop_prob, batch_first=True)

  def forward(self, inputs, hidden):
    # Embed input words
    embedded = self.embedding(inputs)
    # Pass the embedded word vectors into LSTM and return all outputs
    output, hidden = self.lstm(embedded, hidden)
    return output, hidden

示例2（PyTorch）：

此示例编码器首先使用一个LSTM层扩展输入，然后通过具有较少数量隐藏节点的第二个LSTM层进行压缩。除了扩展，这似乎与我发现的这篇论文一致：https : //arxiv.org/pdf/1607.00148.pdf

但是，在此实现的解码器中，没有最终的密集层。解码通过第二个lstm层进行，该层将编码扩展回与原始输入相同的维度。在这里看到它。这与论文不符（尽管我不知道论文是否权威）。

class Encoder(nn.Module):
  def __init__(self, seq_len, n_features, embedding_dim=64):
    super(Encoder, self).__init__()
    self.seq_len, self.n_features = seq_len, n_features
    self.embedding_dim, self.hidden_dim = embedding_dim, 2 * embedding_dim
    self.rnn1 = nn.LSTM(
      input_size=n_features,
      hidden_size=self.hidden_dim,
      num_layers=1,
      batch_first=True
    )
    self.rnn2 = nn.LSTM(
      input_size=self.hidden_dim,
      hidden_size=embedding_dim,
      num_layers=1,
      batch_first=True
    )
  def forward(self, x):
    x = x.reshape((1, self.seq_len, self.n_features))
    x, (_, _) = self.rnn1(x)
    x, (hidden_n, _) = self.rnn2(x)
    return hidden_n.reshape((self.n_features, self.embedding_dim))

题：

我想知道实现中的这种差异。差异似乎很大。所有这些完成同一件事的有效方法吗？还是在“真正的” LSTM自动编码器中进行了一些误导的尝试？