2

我正在尝试向我的模型添加自定义损失，并且需要引用目标变量来执行此操作。例如

model = Model(inputs=[x1, x2, x3], outputs=[y1,y2,y3])
mse = tf.keras.losses.MeanSquaredError()
model.add_loss(mse(x1, dec_x1))

在这里，我在一个输入变量和同一变量的编码然后解码版本之间添加了损失。但我也希望能够添加一个取决于 y 变量（不是预测的 y1、y2、y3）的基本事实的损失，即想象y1_true然后添加一个损失：

# Code to make Y1 which depends on x1, x2, x3
model.add_loss(mse(Y1, y1_true))

但是我如何y1_true在 keras 中访问？

4

1 回答 1

1

不幸的是，该add_loss函数无法访问y1_true标签。此方法实际上是用于模型中的正则化损失：

在编写自定义层或子类模型的调用方法时，您可能想要计算在训练期间想要最小化的标量（例如正则化损失）。您可以使用 add_loss() 层方法来跟踪此类损失项。

有关更多信息，请参阅文档。我认为使用自定义训练循环会好得多，您可以直接访问所需的一切。这是一个简化的示例：

class Autoencoder(tf.keras.Model):
  def __init__(self, latent_dim):
    super(Autoencoder, self).__init__()

    self.latent_dim = latent_dim
    self.dense1 = tf.keras.layers.Dense(self.latent_dim, activation='relu')
    self.dense2 = tf.keras.layers.Dense(5, activation='relu')
    e_input1 = tf.keras.Input(shape=(5,))
    e_input2 = tf.keras.Input(shape=(5,))
    e_input3 = tf.keras.Input(shape=(5,))
    e_output1 = self.dense1(e_input1)
    e_output2 = self.dense1(e_input2)
    e_output3 = self.dense1(e_input3)

    self.encoder = tf.keras.Model([e_input1, e_input2, e_input3], [e_output1, e_output2, e_output3])

    d_input1 = tf.keras.Input(shape=(self.latent_dim,))
    d_input2 = tf.keras.Input(shape=(self.latent_dim,))
    d_input3 = tf.keras.Input(shape=(self.latent_dim,))

    d_output1 = self.dense2(d_input1)
    d_output2 = self.dense2(d_input2)
    d_output3 = self.dense2(d_input3)
    
    self.decoder = tf.keras.Model([d_input1, d_input2, d_input3], [d_output1, d_output2, d_output3])

  def encode(self, inputs):
    x1, x2, x3 = inputs
    return self.encoder([x1, x2, x3])
  
  def decode(self, inputs):
    x1, x2, x3 = inputs
    return self.decoder([x1, x2, x3])


latent_dim = 5 
autoencoder = Autoencoder(latent_dim) 
optimizer = tf.keras.optimizers.Adam()
mse = tf.keras.losses.MeanSquaredError()


your_train_dataset = tf.data.Dataset.from_tensor_slices((tf.random.normal((4, 5)), 
                                                         tf.random.normal((4, 5)), 
                                                         tf.random.normal((4, 5)), 
                                                         tf.random.normal((4, 5)),
                                                         tf.random.normal((4, 5)),
                                                         tf.random.normal((4, 5)))).batch(2)
epochs = 2
for epoch in range(epochs):
    for batch in your_train_dataset:
        x1_batch_train, x2_batch_train, x3_batch_train, y1_batch_train, y2_batch_train, y3_batch_train = batch
        with tf.GradientTape() as tape:
            enc_x1, enc_x2, enc_x1 = autoencoder.encode([x1_batch_train, x2_batch_train, x3_batch_train])
            dec_x1, dec_x2, dec_x1 = autoencoder.decode([enc_x1, enc_x2, enc_x1])

            loss1 = mse(x1_batch_train, enc_x1)
            loss2 = mse(x1_batch_train, dec_x1)
            loss3 = mse(dec_x1, y1_batch_train)
            #..... and so on.

            losses = loss1 + loss2 + loss3
            tf.print(losses)
        grads = tape.gradient(losses, autoencoder.trainable_weights)
        optimizer.apply_gradients(zip(grads, autoencoder.trainable_weights))
于 2021-10-29T07:35:47.280 回答