标签: loss-function

我正在尝试创建一个简单的加权损失函数.

比方说,我的输入尺寸为100*5,输出尺寸也为100*5.我也有一个相同尺寸的重量矩阵.

类似于以下内容:

import numpy as np
train_X = np.random.randn(100, 5)
train_Y = np.random.randn(100, 5)*0.01 + train_X

weights = np.random.randn(*train_X.shape)

定义自定义丢失功能

def custom_loss_1(y_true, y_pred):
    return K.mean(K.abs(y_true-y_pred)*weights)

定义模型

from keras.layers import Dense, Input
from keras import Model
import keras.backend as K

input_layer = Input(shape=(5,))
out = Dense(5)(input_layer)
model = Model(input_layer, out)

使用现有指标进行测试工作正常

model.compile('adam','mean_absolute_error')
model.fit(train_X, train_Y, epochs=1)

使用我们的自定义丢失功能进行测试不起作用

model.compile('adam',custom_loss_1)
model.fit(train_X, train_Y, epochs=10)

它给出了以下堆栈跟踪:

InvalidArgumentError (see above for traceback): Incompatible shapes: [32,5] vs. [100,5]
 [[Node: loss_9/dense_8_loss/mul = Mul[T=DT_FLOAT, _device="/job:localhost/replica:0/task:0/device:CPU:0"](loss_9/dense_8_loss/Abs, loss_9/dense_8_loss/mul/y)]]

32号来自哪里？

使用权重测试损失函数作为Keras张量

def …

我试图找出如何使用Generative Adversarial Networks的数据集标签信息.我试图使用可在此处找到的条件GAN的以下实现.我的数据集包含两个不同的图像域(真实对象和草图),具有公共类信息(椅子,树,橙等).我选择了这种实现,它只将两个不同的域视为对应的不同"类"(列车样本X对应于真实图像,而目标样本y对应于草图图像).

有没有办法修改我的代码并考虑我整个架构中的类信息(椅子,树等)？我希望我的鉴别器能够预测我生成的图像来自生成器是否属于特定类,而不仅仅是它们是否真实.实际上,在当前架构中,系统学会在所有情况下创建类似的草图.

更新:鉴别器返回一个大小的张量1x7x7然后两者y_true并y_pred在计算损失之前通过展平层:

def discriminator_loss(y_true, y_pred):
     BATCH_SIZE=100
     return K.mean(K.binary_crossentropy(K.flatten(y_pred), K.concatenate([K.ones_like(K.flatten(y_pred[:BATCH_SIZE,:,:,:])),K.zeros_like(K.flatten(y_pred[:BATCH_SIZE,:,:,:])) ]) ), axis=-1)

以及鉴别器对发电机的损失功能:

def discriminator_on_generator_loss(y_true,y_pred):
     BATCH_SIZE=100
     return K.mean(K.binary_crossentropy(K.flatten(y_pred), K.ones_like(K.flatten(y_pred))), axis=-1)

此外,我对输出1层的鉴别器模型的修改:

model.add(Flatten())
model.add(Dense(1, activation='sigmoid'))
#model.add(Activation('sigmoid'))

现在鉴别器输出1层.如何相应修改上述损失函数？我应该有7而不是1,n_classes = 6用于预测真实和假对的+一类吗？

在 Tensorflow 2.0 中，有一个损失函数叫做

tf.keras.losses.sparse_categorical_crossentropy(labels, targets, from_logits = False)

我可以问你设置 from_logits = True 或 False 之间有什么区别吗？我的猜测是，当传入值是 logits 时，您设置 from_logits = True，如果传入值是概率（由 softmax 等输出），那么您只需设置 from_logits = False（这是默认设置）。

但为什么？损失只是一些计算。为什么它的传入值需要不同？我还在谷歌的 tensorflow 教程https://www.tensorflow.org/alpha/tutorials/sequences/text_generation 中看到， 即使最后一层的传入值是 logits，它也不会设置 from_logits = True。这是代码

