Keras

Question

我创建了以下 Keras 自定义模型：

import tensorflow as tf
from tensorflow.keras.layers import Layer

class MyModel(tf.keras.Model):
    def __init__(self, num_classes):
        super(MyModel, self).__init__()
        self.dense_layer = tf.keras.layers.Dense(num_classes,activation='softmax')
        self.lambda_layer = tf.keras.layers.Lambda(lambda x: tf.math.argmax(x, axis=-1))

    
    def call(self, inputs):
        x = self.dense_layer(inputs)
        x = self.lambda_layer(x)
        return x

    # A convenient way to get model summary 
    # and plot in subclassed api
    def build_graph(self, raw_shape):
        x = tf.keras.layers.Input(shape=(raw_shape))
        return tf.keras.Model(inputs=[x], 
                              outputs=self.call(x))

任务是多classclass化的。模型由具有 softmax 激活的密集层和作为 post 处理单元的 lambda 层组成，该处理单元将密集输出向量转换为单个值（预测 class）。

训练目标是一个单热编码矩阵，如下所示：

[
   [0,0,0,0,1]
   [0,0,1,0,0]
   [0,0,0,1,0]
   [0,0,0,0,1]
]

如果我可以在密集层上定义一个 categorical_crossentropy 损失并忽略 lambda 层，同时仍然保持功能并在我调用 model.predict(x) 时输出单个值，那就太好了。

请注意
我的工作区环境不允许我使用@alonetogether 优秀答案所建议的自定义训练循环。

Answer 1

您可以尝试使用自定义训练循环，这在我看来非常简单：

import tensorflow as tf
from tensorflow.keras.layers import Layer

class MyModel(tf.keras.Model):
    def __init__(self, num_classes):
        super(MyModel, self).__init__()
        self.dense_layer = tf.keras.layers.Dense(num_classes,activation='softmax')
        self.lambda_layer = tf.keras.layers.Lambda(lambda x: tf.math.argmax(x, axis=-1))

    
    def call(self, inputs):
        x = self.dense_layer(inputs)
        x = self.lambda_layer(x)
        return x

    # A convenient way to get model summary 
    # and plot in subclassed api
    def build_graph(self, raw_shape):
        x = tf.keras.layers.Input(shape=(raw_shape))
        return tf.keras.Model(inputs=[x], 
                              outputs=self.call(x))
        
n_classes = 5
model = MyModel(n_classes)
labels = tf.keras.utils.to_categorical(tf.random.uniform((50, 1), maxval=5, dtype=tf.int32))
train_dataset = tf.data.Dataset.from_tensor_slices((tf.random.normal((50, 1)), labels)).batch(2)
optimizer = tf.keras.optimizers.Adam()
loss_fn = tf.keras.losses.CategoricalCrossentropy()
epochs = 2
for epoch in range(epochs):
    print("\nStart of epoch %d" % (epoch,))
    for step, (x_batch_train, y_batch_train) in enumerate(train_dataset):
        with tf.GradientTape() as tape:
            logits = model.layers[0](x_batch_train)
            loss_value = loss_fn(y_batch_train, logits)

        grads = tape.gradient(loss_value, model.trainable_weights)
        optimizer.apply_gradients(zip(grads, model.trainable_weights))

和预测：

print(model.predict(tf.random.normal((1, 1))))

[3]

Answer 2

我认为有一个 Model.predict_classes 函数可以替代对 lambda 层的需求。但如果它不起作用：

如果不使用以下技巧之一，似乎没有办法做到这一点：

两个输入（一个是真实值Y）
两个输出
两个模型

我坚信没有其他解决方法。因此，我相信“双模型”版本最适合您的情况，您似乎“需要”具有单输入、单输出和 fit.

的模型

那么我会这样做：

inputs = tf.keras.layers.Input(input_shape_without_batch_size)    
loss_outputs = tf.keras.layers.Dense(num_classes,activation='softmax')(inputs)
final_outputs = tf.keras.layers.Lambda(lambda x: tf.math.argmax(x, axis=-1))(loss_outputs)

training_model = tf.keras.models.Model(inputs, loss_outputs)
final_model = tf.keras.models.Model(inputs, final_outputs)

training_model.compile(.....)
training_model.fit(....)

results = final_model.predict(...)

Keras - 在忽略最后一层的同时向中间层添加损失

Keras - Adding loss to intermediate layer while ignoring the last layer

python

machine-learning

tensorflow