标签: loss

嗨，我正在尝试进入 tensorflow，但感觉有点傻。TF 中的 log_loss 与 sklearn 的不同吗？

这是我的代码中的一些行，我是如何计算的：

from sklearn.metrics import log_loss

tmp = np.array(y_test)
y_test_t = np.array([tmp, -(tmp-1)]).T[0]

tf_log_loss = tf.losses.log_loss(predictions=tf.nn.softmax(logits), labels=tf_y)

with tf.Session() as sess:

    # training

    a = sess.run(tf.nn.softmax(logits), feed_dict={tf_x: xtest, keep_prob: 1.})
    print("    sk.log_loss: ", log_loss(y_test, a,eps=1e-7 ))
    print("    tf.log_loss: ", sess.run(tf_log_loss, feed_dict={tf_x: xtest, tf_y: y_test_t, keep_prob: 1.}))

我得到的输出

Epoch  7, Loss:     0.4875 Validation Accuracy: 0.818981
    sk.log_loss:  1.76533018874
    tf.log_loss:  0.396557
Epoch  8, Loss:     0.4850 Validation Accuracy: 0.820738
    sk.log_loss:  1.77217639627
    tf.log_loss:  0.393351
Epoch  9, Loss:     0.4835 Validation …

我正在实现一个损失函数，该函数将使用掩模张量(M)来消除给定预测和地面实况张量0s and 1s的一些损失值。(P)(G)

所以，我有两种可能的方法：

逐元素乘法：

loss = K.sum(M * K.binary_crossentropy(G, P))

条件选择：

bin_ce = K.binary_crossentropy(G, P)
loss = K.sum(tf.where(tf.equal(M, 1), bin_ce, 0))

那么，就运行时间而言，哪个会更高效呢？

我在keras中实现自定义损失功能。该模型是autoencoder。所述第一层是一个嵌入层，其嵌入尺寸的输入(batch_size, sentence_length)到(batch_size, sentence_length, embedding_dimension)。然后，模型将嵌入压缩为一定维数的向量，最后必须重建嵌入(batch_size, sentence_lenght, embedding_dimension)。

但是嵌入层是可训练的，并且损失必须使用嵌入层的权重（我必须对词汇表的所有词嵌入进行求和）。

例如，如果我想训练玩具示例：“猫”。的sentence_length is 2并假设embedding_dimension is 10和vocabulary size is 50，所以嵌入矩阵具有形状(50,10)。嵌入层的输出X为shape (1,2,10)。然后，它传递到模型中，并且输出X_hat也具有形状(1,2,10)。必须对模型进行训练，以最大程度地提高在嵌入层中表示“ the” X_hat[0]的矢量与X[0]表示“ the” 的矢量最相似的可能性，而对于“ cat”也一样。但是损失是如此之大，以至于我必须计算X和之间的余弦相似度，并X_hat通过将的余弦相似度之和归一化X_hat 以及嵌入矩阵中的每个嵌入（由于词汇量为50，因此为50），它们是嵌入层权重的列。

但是，在训练过程的每次迭代中，如何访问嵌入层中的权重？

谢谢 ！

我想创建一个 L2 损失函数，它忽略标签值为 0 的值（=> 像素）。张量batch[1]包含标签，output而是净输出的张量，两者的形状均为(None,300,300,1).

labels_mask = tf.identity(batch[1])
labels_mask[labels_mask > 0] = 1
loss = tf.reduce_sum(tf.square((output-batch[1])*labels_mask))/tf.reduce_sum(labels_mask)

我当前的代码屈服于TypeError: 'Tensor' object does not support item assignment（在第二行）。什么是张量流方式来做到这一点？我还尝试将损失归一化为tf.reduce_sum(labels_mask)，我希望它像这样工作。

最初由 IJ Goodfellow 提出的 GAN 使用以下损失函数，

D_loss = - log[D(X)] - log[1 - D(G(Z))]

G_loss = - log[D(G(Z))]

因此，鉴别器尝试最小化 D_loss，生成器尝试最小化 G_loss，其中 X 和 Z 分别是训练输入和噪声输入。D(.) 和 G(.) 分别是鉴别器和生成器神经网络的映射。

正如原始论文所说，当 GAN 被训练几个步骤时，它会达到一个生成器和判别器都无法改进的点，并且 D(Y) 到处都是 0.5，Y 是判别器的一些输入。在这种情况下，当 GAN 被充分训练到这一点时，

D_loss = - log(0.5) - log(1 - 0.5) = 0.693 + 0.693 = 1.386

G_loss = - log(0.5) = 0.693

那么，为什么我们不能使用 D_loss 和 G_loss 值作为评估 GAN 的指标呢？

