TensorFlow中针对两个不同输入复用MultiRNNCell的实现问题

Got it, let's break down the issue you're facing: your current code is creating two separate LSTM branches (with their own weights) for each input, and somehow their outputs are getting cross-connected—this almost always happens because you're initializing new LSTM layers every time you process an input, instead of reusing the same layer instances.

The core fix here is reusing the same LSTM layer objects for both inputs, so they share the exact same set of parameters. This way, TensorFlow/Keras won't create duplicate RNN structures, and you'll get the shared model behavior you want.

Let's start with what you're probably doing wrong (example) #

If your code looks something like this, you're creating new LSTM layers every time you process an input:

# ❌ Wrong: Creates separate LSTM layers for each input
def process_input(input_tensor):
    # New LSTM instances created every time this function runs
    x = tf.keras.layers.LSTM(64, return_sequences=True)(input_tensor)
    x = tf.keras.layers.LSTM(32)(x)
    return x

input1 = tf.keras.Input(shape=(timesteps, features))
input2 = tf.keras.Input(shape=(timesteps, features))

output1 = process_input(input1)
output2 = process_input(input2)

This code generates two completely independent LSTM stacks, which explains the weird TensorBoard visualization you're seeing.

Here's the correct approach (reuse layer instances) #

Define your LSTM layers once upfront, then use those same instances to process both inputs. This ensures weight sharing and a single, shared RNN structure.

Option 1: Functional API approach

# ✅ Correct: Pre-define LSTM layers, reuse them for both inputs
import tensorflow as tf
from tensorflow.keras import Input, layers, Model

# Define your multi-layer LSTM components ONCE
lstm_layer_1 = layers.LSTM(64, return_sequences=True, name="shared_lstm_1")
lstm_layer_2 = layers.LSTM(32, name="shared_lstm_2")

# Define your two inputs
input_1 = Input(shape=(timesteps, features), name="input_1")
input_2 = Input(shape=(timesteps, features), name="input_2")

# Process input 1 using the shared layers
x1 = lstm_layer_1(input_1)
output_1 = lstm_layer_2(x1)

# Process input 2 using the SAME shared layers
x2 = lstm_layer_1(input_2)
output_2 = lstm_layer_2(x2)

# Build the final model
model = Model(inputs=[input_1, input_2], outputs=[output_1, output_2])
model.summary()

Option 2: Custom Model Class approach

If you prefer using a subclassed Model, initialize your LSTM layers in the __init__ method, then reuse them in call:

# ✅ Correct: Subclassed Model with shared LSTM layers
class SharedMultiLSTM(tf.keras.Model):
    def __init__(self, lstm_units_1=64, lstm_units_2=32):
        super().__init__()
        # Initialize LSTM layers once during model creation
        self.lstm1 = layers.LSTM(lstm_units_1, return_sequences=True)
        self.lstm2 = layers.LSTM(lstm_units_2)
    
    def call(self, inputs):
        # Unpack your two inputs from the batch
        input1, input2 = inputs
        
        # Process first input with shared layers
        x1 = self.lstm1(input1)
        out1 = self.lstm2(x1)
        
        # Process second input with the SAME shared layers
        x2 = self.lstm1(input2)
        out2 = self.lstm2(x2)
        
        return [out1, out2]

# Usage example
timesteps = 10
features = 16
batch_size = 32

model = SharedMultiLSTM()
# Create dummy mini-batch inputs
input_batch1 = tf.random.normal((batch_size, timesteps, features))
input_batch2 = tf.random.normal((batch_size, timesteps, features))

# Get outputs for both inputs
output1, output2 = model([input_batch1, input_batch2])

Why this works #

By reusing the same lstm_layer_1 and lstm_layer_2 instances for both inputs, you're telling TensorFlow to use the exact same set of trainable weights for both processing paths. In TensorBoard, you'll now see a single set of LSTM layers, with both inputs feeding into them, and no cross-connected outputs.

After implementing this, you can proceed to process output1 and output2 however you need (different loss functions, post-processing, etc.) without worrying about duplicate RNN structures.

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