Python Tensorflow BahdanaauAttention-Layer内存层需要1个输入，但收到2个输入张量

张量流：1.12

我正在使用

双向\u动态\n

。我将

encoder\u输出
写入BahdanaauAttention的内存选项（在tensorflow网站上推荐），但它抛出了一个错误：

ValueError:Layer memory\u Layer需要1个输入，但收到2个
输入张量。收到的输入：tf.张量
“双向/fw/fw/transpose_1:0”形状=（？，？，512）
dtype=float32，tf.张量“反转序列：0”形状=（？，？，512）
dtype=32]

def model_inputs（）：
inputs=tf.placeholder（tf.int32，[None，None]，name='input'）
targets=tf.placeholder（tf.int32，[None，None]，name='target'）
lr=tf.placeholder（tf.float32，name='learning\u rate'）
keep_prob=tf.placeholder（tf.float32，name='keep_prob'）
返回输入、目标、lr、keep_prob
def预处理目标（目标、字2int、批量大小）：
左侧=tf.填充（[批次大小，1]，字2int[“”]）
右侧=tf.跨步切片（目标，[0,0]，[batch\u size，-1]，[1,1]）
预处理的目标=tf.concat（[左侧，右侧]，1）
返回预处理的目标
#编码器
def编码器（rnn输入、rnn大小、层数、保持概率、序列长度）：
lstm=tf.contrib.rnn.BasicLSTMCell（rnn\u大小）
lstm\u dropout=tf.contrib.rnn.dropoutrapper（lstm，输入保持保持保持保持保持）
编码器单元=tf.contrib.rnn.multirncell（[lstm\u dropout]*num\u层）
全局编码器输出，编码器状态
编码器输出，编码器状态=tf.nn.双向动态（小区fw=编码器小区，
cell_bw=编码器_cell，
序列长度=序列长度，
输入=rnn_输入，
dtype=tf.float32）
返回编码器状态
#解码训练集
def解码训练集（编码器状态、解码器单元、解码器嵌入输入、序列长度、解码范围、输出功能、保持概率、批量大小）：
#注意\u states=tf.zeros（[batch\u size，1，解码器\u cell.output\u size]）
注意\u机制=tf.contrib.seq2seq.bahdanaauattention（num\u单元=解码器\u单元.output\u大小，内存=编码器\u输出，normalize=False）

我能做什么？
完整的堆栈跟踪可能有助于查看错误的来源。您好@iga我已经编辑过了，仅此而已。谢谢。我仍然看不到包含所有导致错误的调用的完整堆栈跟踪。我认为注意机制的记忆层在每一步只希望编码层输出一个张量（就像只有一个定向编码器的自然情况一样）。不知何故，我们要么同时关注正向和反向输出，要么提供一个具有正向和反向输出特征的张量。完整的堆栈跟踪可能有助于了解错误的来源。嗨@iga我编辑过，仅此而已。谢谢。我仍然看不到包含所有导致错误的调用的完整堆栈跟踪。我认为注意机制的记忆层在每一步只希望编码层输出一个张量（就像只有一个定向编码器的自然情况一样）。不知何故，要么我们必须将前向输出和后向输出结合起来，要么提供一个具有前向输出和后向输出特征的张量。
def model_inputs():
    inputs = tf.placeholder(tf.int32, [None, None], name='input')
    targets = tf.placeholder(tf.int32, [None, None], name='target')
    lr = tf.placeholder(tf.float32, name='learning_rate')
    keep_prob = tf.placeholder(tf.float32, name='keep_prob')
    return inputs, targets, lr, keep_prob

def preprocess_targets(targets, word2int, batch_size):
    left_side = tf.fill([batch_size, 1], word2int['<SOS>'])
    right_side = tf.strided_slice(targets, [0,0], [batch_size, -1], [1,1])
    preprocessed_targets = tf.concat([left_side, right_side], 1)
    return preprocessed_targets

#Encoder RNN
def encoder_rnn(rnn_inputs, rnn_size, num_layers, keep_prob, sequence_lenght):
    lstm = tf.contrib.rnn.BasicLSTMCell(rnn_size)
    lstm_dropout = tf.contrib.rnn.DropoutWrapper(lstm, input_keep_prob = keep_prob)
    encoder_cell = tf.contrib.rnn.MultiRNNCell([lstm_dropout] * num_layers)
    global encoder_output, encoder_state
    encoder_output, encoder_state = tf.nn.bidirectional_dynamic_rnn(cell_fw = encoder_cell,
                                                                    cell_bw = encoder_cell,
                                                                    sequence_length = sequence_length,
                                                                    inputs = rnn_inputs,
                                                                    dtype = tf.float32)

    return encoder_state



#Decoding training set
def decode_training_set(encoder_state, decoder_cell, decoder_embedded_input, sequence_lenght, decoding_scope, output_function, keep_prob, batch_size):
    #attention_states = tf.zeros([batch_size, 1, decoder_cell.output_size])
    attention_mechanism = tf.contrib.seq2seq.BahdanauAttention(num_units = decoder_cell.output_size, memory = encoder_output, normalize=False)