我对tensorflow有些陌生，特别是手工培训，需要一些帮助。
我创建了三个自动编码器，每个自动编码器学习RGB图像的单个通道
现在我尝试获得自动编码器的编码输出，然后传递到另一个自动编码器进行训练。由于我有一些GPU内存问题，我被迫手动训练。问题是，现在我需要创建批处理训练，但由于中间层的输出是一个Tensor对象，我无法获得值。
自动编码器

def build_autoencoder():
input_img = keras.Input(shape=(256, 256,1))
x = Conv2D(32, kernel_size = (3,3), activation=LeakyReLU(alpha=0.03), padding = 'same')(input_img)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(16, kernel_size = (3,3), activation=LeakyReLU(alpha=0.03), padding = 'same')(x)
x = Conv2D(8, kernel_size = (3,3), activation=LeakyReLU(alpha=0.03), padding = 'same')(x)
encoded = MaxPooling2D((2, 2), padding='same', name='encoded')(x)
x = Conv2D(8, (3, 3), activation=LeakyReLU(alpha=0.03), padding='same')(encoded)
x = Conv2D(16, (3, 3), activation=LeakyReLU(alpha=0.03), padding='same')(x)
x = UpSampling2D((2, 2))(x)
x = Conv2D(32, (3, 3), activation=LeakyReLU(alpha=0.03), padding='same')(x)
decoded = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(x)

autoencoder = keras.Model(inputs=input_img, outputs=decoded)
autoencoder.compile(optimizer=Nadam(learning_rate=0.001), loss=tf.keras.losses.MeanSquaredError())
return autoencoder

我如何获得编码输出并将它们连接起来

encoded_red = model_red.get_layer('encoded').output
encoded_green = model_green.get_layer('encoded').output
encoded_blue = model_blue.get_layer('encoded').output
concatenated_encode = tf.keras.layers.Concatenate(axis=-1)([encoded_red, encoded_green, encoded_blue])
model_encoder_generator = build_encoder_generator(concatenated_encode)

对于训练，我尝试这种方法来训练，因为它在训练第一个自动编码器时起作用。现在的问题是

batch_size = 16
epochs=30

num_samples = len(y_train)
num_batches = num_samples // batch_size
optimizer = tf.keras.optimizers.Nadam(learning_rate=0.001)

batch_size = 16
epochs = 30

num_samples = len(y_train)
num_batches = num_samples // batch_size
concatenated_encode = tf.keras.layers.Concatenate(axis=-1)([encoded_red, encoded_green, encoded_blue])
optimizer = tf.keras.optimizers.Nadam(learning_rate=0.001)

history_encoder_generator = []
for epoch in range(epochs):
    epoch_loss = 0.0
    for batch_idx in range(0, num_samples, batch_size):
        batch_x = concatenated_encode[batch_idx : batch_idx + batch_size]
        batch_y = y_train[batch_idx : batch_idx + batch_size]

        with tf.GradientTape() as tape:
            predictions = model_encoder_generator(batch_x)
            loss = tf.keras.losses.mean_squared_error(batch_y, predictions)
        gradients = tape.gradient(loss, model_encoder_generator.trainable_variables)
        optimizer.apply_gradients(zip(gradients, model_encoder_generator.trainable_variables))

        batch_mean_loss = tf.reduce_mean(loss)
        epoch_loss += batch_mean_loss
    avg_loss = epoch_loss / num_batches
    print("Epoch {}: Average Loss = {}".format(epoch + 1, avg_loss))
    history_encoder_generator.append(avg_loss)

但我得到了这个错误。如何获得编码的输出层，以便将它们传递到另一个网络？

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[116], line 12
     10     predictions = model_encoder_generator(batch_x)
     11     loss = tf.keras.losses.mean_squared_error(batch_y, predictions)
---> 12 gradients = tape.gradient(loss, model_encoder_generator.trainable_variables)
     13 optimizer.apply_gradients(zip(gradients, model_encoder_generator.trainable_variables))
     15 batch_mean_loss = tf.reduce_mean(loss)

File ~\anaconda3\envs\test\lib\site-packages\tensorflow\python\eager\backprop.py:1113, in GradientTape.gradient(self, target, sources, output_gradients, unconnected_gradients)
   1107   output_gradients = (
   1108       composite_tensor_gradient.get_flat_tensors_for_gradients(
   1109           output_gradients))
   1110   output_gradients = [None if x is None else ops.convert_to_tensor(x)
   1111                       for x in output_gradients]
-> 1113 flat_grad = imperative_grad.imperative_grad(
   1114     self._tape,
   1115     flat_targets,
   1116     flat_sources,
   1117     output_gradients=output_gradients,
   1118     sources_raw=flat_sources_raw,
   1119     unconnected_gradients=unconnected_gradients)
   1121 if not self._persistent:
   1122   # Keep track of watched variables before setting tape to None
   1123   self._watched_variables = self._tape.watched_variables()

File ~\anaconda3\envs\test\lib\site-packages\tensorflow\python\eager\imperative_grad.py:67, in imperative_grad(tape, target, sources, output_gradients, sources_raw, unconnected_gradients)
     63 except ValueError:
     64   raise ValueError(
     65       "Unknown value for unconnected_gradients: %r" % unconnected_gradients)
---> 67 return pywrap_tfe.TFE_Py_TapeGradient(
     68     tape._tape,  # pylint: disable=protected-access
     69     target,
     70     sources,
     71     output_gradients,
     72     sources_raw,
     73     compat.as_str(unconnected_gradients.value))

AttributeError: 'KerasTensor' object has no attribute '_id'

我试过转换成numpy数组
提前感谢！