如果两个损失函数偏离了这些理想值，那么 GAN 肯定需要训练好或架构需要设计好。正如原始论文中的定理 1 所讨论的，这些是 D_loss 和 G_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 …

我将小批量数据提供给模型，我只想知道如何处理损失。我可以累积损失，然后像这样调用向后：

    ...
    def neg_log_likelihood(self, sentences, tags, length):
        self.batch_size = sentences.size(0)

        logits = self.__get_lstm_features(sentences, length)
        real_path_score = torch.zeros(1)
        total_score = torch.zeros(1)
        if USE_GPU:
            real_path_score = real_path_score.cuda()
            total_score = total_score.cuda()

        for logit, tag, leng in zip(logits, tags, length):
            logit = logit[:leng]
            tag = tag[:leng]
            real_path_score += self.real_path_score(logit, tag)
            total_score += self.total_score(logit, tag)
        return total_score - real_path_score
    ...
loss = model.neg_log_likelihood(sentences, tags, length)
loss.backward()
optimizer.step()

我想知道如果积累会导致梯度爆炸吗？

所以，我应该在循环中调用向后：

for sentence, tag , leng in zip(sentences, tags, length):
    loss = model.neg_log_likelihood(sentence, tag, leng)
    loss.backward()
    optimizer.step() …

假设我们有 100 个图像且批量大小为 15 的问题。除了最后一个批次包含 10 个图像之外，所有批次中都有 15 个图像。

假设我们的网络训练为：

network = Network()
optimizer = optim.Adam(network.parameters(),lr=0.001)

for epoch in range(5):

    total_loss = 0

    train_loader = torch.utils.data.DataLoader(train_set,batch_size=15) 

    for batch in train_loader: 
        images,labels = batch

        pred = network(images)
        loss = F.cross_entropy(pred,labels)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        total_loss+= loss.item()*15

最后一批不是总是应该给我们一个增加的值，loss因为我们将乘以 15，而我们应该在最后一批中乘以 10？它不应该 total_loss+= loss.item()*len(images)代替 15 或batch_size??

我们可以使用

for every epoch:
    for every batch:
        loss = F.cross_entropy(pred,labels,reduction='sum')
        total_loss+=loss.item()

    avg_loss_per_epoch = (total_loss/len(train_set))      

有人可以解释一下乘以batch_size一个好主意吗？我怎么错了？

我正在训练一个分类模型来对细胞进行分类，我的模型基于这篇论文： https: //www.nature.com/articles/s41598-019-50010-9。由于我的数据集仅包含 10 张图像，因此我执行了图像增强，人为地将数据集的大小增加到 3000 张图像，然后将其分为 2400 张训练图像和 600 张验证图像。

然而，虽然训练损失和准确度随着迭代次数的增加而提高，但验证损失却迅速增加，而验证准确度则停滞在 0.0000e+00。

我的模型从一开始就严重过度拟合吗？

我使用的代码如下所示：

import keras
import tensorflow as tf
from tensorflow.keras import backend as K
from tensorflow.keras.models import Model, load_model, Sequential, model_from_json, load_model
from tensorflow.keras.layers import Input, BatchNormalization, Activation, Flatten, Dense, LeakyReLU
from tensorflow.python.keras.layers.core import Lambda, Dropout
from tensorflow.python.keras.layers.convolutional import Conv2D, Conv2DTranspose, UpSampling2D
from tensorflow.python.keras.layers.pooling import MaxPooling2D, AveragePooling2D
from tensorflow.python.keras.layers.merge import Concatenate, Add
from tensorflow.keras import backend as K
from tensorflow.keras.callbacks import ModelCheckpoint, LearningRateScheduler, ReduceLROnPlateau, EarlyStopping
from …

我正在尝试计算使用掩码时的 MSELoss。假设我有一个batch_size为2:的张量[2, 33, 1]作为我的目标，还有另一个具有相同形状的输入张量。由于每个实例的序列长度可能不同，因此我还有一个二进制掩码，指示输入序列中每个元素的存在。所以这就是我正在做的：

mse_loss = nn.MSELoss(reduction='none')

loss = mse_loss(input, target)
loss = (loss * mask.float()).sum() # gives \sigma_euclidean over unmasked elements

mse_loss_val = loss / loss.numel()

# now doing backpropagation
mse_loss_val.backward()

是loss / loss.numel()一个好的做法吗？我持怀疑态度，因为我必须使用reduction='none'并且在计算最终损失值时，我认为我应该仅考虑那些非零（即未屏蔽）的损失元素来计算损失，但是，我取所有张量元素的平均值和torch.numel()。我实际上正在尝试考虑1/nMSELoss 因素。有什么想法吗？