我在Pytorch中使用Sequence to Sequence模型.序列到序列模型包括编码器和解码器.

编码器转换a (batch_size X input_features X num_of_one_hot_encoded_classes) -> (batch_size X input_features X hidden_size)

解码器将采用此输入序列并将其转换为 (batch_size X output_features X num_of_one_hot_encoded_classes)

一个例子是 -

所以在上面的例子中,我需要将22个输入功能转换为10个输出功能.在Keras中,可以使用RepeatVector(10)完成.

一个例子 -

model.add(LSTM(256, input_shape=(22, 98)))
model.add(RepeatVector(10))
model.add(Dropout(0.3))
model.add(LSTM(256, return_sequences=True))

虽然,我不确定它是否是将输入序列转换为输出序列的正确方法.

所以,我的问题是 -

• 将输入序列转换为输出序列的标准方法是什么.例如.转换自(batch_size,22,98) - >(batch_size,10,98)？或者我应该如何准备解码器？

编码器代码片段(用Pytorch编写) -

class EncoderRNN(nn.Module):
    def __init__(self, input_size, hidden_size):
        super(EncoderRNN, self).__init__()
        self.hidden_size = hidden_size
        self.lstm = nn.LSTM(input_size=input_size, hidden_size=hidden_size,
          num_layers=1, batch_first=True)

    def forward(self, input):
        output, hidden = self.lstm(input)
        return output, hidden

我在keras中创建了seq2seq模型。我建立了单层编码器和解码器，它们工作正常。但是现在我想将其扩展到多层编码器和解码器。我正在使用Keras Functional API构建它。

训练：-

编码器代码：-

encoder_input=Input(shape=(None,vec_dimension))
encoder_lstm=LSTM(vec_dimension,return_state=True,return_sequences=True)(encoder_input)
encoder_lstm=LSTM(vec_dimension,return_state=True)(encoder_lstm)
encoder_output,encoder_h,encoder_c=encoder_lstm

解码器代码：-