@tf.function
def train_step(inp, target):
  with tf.GradientTape() as tape:
    predictions = model(inp)
    loss = tf.reduce_mean(
        tf.keras.losses.sparse_categorical_crossentropy(target, predictions))
  grads = tape.gradient(loss, model.trainable_variables)
  optimizer.apply_gradients(zip(grads, model.trainable_variables))

  return loss

模型在哪里

 model = tf.keras.Sequential([
    tf.keras.layers.Embedding(vocab_size, embedding_dim, 
                              batch_input_shape=[batch_size, None]),
    tf.keras.layers.LSTM(rnn_units, 
                        return_sequences=True, 
                        stateful=True, 
                        recurrent_initializer='glorot_uniform'),
    tf.keras.layers.Dense(vocab_size)
  ])

没有最后一层softmax。（另外，在教程的另一部分，它设置了 from_logits = True）

那么，我是否将其设置为 True …

PyTorch 的负对数似然损失nn.NLLLoss定义为：

因此，如果使用单批次中一个的标准重量来计算损失，则损失的公式始终为：

\n

-1 *（正确类别的模型预测）

\n

例子：

正确类别 = 0

正确类别的模型预测 = 0.5

损失 = -1 * 0.5

那么，如果计算损失时没有涉及对数函数，为什么它被称为“负对数似然损失”呢？\n\xe2\x80\x8b

我需要训练模型来预测标量值,并且预测值与真实值的方向相同很重要,而平方误差最小.

那个损失函数的好选择是什么？

例如:

假设预测值为-1,真值为1.两者之间的损失应该比3和1之间的损失大很多,即使(3,1)和(-1,1)的平方误差也是如此. ) 是平等的.

非常感谢!

我正在研究一个医疗数据集,我试图减少假阴性.预测"实际上没有疾病时的疾病"对我来说是可以的,但预测"实际上没有疾病时没有疾病".也就是说,我没事,FP但没有FN.

之后做一些研究,我发现喜欢的方式Keeping higher learning rate for one class,using class weights,ensemble learning with specificity/sensitivity等.

我使用类权重来实现接近期望的结果class_weight = {0 : 0.3,1: 0.7},然后调用model.fit(class_weights=class_weight).这给了我非常低的FN但是相当高的FP.我试图尽可能地降低FP,使FN保持在非常低的水平.

我正在努力编写一个自定义丢失函数,Keras这将帮助我惩罚假阴性.谢谢您的帮助.

环境

正如标题中已经提到的，在尝试加载保存的模型时，我的自定义损失函数出现了问题。我的损失如下：

def weighted_cross_entropy(weights):

    weights = K.variable(weights)

    def loss(y_true, y_pred):
        y_pred = K.clip(y_pred, K.epsilon(), 1-K.epsilon())

        loss = y_true * K.log(y_pred) * weights
        loss = -K.sum(loss, -1)
        return loss

    return loss

weighted_loss = weighted_cross_entropy([0.1,0.9])

所以在训练过程中，我将该weighted_loss函数用作损失函数，一切运行良好。训练完成后，我.h5使用model.save来自 keras API的标准函数将模型保存为文件。

问题

当我尝试通过加载模型时

model = load_model(path,custom_objects={"weighted_loss":weighted_loss})

我得到一个ValueError告诉我损失未知的消息。

错误

错误消息如下所示：

File "...\predict.py", line 29, in my_script
"weighted_loss": weighted_loss})
File "...\Continuum\anaconda3\envs\processing\lib\site-packages\keras\engine\saving.py", line 419, in load_model
model = _deserialize_model(f, custom_objects, compile)
File "...\Continuum\anaconda3\envs\processing\lib\site-packages\keras\engine\saving.py", line 312, in _deserialize_model
sample_weight_mode=sample_weight_mode)
File "...\Continuum\anaconda3\envs\processing\lib\site-packages\keras\engine\training.py", …

