0


损失函数——对数损失(Logarithmic Loss,Log Loss)

对数损失(Logarithmic Loss,Log Loss)是一种用于衡量分类模型的损失函数。它通常用于二元分类问题,但也可以用于多元分类问题。

在二元分类问题中,Log Loss 基于预测概率和实际标签的对数误差来计算损失。对于一个样本 i,假设它的实际标签是 yi​(取值为 0 或 1),模型预测的概率为 y​^i​(0 ≤ y^i​​ ≤ 1),则它的对数损失为:

其中,N 是样本总数。可以看出,当预测的概率接近于实际标签时,对数损失接近于0,而当预测的概率偏离实际标签时,对数损失会增加。

对于多元分类问题,Log Loss 的定义稍有不同。假设有 K 个类别,样本 i 的实际标签是yi,j​(取值为 0 或 1,表示样本 i 是否属于第 j 个类别),模型预测的概率为 y^​i,j​(0 ≤ y^i,j​​ ≤ 1,表示样本 i 属于第 j 个类别的概率),则样本 i 的对数损失为:

其中,N 是样本总数。可以看出,对数损失的计算方式与二元分类问题的情况类似,只不过需要对所有类别的对数误差求和。

对数损失是一种常用的损失函数,它在训练分类模型时被广泛使用。当模型的预测概率与实际标签越接近时,对数损失越小,因此它可以帮助模型更好地拟合数据并提高分类准确率。

在 PyTorch 中,可以使用 nn.BCELoss() 来计算二元分类问题的对数损失,使用 nn.CrossEntropyLoss() 来计算多元分类问题的对数损失。下面分别介绍它们的使用方法。

对于二元分类问题,可以按以下方式计算对数损失:

import torch.nn as nn

# 定义二元分类模型
model = nn.Sequential(
    nn.Linear(10, 1),
    nn.Sigmoid()
)

# 定义损失函数
criterion = nn.BCELoss()

# 假设有 100 个样本,每个样本有 10 个特征
x = torch.randn(100, 10)
y = torch.randint(0, 2, (100, 1)).float()

# 前向传播计算损失
y_pred = model(x)
loss = criterion(y_pred, y)

# 反向传播更新模型参数
loss.backward()

在上面的代码中,我们首先定义了一个包含一个线性层和一个 Sigmoid 激活函数的二元分类模型。然后,使用 nn.BCELoss() 定义损失函数。在前向传播过程中,我们首先计算模型对所有样本的预测概率,然后将它们与实际标签一起传递给损失函数,从而计算对数损失。最后,使用反向传播算法计算梯度,并更新模型参数。

对于多元分类问题,可以按以下方式计算对数损失:

import torch.nn as nn

# 定义多元分类模型
model = nn.Sequential(
    nn.Linear(10, 5),
    nn.Softmax(dim=1)
)

# 定义损失函数
criterion = nn.CrossEntropyLoss()

# 假设有 100 个样本,每个样本有 10 个特征,共有 5 个类别
x = torch.randn(100, 10)
y = torch.randint(0, 5, (100,))

# 前向传播计算损失
y_pred = model(x)
loss = criterion(y_pred, y)

# 反向传播更新模型参数
loss.backward()

在上面的代码中,我们首先定义了一个包含一个线性层和一个 Softmax 激活函数的多元分类模型。然后,使用 nn.CrossEntropyLoss() 定义损失函数。在前向传播过程中,我们首先计算模型对所有样本的预测概率,然后将它们与实际标签一起传递给损失函数,从而计算对数损失。最后,使用反向传播算法计算梯度,并更新模型参数。

要在训练中使用对数损失作为损失函数,可以在模型训练的过程中调用 PyTorch 中的损失函数计算方法,并将计算得到的损失加入到反向传播过程中以更新模型参数。下面是一个使用对数损失函数训练二元分类模型的示例:

import torch
import torch.nn as nn
import torch.optim as optim

# 定义二元分类模型
class BinaryClassifier(nn.Module):
    def __init__(self, input_size):
        super(BinaryClassifier, self).__init__()
        self.linear = nn.Linear(input_size, 1)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        x = self.linear(x)
        x = self.sigmoid(x)
        return x

# 定义训练函数
def train(model, train_loader, criterion, optimizer):
    model.train()
    train_loss = 0
    correct = 0
    total = 0
    for batch_idx, (data, target) in enumerate(train_loader):
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()
        pred = output >= 0.5
        correct += pred.eq(target).sum().item()
        total += target.size(0)
    accuracy = 100. * correct / total
    train_loss /= len(train_loader)
    print('Train set: Average loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)'.format(
        train_loss, correct, total, accuracy))

# 定义训练数据
train_data = torch.randn(1000, 10)
train_target = torch.randint(0, 2, (1000, 1)).float()
train_dataset = torch.utils.data.TensorDataset(train_data, train_target)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=32, shuffle=True)

# 定义模型、损失函数和优化器
model = BinaryClassifier(input_size=10)
criterion = nn.BCELoss()
optimizer = optim.SGD(model.parameters(), lr=0.1)

# 开始训练
for epoch in range(10):
    train(model, train_loader, criterion, optimizer)

在上面的代码中,我们首先定义了一个二元分类模型,并定义了一个训练函数 train()。在 train() 函数中,我们将模型的 train() 方法调用,以确保在训练过程中启用了 dropout 和 batch normalization。然后,我们遍历训练数据集,计算每个 mini-batch 的预测输出和对数损失,并调用反向传播算法计算梯度并更新模型参数。最后,我们计算并输出训练集的平均损失和准确率。

在主程序中,我们首先定义了训练数据集,并将其加载到 DataLoader 中以方便批量训练。然后,我们定义了模型、损失函数和优化器,并调用 10 次 train() 函数对模型进行训练。

需要注意的是,在训练过程中,我们使用的损失函数是 nn.BCELoss()


本文转载自: https://blog.csdn.net/weixin_50752408/article/details/129561792
版权归原作者 木子十口儿几丶 所有, 如有侵权,请联系我们删除。

“损失函数——对数损失(Logarithmic Loss,Log Loss)”的评论:

还没有评论