encoder_state=[encoder_h,encoder_c]
decoder_input=Input(shape=(None,vec_dimension))
decoder_lstm= LSTM(vec_dimension,return_state=True,return_sequences=True (decoder_input,initial_state=encoder_state)
decoder_lstm=LSTM(vec_dimension,return_state=True,return_sequences=True)(decoder_lstm)
decoder_output,_,_=decoder_lstm

供测试用 ：-

encoder_model=Model(inputs=encoder_input,outputs=encoder_state)
decoder_state_input_h=Input(shape=(None,vec_dimension))
decoder_state_input_c=Input(shape=(None,vec_dimension))
decoder_states_input=[decoder_state_input_h,decoder_state_input_c]
decoder_output,decoder_state_h,decoder_state_c =decoder_lstm #(decoder_input,initial_state=decoder_states_input)
decoder_states=[decoder_state_h,decoder_state_c]
decoder_model=Model(inputs=[decoder_input]+decoder_states_input,outputs=[decoder_output]+decoder_states)

现在，当我尝试增加编号时。解码器中的多个层进行训练，然后训练可以正常工作，但对于测试它无效，并会引发错误。

实际上问题是当我将其设置initial_state为多层时，我将其转移到了通常在最后指定的中间层，因此当我在测试期间调用它时，会抛出错误。

RuntimeError: Graph disconnected: cannot obtain value for tensor Tensor("input_64:0", shape=(?, ?, 150), dtype=float32) at layer "input_64".The following previous layers were accessed without issue: []

我应该如何initial_state=decoder_states_input为输入层传递which，以免引发错误。我应该如何通过initial_state=decoder_states_input在第一个输入层的最后一层？

编辑：-

在该代码中，我尝试制作多层解码器LSTM。但这给了错误。使用单层时正确的代码是：-

编码器（培训）：-

encoder_input=Input(shape=(None,vec_dimension))
encoder_lstm =LSTM(vec_dimension,return_state=True)(encoder_input)
encoder_output,encoder_h,encoder_c=encoder_lstm

解码器（培训）：-

encoder_state=[encoder_h,encoder_c]
decoder_input=Input(shape=(None,vec_dimension))
decoder_lstm= LSTM(vec_dimension, return_state=True, return_sequences=True)
decoder_output,_,_=decoder_lstm(decoder_input,initial_state=encoder_state)

解码器（测试中）

decoder_output,decoder_state_h,decoder_state_c=decoder_lstm( decoder_input, initial_state=decoder_states_input) …

我正在尝试实施Luong 等人中描述的注意力。2015 年在 PyTorch 中，但我无法让它工作。下面是我的代码，我现在只对“一般”关注案例感兴趣。我想知道我是否遗漏了任何明显的错误。它运行，但似乎没有学习。

class AttnDecoderRNN(nn.Module):
    def __init__(self, hidden_size, output_size, dropout_p=0.1):
        super(AttnDecoderRNN, self).__init__()
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.dropout_p = dropout_p

        self.embedding = nn.Embedding(
            num_embeddings=self.output_size,
            embedding_dim=self.hidden_size
        )
        self.dropout = nn.Dropout(self.dropout_p)
        self.gru = nn.GRU(self.hidden_size, self.hidden_size)
        self.attn = nn.Linear(self.hidden_size, self.hidden_size)
        # hc: [hidden, context]
        self.Whc = nn.Linear(self.hidden_size * 2, self.hidden_size)
        # s: softmax
        self.Ws = nn.Linear(self.hidden_size, self.output_size)

    def forward(self, input, hidden, encoder_outputs):
        embedded = self.embedding(input).view(1, 1, -1)
        embedded = self.dropout(embedded)

        gru_out, hidden = self.gru(embedded, hidden) …

我为文本摘要创建了一个 Seq2Seq 模型。我有两种模型，一种有注意力，一种没有。没有注意力的人能够产生预测，但我不能为有注意力的人做预测，即使它成功地拟合。

这是我的模型：

latent_dim = 300
embedding_dim = 200

clear_session()

# Encoder
encoder_inputs = Input(shape=(max_text_len, ))

# Embedding layer
enc_emb = Embedding(x_voc, embedding_dim,
                    trainable=True)(encoder_inputs)

# Encoder LSTM 1
encoder_lstm1 = Bidirectional(LSTM(latent_dim, return_sequences=True,
                     return_state=True, dropout=0.4,
                     recurrent_dropout=0.4))
(encoder_output1, forward_h1, forward_c1, backward_h1, backward_c1) = encoder_lstm1(enc_emb)

# Encoder LSTM 2
encoder_lstm2 = Bidirectional(LSTM(latent_dim, return_sequences=True,
                     return_state=True, dropout=0.4,
                     recurrent_dropout=0.4))
(encoder_output2, forward_h2, forward_c2, backward_h2, backward_c2) = encoder_lstm2(encoder_output1)

# Encoder LSTM 3
encoder_lstm3 = Bidirectional(LSTM(latent_dim, return_state=True,
                     return_sequences=True, dropout=0.4,
                     recurrent_dropout=0.4))
(encoder_outputs, forward_h, forward_c, backward_h, backward_c) = encoder_lstm3(encoder_output2)

state_h …

BATCH_QUEUE_MAX = 100

self._data_path = data_path
self._vocab = vocab
self._hps = hps
self._single_pass = single_pass

# Initialize a queue of Batches waiting to be used, and a queue of Examples waiting to be batched
self._batch_queue = Queue.Queue(self.BATCH_QUEUE_MAX)
self._example_queue = Queue.Queue(self.BATCH_QUEUE_MAX * self._hps.batch_size)?

这段代码突然无法运行，因为tensorflow变成了1.6版本？

使用scatter_nd将注意力分布投射到另一个分布上,实质上创建一个引用词汇表的分布.

indices = tf.stack((batch_nums, encoder_batch), axis=2)
shape = [batch_size, vocab_size]
attn_dists_projected = [tf.scatter_nd(indices, copy_distribution, shape) for copy_distribution in attn_dists] 

尝试使用大部分未定义维度的占位符运行此操作时,我遇到以下错误:

ValueError: The inner 0 dimensions of output.shape=[?,?] must match the inner 1
dimensions of updates.shape=[128,128,?]: Shapes must be equal rank, but are 0 and 1
for 'final_distribution/ScatterNd' (op: 'ScatterNd') with input shapes: 
[128,?,2], [128,128,?], [2].

这在seq2seq的上下文中,因此模型占位符的形状需要部分未定义.此外,我的数据批量大小不一致,这也需要不同的批量大小.

我正在尝试在 Keras 中使用 LSTM 构建 seq2seq 模型。目前正在研究英语到法语对数据集-10k 对（原始数据集有 147k 对）。训练完成后，在尝试预测给定输入序列的输出时，模型预测相同的输出，而不管输入序列如何。还为编码器和解码器使用单独的嵌入层。我观察到的是，预测的单词只不过是数据集中最常用的单词，它们按频率的降序显示。例如：“我认识你”、“我们可以去吗？”、“跳出它”——对于所有这些输入序列，输出是——“je suis en train”（所有三个输出相同）。

任何人都可以帮助我，模型表现得像这样的原因可能是什么。我错过了一些基本的东西吗？

我尝试使用 batchsize=32, epoch=50,maxinp=8, maxout=8, embeddingsize=100 跟随。

    encoder_inputs = Input(shape=(None, GLOVE_EMBEDDING_SIZE), name='encoder_inputs')
    encoder_lstm1 = LSTM(units=HIDDEN_UNITS, return_state=True, name="encoder_lstm1" , stateful=False, dropout=0.2)
    encoder_outputs, encoder_state_h, encoder_state_c = encoder_lstm1(encoder_inputs)

    encoder_states = [encoder_state_h, encoder_state_c]

    decoder_inputs = Input(shape=(None, GLOVE_EMBEDDING_SIZE), name='decoder_inputs')
    decoder_lstm = LSTM(units=HIDDEN_UNITS, return_sequences=True, return_state=True, stateful=False, 
                        name='decoder_lstm', dropout=0.2)
    decoder_outputs, _, _ = decoder_lstm(decoder_inputs, initial_state=encoder_states)
    decoder_dense = Dense(self.num_decoder_tokens, activation='softmax', name='decoder_dense')
    decoder_outputs = decoder_dense(decoder_outputs)

    self.model = Model([encoder_inputs, decoder_inputs], decoder_outputs)
    print(self.model.summary())

    self.model.compile(optimizer='rmsprop', loss='categorical_crossentropy')

    Xtrain, Xtest, Ytrain, …

我正在使用NMT创建在康奈尔电影对话语料库上受过训练的聊天机器人。

我的代码部分来自https://github.com/bshao001/ChatLearner和https://github.com/chiphuyen/stanford-tensorflow-tutorials/tree/master/assignments/chatbot

在训练过程中，我打印了从批处理中馈送到解码器的随机输出答案，以及我的模型预测观察到学习进度的相应答案。

我的问题：仅经过约4次训练，该模型就学会了在<\s>每个时间步输出EOS令牌（）。即使训练继续进行，它也始终将其输出作为其响应（由logits的argmax确定）。该模型偶尔会偶尔输出一系列周期作为其答案。

我还在训练过程中打印了前10个logit值（不仅是argmax），以查看其中是否存在正确的单词，但这似乎是在预测词汇中最常见的单词（例如i，you，？，。 ）。在培训期间，即使是前10个字词也没有太大变化。

我已经确保正确计算编码器和解码器的输入序列长度，并相应地添加了SOS（<s>）和EOS（也用于填充）令牌。我还在损失计算中执行屏蔽。

这是一个示例输出：

训练迭代1：

Decoder Input: <s> sure . sure . <\s> <\s> <\s> <\s> <\s> <\s> <\s> 
<\s> <\s>
Predicted Answer: wildlife bakery mentality mentality administration 
administration winston winston winston magazines magazines magazines 
magazines

...

训练迭代4：

Decoder Input: <s> i guess i had it coming . let us call it settled . 
<\s> <\s> <\s> <\s> <\s>
Predicted Answer: <\s> …

我目前正在尝试预测客户在下一个时间段内可能购买的下一个商品序列。以下示例仅用于说明目的（我的实际数据集有大约600万个客户ID和5000种不同的产品）

我当前的数据如下所示：

date  customer_nbr  products_bought
201701  123 ["product_1","product_5","product_15"]
201704  123 ["product_4","product_10","product_11"]
201721  123 ["product_1","product_6"]
201713  456 ["product_7","sproduct_11","product_12","product_15"]
201714  456 ["product_1","product_3"]
201721  456 ["product_4","product_9","product_10","product_13","product_15"]

数据的频率按周。因此，customer_id 123在2017年的第一周购买了商品“ product_1”，“ product_5”和“ product_15”（因此，给定年份最多有52周）。滞后获取我的输入变量后，我的最终数据帧如下所示：

date  customer_nbr  products_bought_last_period   products_bought
201704  123 ["product_1","product_5","product_15"]  ["product_4","product_10","product_11"]
201721  123 ["product_4","product_10","product_11"]  ["product_1","product_6"]
201714  456 ["product_7","sproduct_11","product_12","product_15"]   ["product_1","product_3"]
201721  456 ["product_1","product_3"]  
["product_4","product_9","product_10","product_13","product_15"]

因此，对于我的seq2seq模型，我想预测客户使用来购买日期为201721的产品的顺序products_bought_last_period，因此这products_bought_last_period是我的输入，products_bought现在是我的目标变量。然后，我对产品ID进行编码，products_bought_last_period并products_bought在数据框中填充和数组（基于具有最多产品的数组）。之后，我将所有内容都转换为np.arrays。最后，我的实际数据集中的产品总数为5000，因此我进行设置total_nbr_of_products = 5000并尝试执行以下操作：

train = df[df['date'] < 201721].set_index('date')
test = df[df['date'] >= 201721].set_index('date')
X = train["products_bought_last_period"].copy()  
X_test = test["products_bought_last_period"].copy()


y …

我在 TensorFlow 1.0 中有以下代码。我尝试使用 tf_upgrade_v2 脚本将其迁移到 TensorFlow 2.0。然而，在tf-2紧凑版本中没有找到等效的功能。

建议我使用tensorflow_addons。但是，我在 tf_addons 模块中没有看到等效的注意力解码器。请指导我。

decoder_outputs,decoder_state = tf.contrib.legacy_seq2seq.attention_decoder(
            decoder_inputs = decoder_inputs,
            initial_state = encoder_state,
            attention_states = encoder_outputs,
            cell = cell,
            output_size = word_embedding_dim,
            loop_function = None if mode=='pretrain' else feed_prev_loop,
            scope = scope
        )

tf 1.0代码的链接在这里： https://github.com/yaushian/CycleGAN-sentiment-transfer/blob/master/lib/seq2seq.py