标签: loss-function

我正在使用 Keras/TF 和以下模型：

conv = Conv2D(4, 3, activation = None, use_bias=True)(inputs)   
conv = Conv2D(2, 1, activation = None, use_bias=True)(conv)
model = Model(input = inputs, output = conv)
model.compile(optimizer=Adam(lr=1e-4), loss=keras.losses.mean_absolute_error)

在 model.fit 中，我收到一条错误消息：

ValueError：检查目标时出错：预期 conv2d_2 的形状为 (300, 320, 2)，但得到的数组形状为 (300, 320, 1)

这是符合预期的，因为目标是单通道图像，而模型的最后一层有 2 个通道。

我不明白的是为什么当我使用自定义损失函数时：

def my_loss2(y_true, y_pred):
    return keras.losses.mean_absolute_error(y_true, y_pred)

并编译模型：

model.compile(optimizer = Adam(lr=1e-4), loss=my_loss2)

它确实有效（或者至少没有给出错误）。是否有任何类型的自动转换/截断正在进行？

我正在使用 TF (CPU) 1.12.0 和 Keras 2.2.2

此致，埃拉德

当尝试使用 PyTorch 创建模型时，当我尝试实现损失函数时nll_loss，它抛出以下错误

RuntimeError: _thnn_nll_loss_forward is not implemented for type torch.LongTensor 

我创建的拟合函数是：

for epoch in tqdm_notebook(range(1, epochs+1)):
    for batch_idx, (data, targets) in enumerate(train_loader):
        optimizer.zero_grad()
        net.float()
        output = net(data)
        output_x = output.argmax(dim=2) #to convert (64,50,43) -> (64, 50)
        loss = F.nll_loss(output_x, targets)
        loss.backward()
        optimizer.step()
        if batch_idx % 100 == 0:
            print('Train epochs: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx*len(data), len(ds.data),
                100.*batch_idx / len(ds), loss.item()
            ))

其中输出和目标的形状是(64, 50)，并且 dtypes 是torch.int64两者的。

