如何用Keras函数式API构建仅首尾层循环连接的自定义循环模型？

要实现你需求的这种仅将最后一层的最终输出作为下一时间步第一层输入的循环结构，SimpleRNN确实不适用——它会在每层内部维护递归状态，而不是跨层传递单一的反馈连接。最简洁且符合你用Dense层作为组件的方案，是自定义RNN Cell来完全控制循环逻辑。

方案一：自定义RNN Cell（推荐，高效训练/推理） #

通过继承AbstractRNNCell，你可以定义自己的循环状态传递规则，核心就是把上一步的模型输出作为下一时间步的状态，与当前真实输入拼接后送入多层Dense。

完整代码实现 #

import tensorflow as tf
from tensorflow.keras.layers import Dense, Input, RNN
from tensorflow.keras.models import Model

class CustomLoopCell(tf.keras.layers.AbstractRNNCell):
    def __init__(self, output_units=5, dense_hidden_units=20, **kwargs):
        self.output_units = output_units
        self.dense_hidden_units = dense_hidden_units
        super().__init__(**kwargs)
        
        # 定义你需要的多层Dense结构
        self.dense1 = Dense(dense_hidden_units, activation='relu')
        self.dense2 = Dense(dense_hidden_units, activation='relu')
        self.final_dense = Dense(output_units)

    @property
    def state_size(self):
        # 循环状态就是上一步的输出，维度与最终输出一致（5维）
        return self.output_units

    def call(self, inputs, states):
        # inputs：当前时间步的真实输入（shape: (batch_size, 5)）
        # states：上一步模型的输出（shape: (batch_size, 5)）
        prev_output = states[0]
        
        # 拼接当前输入与上一步输出，得到10维输入（对应你说的5维真实输入+5维前一步输出）
        concat_input = tf.concat([inputs, prev_output], axis=-1)
        
        # 经过多层Dense计算当前输出
        x = self.dense1(concat_input)
        x = self.dense2(x)
        current_output = self.final_dense(x)
        
        # 返回当前输出，同时将其作为下一时间步的状态
        return current_output, [current_output]

# 构建完整模型
# 输入1：序列数据（shape: (batch_size, seq_len, 5)，seq_len可以是None表示可变长度）
input_sequence = Input(shape=(None, 5), name='input_sequence')
# 输入2：初始状态（第一个时间步没有前序输出，用初始状态替代，shape: (batch_size, 5)）
initial_state = Input(shape=(5,), name='initial_state')

# 用RNN层包装自定义Cell，return_sequences=True返回每个时间步的输出
rnn_layer = RNN(CustomLoopCell(output_units=5, dense_hidden_units=20), return_sequences=True)
output_sequence = rnn_layer(input_sequence, initial_state=initial_state)

# 定义模型
model = Model(inputs=[input_sequence, initial_state], outputs=output_sequence)
model.summary()

关键逻辑说明 #

1. 状态定义：state_size指定循环状态的维度为最终输出的5维，也就是上一步的模型输出。
2. 输入拼接：每个时间步将当前真实输入（5维）与上一步输出（5维）拼接，作为多层Dense的输入。
3. 循环传递：当前时间步的输出直接作为下一时间步的状态，完全符合你“仅最后一层输出反馈到第一层”的需求。

方案二：单步模型循环调用（适合简单推理场景） #

如果不需要高效的批量训练，也可以先构建单步计算的模型，然后在推理时手动循环处理每个时间步：

from tensorflow.keras.layers import Dense, Input
from tensorflow.keras.models import Model
import tensorflow as tf

# 构建单步计算模型：输入是当前真实输入+上一步输出，输出是当前步结果
def build_single_step_model():
    current_input = Input(shape=(5,))
    prev_output = Input(shape=(5,))
    concat_input = tf.concat([current_input, prev_output], axis=-1)
    x = Dense(20, activation='relu')(concat_input)
    x = Dense(20, activation='relu')(x)
    current_output = Dense(5)(x)
    return Model(inputs=[current_input, prev_output], outputs=current_output)

# 示例：处理长度为3的序列
single_step_model = build_single_step_model()
batch_size = 2
seq_len = 3

# 初始状态用全零张量（第一个时间步没有前序输出）
current_output = tf.zeros((batch_size, 5))
# 生成模拟序列输入
sequence_inputs = tf.random.normal((batch_size, seq_len, 5))

# 循环处理每个时间步
outputs = []
for t in range(seq_len):
    step_input = sequence_inputs[:, t, :]
    current_output = single_step_model([step_input, current_output])
    outputs.append(current_output)

# 将各时间步输出拼接成序列
output_sequence = tf.stack(outputs, axis=1)

这种方式的优点是逻辑直观，但训练时无法利用RNN的向量化优化，效率较低，适合小规模推理场景。

内容的提问来源于stack exchange，提问作者poldpold