标签: cross-entropy

import tensorflow as tf
import numpy as np
def weight(shape):
return tf.Variable(tf.truncated_normal(shape, stddev=0.1))
def bias(shape):
return tf.Variable(tf.constant(0.1, shape=shape))
def output(input,w,b):
return tf.matmul(input,w)+b
x_columns = 33
y_columns = 1
layer1_num = 7
layer2_num = 7
epoch_num = 10
train_num = 1000
batch_size = 100
display_size = 1
x = tf.placeholder(tf.float32,[None,x_columns])
y = tf.placeholder(tf.float32,[None,y_columns])

layer1 = 
tf.nn.relu(output(x,weight([x_columns,layer1_num]),bias([layer1_num])))
layer2=tf.nn.relu
(output(layer1,weight([layer1_num,layer2_num]),bias([layer2_num])))
prediction = output(layer2,weight([layer2_num,y_columns]),bias([y_columns]))

loss=tf.reduce_mean
(tf.nn.softmax_cross_entropy_with_logits(labels=y,logits=prediction))
train_step = tf.train.AdamOptimizer().minimize(loss)

sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer())
for epoch in range(epoch_num):
   avg_loss = 0.
   for i in range(train_num): …

我正在阅读log_loss和交叉熵，似乎有两种计算方法

第一：

import numpy as np
from sklearn.metrics import log_loss
def cross_entropy(predictions, targets):
    N = predictions.shape[0]
    ce = -np.sum(targets*np.log(predictions))/N
    return ce

predictions = np.array([[0.25,0.25,0.25,0.25],
                        [0.01,0.01,0.01,0.97]])
targets = np.array([[1,0,0,0],
                   [0,0,0,1]])

x = cross_entropy(predictions, targets)
print(log_loss(targets, predictions), 'our_answer:', ans)

输出：0.7083767843022996 our_answer: 0.71355817782，几乎相同。所以这不是问题。

资料来源：http : //wiki.fast.ai/index.php/Log_Loss

以上实现是等式的中间部分。

第二：计算方法是等式的RHS部分：

res = 0
for act_row, pred_row in zip(targets, np.array(predictions)):
    for class_act, class_pred in zip(act_row, pred_row):
        res += - class_act * np.log(class_pred) - (1-class_act) * np.log(1-class_pred)

print(res/len(targets))

输出： 1.1549753967602232

不太一样。我用numpy尝试过相同的实现也没有用。我究竟做错了什么？

PS：我也很好奇，-y …

我正在做一个图像分割任务。总共有 7 个类，所以最终输出是一个像 [batch, 7, height, width] 这样的张量，它是一个 softmax 输出。现在直觉上我想使用 CrossEntropy 损失，但 pytorch 实现不适用于通道明智的单热编码向量

所以我打算自己做一个功能。在一些 stackoverflow 的帮助下，我的代码到目前为止看起来像这样

from torch.autograd import Variable
import torch
import torch.nn.functional as F