我正在尝试找出如何匹配activation=sigmoid正确activation=softmax的model.compile(）损失参数。特别是那些与binary_crossentropy.

我研究了相关主题并阅读了文档。我还建立了一个模型并让它与 一起工作，sigmoid但没有softmax。我无法让它与“ from_logits”参数正常工作。

具体来说，这里说：

参数：

• from_logits：是否output预期为 Logits 张量。默认情况下，我们认为output编码了概率分布。

这对我来说，如果你使用sigmoid激活，你想要“ from_logits=True”。对于softmax激活，默认情况下您需要“ from_logits=False”。这里我假设sigmoid提供logits并softmax提供概率分布。

接下来是一些代码：

model = Sequential()
model.add(LSTM(units=128,
               input_shape=(n_timesteps, n_features), 
               return_sequences=True))
model.add(Dropout(0.3))
model.add(LSTM(units=64, return_sequences=True))
model.add(Dropout(0.3))
model.add(LSTM(units=32))
model.add(Dropout(0.3))
model.add(Dense(16, activation='relu'))
model.add(Dropout(0.3))
model.add(Dense(1, activation='sigmoid'))

请注意，最后一行正在使用sigmoid激活。然后：

model.compile(optimizer=optimizer,
              loss='binary_crossentropy',  
              metrics=['accuracy'])

这工作正常，但它使用默认的“from_logits=False”，它期望概率分布。

如果我执行以下操作，则会失败：

model.compile(optimizer=optimizer,
              loss='binary_crossentropy',  
              metrics=['accuracy'],
              from_logits=True) # For 'sigmoid' in above …

我试图了解如何计算圆圈项的值，我必须比较的输入/输出是什么？

让我们以第一个术语为例，如果我理解正确的话，它是这样的：

假设我对第一个单元格、第一个边界框 (yolov1 = 2 bbs) 的预测值是

[pr, x, y, W, H]\n[.7, 0.5, 0.3, 0.1, 0.1]\n

我的真正价值观是

[pr, x, y, W, H]\n[1, 0.6, 0.4, 0.2, 0.2]\n

这意味着公式是这样的

5 * ( 1 或 0 ) ((0.6 - .5)^2 + (0.4 - 0.3)^2)

有人可以逐步提供一个示例来说明确定 1 或 0 的指标是什么吗？

我们是否在查看训练集图像中的标签？\n我们是否在查看预测的客观分数？\nIoU？

根据 YOLO 论文：

\n

1objij ：表示单元格 i 中的第 j 个边界框预测器是\n \xe2\x80\x9cresponsible\xe2\x80\x9d 对于该预测

\n\n

1oji ：表示对象是否出现在单元格 i 中

\n

我的输入数组是image_array，包含 10000 张大小为 512x512、4 个通道的图像的数据。IE image_array.shape = (10000, 512, 512, 4)。每张图像都有一个相关的指标，我想训练 CNN 来为我进行预测。因此metric_array.shape = (10000)。由于我不希望网络偏向更频繁出现的指标值，因此我有一个加权数组，其中包含指标的每个值的权重。因此weightArray.shape = (10000)。

我正在使用 Keras。这是我的顺序模型：

model = Sequential()
model.add(Conv2D(32, use_bias=True, kernel_size=(3,3), strides=(1, 1), activation='relu', input_shape=(512,512,4))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
model.add(Conv2D(64, use_bias=True, kernel_size=(3,3), strides=(1, 1), activation='relu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
model.add(Conv2D(128, use_bias=True, kernel_size=(3,3), strides=(1, 1), activation='relu'))
model.add(BatchNormalization())
model.add(Flatten())
model.add(Dense(32))
model.add(Activation('relu'))
model.add(BatchNormalization())
model.add(Dense(1, activation=relu_max))

我想使用均方误差损失函数和随机梯度下降优化器。我编译我的模型：

model.compile(loss='mean_squared_error', optimizer=optimizers.SGD(lr=0.01))

我将数据集分为训练和验证：

X_train, X_validate, Y_train, Y_validate, W_train, W_validate \
= train_test_split(image_array, metric_array, weightArray, …

我正在使用自定义训练循环。返回的损失tf.keras.losses.categorical_crossentropy是我假设的数组(1,batch_size)。这是它应该返回的值还是单个值？

在后一种情况下，知道我可能做错了什么吗？

I'm training a LSTM model using pytorch with batch size of 256 and NLLLoss() as loss function. The loss function is having problem with the data shape.

The softmax output from the forward passing has shape of torch.Size([256, 4, 1181]) where 256 is batch size, 4 is sequence length, and 1181 is vocab size.

The target is in the shape of torch.Size([256, 4]) where 256 is batch size and 4 is the output sequence length.

When I was testing earlier …

默认情况下，PyTorchcross_entropy采用 logits（模型的原始输出）作为输入。我知道将(log(softmax(x))) 和(负对数似然损失)CrossEntropyLoss结合在一个类中。所以，我想我可以用如下方法从概率中获得交叉熵损失：LogSoftmaxNLLLossNLLLoss

真实标签：[1, 0, 1]
概率：[0.1, 0.9], [0.9, 0.1], [0.2, 0.8]

其中，y_i,j表示真实值，即如果样本i属于类别，则为1 j，否则为 0。并表示属于 类 的p_i,j样本模型预测的概率。ij

如果我手工计算的话，结果是：

>>> -(math.log(0.9) + math.log(0.9) + math.log(0.8))
0.4338

使用 PyTorch：

>>> labels = torch.tensor([1, 0, 1], dtype=torch.long)
>>> probs = torch.tensor([[0.1, 0.9], [0.9, 0.1], [0.2, 0.8]], dtype=torch.float)
>>> F.nll_loss(torch.log(probs), labels)
tensor(0.1446)

我究竟做错了什么？为什么答案不同？

假设我们有 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一个好主意吗？我怎么错了？

我需要使用tf.keras.*. 但：

• 空白类并不像 tf 期望的那样为零，但是(num_classes - 1)相反。
• 输入图像的宽度事先未知（不同批次的宽度不同）。

我想利用tf.nn.ctc_loss其中有一些很好的论点：blank_index。所以我做了一个简单的包装器来计算 CTC 损失：

    class CTCLossWrapper(tf.keras.losses.Loss):
        def __init__(self, blank_class: int, reduction: str = tf.keras.losses.Reduction.AUTO, name: str = 'ctc_loss'):
            super().__init__(reduction=reduction, name=name)
            self.blank_class = blank_class
        
        def call(self, y_true, y_pred):
            output = y_true['output']
            targets, target_lenghts = output['targets'], output['target_lengths']
            y_pred = tf.math.log(tf.transpose(y_pred, perm=[1, 0, 2]) + K.epsilon())
            max_input_len = K.cast(K.shape(y_pred)[1], dtype='int32')
            input_lengths = tf.ones((K.shape(y_pred)[0]), dtype='int32') * max_input_len
            return tf.nn.ctc_loss(
                labels=targets,
                logits=y_pred,
                label_length=target_lenghts,
                logit_length=input_lengths,
                blank_index=self.blank_class
            )

我还编写了一个简单的生成器函数，它生成训练样本：

def generator(dataset, batch_size: …