我想为 Deeplab v3 添加自定义损失，它不仅适用于热编码标签，而且适用于显着性预测。因此，您在下面看到的不是 Deeplab 损失实现：

label = tf.to_int32(label > 0.2)
one_hot_labels = slim.one_hot_encoding(label, num_classes, on_value=1.0, off_value=0.0)
tf.losses.softmax_cross_entropy(one_hot_labels, logits)

我使用了这个实现：

softmax = tf.log(tf.nn.softmax(logits))
cross_entropy = -tf.reduce_sum(label*softmax, reduction_indices=[1])
tf.losses.add_loss(tf.reduce_mean(cross_entropy))

用 5 张图像训练了大约 1000 个 epoch 并得到了这个结果：

• 输入带填充的简化图像 - https://i.stack.imgur.com/07GsL.png
• 真实标签 - https://i.stack.imgur.com/ttEZi.png
• 自定义损失结果]( https://i.stack.imgur.com/cNooX.png
• 使用一个热编码结果的交叉熵 - https://i.stack.imgur.com/LEhl3.png

此外，尝试了几种学习率，但它不会改变自定义损失的结果。

背景

我有一个带有 5 个标签的多标签分类问题（例如[1 0 1 1 0]）。因此，我希望我的模型在固定召回、精确召回 AUC 或 ROC AUC 等指标上有所改进。

使用binary_crossentropy与我想要优化的性能测量没有直接关系的损失函数（例如）是没有意义的。因此，我想使用 TensorFlowglobal_objectives.recall_at_precision_loss()或类似的作为损失函数。

• 相关GitHub：https : //github.com/tensorflow/models/tree/master/research/global_objectives
• 相关论文（Scalable Learning of Non-Decomposable Objectives）：https : //arxiv.org/abs/1608.04802

不是公制的

我不是在寻找实现tf.metrics. 我已经在以下方面取得了成功：https : //stackoverflow.com/a/50566908/3399066

问题

我认为我的问题可以分为两个问题：

1. 如何使用global_objectives.recall_at_precision_loss()或类似？
2. 如何在带有 TF 后端的 Keras 模型中使用它？

问题一

全局目标GitHub页面loss_layers_example.py上有一个文件（同上）。但是，由于我对TF没有太多经验，所以我不太了解如何使用它。另外，谷歌搜索TensorFlow recall_at_precision_loss example或TensorFlow Global objectives example不会给我任何更清晰的例子。

如何global_objectives.recall_at_precision_loss()在简单的 TF 示例中使用？

问题二

会像（在 Keras 中）：model.compile(loss = ??.recall_at_precision_loss, ...)就足够了吗？我的感觉告诉我它比这更复杂，因为在 …

在我的模型中，隐藏层的输出，即“编码”，有两个通道（例如形状：[none, 128, 128, 2]）。我希望在损失函数中在这两个通道之间添加SSIM：

损失 = ssim（输入，输出）+ theta*ssim（编码（通道 1），编码（通道 2））。

我怎么能实现这个？以下是我的模型的架构。

def structural_similarity_index(y_true, y_pred):
    loss = 1 - tf.image.ssim(y_true, y_pred, max_val=1.0) 
    return loss

def mymodel():
    input_img = Input(shape=(256, 256, 1))

    # encoder
    x = Conv2D(4, (3, 3), activation='relu', padding='same')(input_img)
    x = MaxPooling2D((2, 2), padding='same')(x)
    encoded = Conv2D(2, (3, 3), activation='relu', padding='same', name='encoder')(x)

    # decoder    
    x = Conv2D(4, (3, 3), activation='relu', padding='same')(encoded)
    x = UpSampling2D((2, 2))(x)
    decoded = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(x)

    autoencoder = Model(input_img, decoded)    
    autoencoder.compile(optimizer = 'adadelta', loss …

我很好奇损失函数是否可以在 keras 中实现中间层输出，而无需设计模型以将中间层作为输出提供。我已经看到一个解决方案可以是重新设计架构以在最终预测之外返回中间层并将其用作解决方法，但我不清楚是否可以直接从损失函数访问层输出

我正在尝试用三个类来实现一个分类问题：'A'、'B' 和 'C'，我想在我的模型损失函数中对不同类型的错误分类进行惩罚（有点像加权交叉熵）。类权重不适合，因为它适用于属于该类的所有数据。例如，与被错误分类为“A”相比，真实标签“B”被错误分类为“C”应该具有更高的损失。重量表如下：

   A  B  C  
A  1  1  1  
B  1  1  1.2 
C  1  1  1    

在当前的 categorical_crossentropy 损失中，对于真正的“B”类，如果我将预测 softmax 设为

0.5 0.4 0.1  vs 0.1 0.4 0.5 

categorical_crossentropy 将相同。'B' 是否被误分类为 A 或 C 并不重要。与第一个相比，我想增加第二个预测 softmax 的损失。

我试过https://github.com/keras-team/keras/issues/2115 但没有任何代码适用于 Keras v2。任何我可以直接将权重矩阵强制执行到 Keras 损失函数的帮助都将受到高度赞赏。

我有一个多标签问题，我正在尝试在 TensorFlow 中将排名损失实现为自定义损失。( https://arxiv.org/pdf/1312.4894.pdf )

我制作了一个带有最终 Sigmoid 激活层的简单 CNN，以便为每个类提供独立的分布。
数学公式将标签分为两组，正组和负组。

我的问题是，实施它的正确方法是什么？

def ranking_loss(y_true, y_pred):    
    pos = tf.where(tf.equal(y_true, 1), y_pred, tf.zeros_like(y_pred))
    neg = tf.where(tf.equal(y_true, 0), y_pred, tf.zeros_like(y_pred))

    loss = tf.maximum(1.0 - tf.math.reduce_sum(pos) + tf.math.reduce_sum(neg), 0.0)
    return tf.math.reduce_sum(loss)

结果是对于每个样本，来自正类和负类的激活分数被独立相加。

tr = [1, 0, 0, 1]
pr = [0, 0.6, 0.55, 0.9]
t =  tf.constant([tr])
p =  tf.constant([pr])

print(ranking_loss(t, p))

tf.Tensor([[0.  0.  0.  0.9]], shape=(1, 4), dtype=float32) #Pos
tf.Tensor([[0.   0.6  0.55 0.  ]], shape=(1, 4), dtype=float32) #Neg
tf.Tensor(1.2500001, shape=(), dtype=float32) #loss

CNN 的精确度、召回率和 …

Epoch: 1    Training Loss: 0.816370     Validation Loss: 0.696534
Validation loss decreased (inf --> 0.696534).  Saving model ...
Epoch: 2    Training Loss: 0.507756     Validation Loss: 0.594713
Validation loss decreased (0.696534 --> 0.594713).  Saving model ...
Epoch: 3    Training Loss: 0.216438     Validation Loss: 1.119294
Epoch: 4    Training Loss: 0.191799     Validation Loss: 0.801231
Epoch: 5    Training Loss: 0.111334     Validation Loss: 1.753786
Epoch: 6    Training Loss: 0.064309     Validation Loss: 1.348847
Epoch: 7    Training Loss: 0.058158     Validation Loss: 1.839139
Epoch: 8    Training Loss: 0.015489     Validation …

我有一个生成器函数，它在某些图像目录上无限循环并输出 3 元组的形式

[img1, img2], label, weight

其中img1和img2是batch_size x M x N x 3张量，并且label和weight各自batch_size的X 1张量。

我fit_generator在用 Keras 训练模型时向函数提供了这个生成器。

对于这个模型，我有一个自定义的余弦对比损失函数，

def cosine_constrastive_loss(y_true, y_pred):
    cosine_distance = 1 - y_pred
    margin = 0.9
    cdist = y_true * y_pred + (1 - y_true) * keras.backend.maximum(margin - y_pred, 0.0)
    return keras.backend.mean(cdist)

从结构上讲，我的模型一切正常。没有错误，它正在按预期消耗来自生成器的输入和标签。

但现在我正在寻求直接使用每个批次的权重参数，并cosine_contrastive_loss根据特定于样本的权重在内部执行一些自定义逻辑。

如何在执行损失函数时从一批样本的结构中访问此参数？

请注意，由于它是一个无限循环的生成器，因此无法预先计算权重或动态计算它们以将权重归入损失函数或生成它们。

它们具有一致地产生具有所产生的样品，并确有定制逻辑在我的数据生成器，从性能动态地确定的权重img1，img2并且label在此刻它们用于分批生成。

我有一个图像分割问题，我必须在 TensorFlow 2 中解决。

特别是我有一个由航拍图像与各自的面具配对组成的训练集。在面具中，地形为黑色，建筑物为白色。目的是预测测试集中图像的掩码。

我使用带有最终 Conv2DTranspose 的 UNet，带有 1 个过滤器和一个 sigmoid 激活函数。对最终 sigmoid 层的输出按以下方式进行预测：如果 y_pred>0.5，则为建筑物，否则为背景。

我想实现一个骰子的损失，所以我写了下面的函数

def dice_loss(y_true, y_pred):
    print("[dice_loss] y_pred=",y_pred,"y_true=",y_true)
    y_pred = tf.cast(y_pred > 0.5, tf.float32)
    y_true = tf.cast(y_true, tf.float32)
    numerator = 2 * tf.reduce_sum(y_true * y_pred)
    denominator = tf.reduce_sum(y_true + y_pred)

    return 1 - numerator / denominator

我通过以下方式传递给 TensorFlow：

loss = dice_loss
optimizer = tf.keras.optimizers.Adam(learning_rate=config.learning_rate)
metrics = [my_IoU, 'acc']
model.compile(optimizer=optimizer, loss=loss, metrics=metrics)

但在训练时 TensorFlow 抛出以下错误：

ValueError：没有为任何变量提供梯度：

我正在编写一个自定义损失函数，需要计算每组预测值的比率。作为一个简化的例子，这里是我的数据和模型代码的样子：

def main():
    df = pd.DataFrame(columns=["feature_1", "feature_2", "condition_1", "condition_2", "label"],
                      data=[[5, 10, "a", "1", 0],
                            [30, 20, "a", "1", 1],
                            [50, 40, "a", "1", 0],
                            [15, 20, "a", "2", 0],
                            [25, 30, "b", "2", 1],
                            [35, 40, "b", "1", 0],
                            [10, 80, "b", "1", 1]])
    features = ["feature_1", "feature_2"]
    conds_and_label = ["condition_1", "condition_2", "label"]
    X = df[features]
    Y = df[conds_and_label]
    model = my_model(input_shape=len(features))
    model.fit(X, Y, epochs=10, batch_size=128)
    model.evaluate(X, Y)


def custom_loss(conditions, y_pred):  # this is what I need …