def cross_entropy2d(input, target, weight=None, size_average=True):
    # input: (n, c, w, z), target: (n, w, z)
    n, c, w, z = input.size()
    # log_p: (n, c, w, z)
    log_p = F.log_softmax(input, dim=1)
    # log_p: (n*w*z, c)
    log_p = log_p.permute(0, 3, 2, 1).contiguous().view(-1, c)  # make class dimension last dimension
    log_p = log_p[
       target.view(n, w, …

我已经用随机数测试过“ softmax_cross_entropy_with_logits_v2”

import tensorflow as tf

x = tf.placeholder(tf.float32,shape=[None,5])
y = tf.placeholder(tf.float32,shape=[None,5])
softmax = tf.nn.softmax_cross_entropy_with_logits_v2(logits=x,labels=y)

with tf.Session() as sess:
    feedx=[[0.1,0.2,0.3,0.4,0.5],[0.,0.,0.,0.,1.]]
    feedy=[[1.,0.,0.,0.,0.],[0.,0.,0.,0.,1.]]
    softmax = sess.run(softmax, feed_dict={x:feedx, y:feedy})
    print("softmax", softmax)

控制台“ softmax [1.8194163 0.9048325]”

我对该功能的了解是，此功能仅在logit和标签不同时才返回成本。

那为什么它甚至返回相同的值0.9048325？

我想打印每个时期模型的验证损失，获取和打印验证损失的正确方法是什么？

是不是这样：

criterion = nn.CrossEntropyLoss(reduction='mean')
for x, y in validation_loader:
 optimizer.zero_grad()
 out = model(x)
 loss = criterion(out, y)
 loss.backward()
 optimizer.step()
 losses += loss

display_loss = losses/len(validation_loader)
print(display_loss)

或者像这样

criterion = nn.CrossEntropyLoss(reduction='mean')
for x, y in validation_loader:
     optimizer.zero_grad()
     out = model(x)
     loss = criterion(out, y)
     loss.backward()
     optimizer.step()
     losses += loss
    
display_loss = losses/len(validation_loader.dataset)
print(display_loss)

或者是其他东西？谢谢。

本pytorch教程 ( https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html#sphx-glr-beginner-blitz-cifar10-tutorial-py ) 在 CIFAR 数据集上训练卷积神经网络 (CNN)。

    class Net(nn.Module):
        def __init__(self):
            super(Net, self).__init__()
            self.conv1 = nn.Conv2d(3, 6, 5)
            self.pool = nn.MaxPool2d(2, 2)
            self.conv2 = nn.Conv2d(6, 16, 5)
            self.fc1 = nn.Linear(16 * 5 * 5, 120)
            self.fc2 = nn.Linear(120, 84)
            self.fc3 = nn.Linear(84, 10)

        def forward(self, x):
            x = self.pool(F.relu(self.conv1(x)))
            x = self.pool(F.relu(self.conv2(x)))
            x = x.view(-1, 16 * 5 * 5)
            x = F.relu(self.fc1(x))
            x = F.relu(self.fc2(x))
            x = self.fc3(x)
            return x 

网络看起来不错，除了最后一层fc3，它预测属于 10 个类的概率，而没有 softmax。在计算交叉熵损失之前，我们不应该先应用 …

我正在阅读多类分类问题的 Pytorch 教程。我发现 Pytorch 中 Loss 计算的行为让我很困惑。你能帮我解决这个问题吗？

用于分类的模型如下：

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

训练过程如下：

optimizer.zero_grad()
outputs = net(inputs)
loss = nn.CrossEntropyLoss(outputs, …

当我们处理不平衡的训练数据（负样本较多，正样本较少）时，通常pos_weight会使用参数。的期望是，当得到错误标签pos_weight时，模型将比 得到更高的损失。当我使用该功能时，我发现：positive samplenegative samplebinary_cross_entropy_with_logits

bce = torch.nn.functional.binary_cross_entropy_with_logits

pos_weight = torch.FloatTensor([5])
preds_pos_wrong =  torch.FloatTensor([0.5, 1.5])
label_pos = torch.FloatTensor([1, 0])
loss_pos_wrong = bce(preds_pos_wrong, label_pos, pos_weight=pos_weight)

preds_neg_wrong =  torch.FloatTensor([1.5, 0.5])
label_neg = torch.FloatTensor([0, 1])
loss_neg_wrong = bce(preds_neg_wrong, label_neg, pos_weight=pos_weight)

然而：

>>> loss_pos_wrong
tensor(2.0359)

>>> loss_neg_wrong
tensor(2.0359)

错误的正样本和负样本产生的损失是相同的，那么pos_weight不平衡数据损失计算是如何进行的呢？

我有一个输出大小为 3D 张量的网络(batch_size, max_len, num_classes)。我的基本真理是形状(batch_size, max_len)。如果我对标签执行 one-hot 编码，它将是形状，(batch_size, max_len, num_classes)即 中的值max_len是范围内的整数[0, num_classes]。由于原始代码太长，我写了一个更简单的版本，重现了原始错误。

criterion = nn.CrossEntropyLoss()
batch_size = 32
max_len = 350
num_classes = 1000
pred = torch.randn([batch_size, max_len, num_classes])
label = torch.randint(0, num_classes,[batch_size, max_len])
pred = nn.Softmax(dim = 2)(pred)
criterion(pred, label)

pred 和 label 的形状分别是，torch.Size([32, 350, 1000])和torch.Size([32, 350])

遇到的错误是

ValueError: Expected target size (32, 1000), got torch.Size([32, 350, 1000])

如果我对标签进行单热编码以计算损失

x = nn.functional.one_hot(label)
criterion(pred, x)

它会抛出以下错误

ValueError: …

我想使用 Pytorch 训练多类分类器。

按照官方 Pytorch 文档展示了如何nn.CrossEntropyLoss()在 type 的最后一层之后使用 a nn.Linear(84, 10)。

但是，我记得这是 Softmax 所做的。

这让我很困惑。

1. 如何以最佳方式训练“标准”分类网络？
2. 如果网络有最后的线性层，如何推断每个类的概率？
3. 如果网络有最后的 softmax 层，如何训练网络（哪个损失，以及如何训练）？

我在 Pytorch 论坛上找到了这个线程，它可能回答了所有这些问题，但我无法将它编译成工作和可读的 Pytorch 代码。

我假设的答案：

1. 就像医生说的那样。
2. 线性层输出的幂，这实际上是对数（对数概率）。
3. 我不明白。