我正在使用Raw python实现二进制交叉熵损失函数，但它给了我一个与 Tensorflow 非常不同的答案。这是我从 Tensorflow 得到的答案：-

import numpy as np
from tensorflow.keras.losses import BinaryCrossentropy

y_true = np.array([1., 1., 1.])
y_pred = np.array([1., 1., 0.])
bce = BinaryCrossentropy()
loss = bce(y_true, y_pred)
print(loss.numpy())

输出：

>>> 5.1416497230529785

据我所知，二元交叉熵的公式是这样的：

我用原始 python 实现了相同的功能，如下所示：

def BinaryCrossEntropy(y_true, y_pred):
    m = y_true.shape[1]
    y_pred = np.clip(y_pred, 1e-7, 1 - 1e-7)
    # Calculating loss
    loss = -1/m * (np.dot(y_true.T, np.log(y_pred)) + np.dot((1 - y_true).T, np.log(1 - y_pred)))

    return loss

print(BinaryCrossEntropy(np.array([1, 1, 1]).reshape(-1, 1), np.array([1, 1, 0]).reshape(-1, 1))) …

我想实施一个两步学习过程，其中：

1. 使用损失函数预训练几个时期的模型 loss_1
2. 将损失函数更改为loss_2并继续训练以进行微调

目前，我的做法是：

model.compile(optimizer=opt, loss=loss_1, metrics=['accuracy'])
model.fit_generator(…)
model.compile(optimizer=opt, loss=loss_2, metrics=['accuracy'])
model.fit_generator(…)

请注意，优化器保持不变，只有损失函数发生变化。我想顺利地继续训练，但损失函数不同。根据这篇文章，重新编译模型会失去优化器状态。问题：

a) 即使我使用相同的优化器，例如 Adam，我会丢失优化器状态吗？
b) 如果 a) 的答案是肯定的，关于如何在不重置优化器状态的情况下将损失函数更改为新函数的任何建议？

编辑：
根据 Simon Caby 的建议并基于此线程，我创建了一个自定义损失函数，其中包含两个依赖于纪元数的损失计算。但是，它对我不起作用。我的做法：

model.compile(optimizer=opt, loss=loss_1, metrics=['accuracy'])
model.fit_generator(…)
model.compile(optimizer=opt, loss=loss_2, metrics=['accuracy'])
model.fit_generator(…)

初始化后，我编译如下current_epoch：

def loss_wrapper(t_change, current_epoch):
    def custom_loss(y_true, y_pred):
       c_epoch = K.get_value(current_epoch)
       if c_epoch < t_change:
           # compute loss_1
       else:
           # compute loss_2
    return custom_loss

为了更新current_epoch，我创建了以下回调：

current_epoch = K.variable(0.)
model.compile(optimizer=opt, loss=loss_wrapper(5, current_epoch), metrics=...)

回调self.current_epoch正确更新每个时期。但是更新没有达到自定义损失函数。相反， …

我设计了自己的损失函数。但是，当尝试恢复到训练期间遇到的最佳模型时

model = load_model("lc_model.h5")

我收到以下错误：

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-105-9d09ef163b0a> in <module>
     23 
     24 # revert to the best model encountered during training
---> 25 model = load_model("lc_model.h5")

C:\ProgramData\Anaconda3\lib\site-packages\keras\engine\saving.py in load_model(filepath, custom_objects, compile)
    417     f = h5dict(filepath, 'r')
    418     try:
--> 419         model = _deserialize_model(f, custom_objects, compile)
    420     finally:
    421         if opened_new_file:

C:\ProgramData\Anaconda3\lib\site-packages\keras\engine\saving.py in _deserialize_model(f, custom_objects, compile)
    310                       metrics=metrics,
    311                       loss_weights=loss_weights,
--> 312                       sample_weight_mode=sample_weight_mode)
    313 
    314         # Set optimizer weights.

C:\ProgramData\Anaconda3\lib\site-packages\keras\engine\training.py in compile(self, optimizer, loss, metrics, loss_weights, …