Pytorch：交叉熵损失中的权重

在本文中，我们将介绍Pytorch中使用交叉熵损失函数时的权重设置方法。交叉熵损失函数是深度学习中常用的损失函数之一，用于衡量分类模型的预测值与真实标签之间的差异。通过调整交叉熵损失函数的权重，我们可以关注特定类别的预测性能，提高模型的训练效果。

阅读更多：Pytorch 教程

交叉熵损失函数

在介绍权重设置方法之前，我们先来回顾一下交叉熵损失函数的定义。在Pytorch中，可以使用torch.nn.CrossEntropyLoss()函数来定义交叉熵损失函数。该函数的输入包含两部分：模型的预测值和真实标签。

首先，我们需要加载Pytorch和定义一个模型。为了方便起见，我们假设使用一个简单的全连接神经网络作为分类器。模型的结构如下所示：

import torch
import torch.nn as nn

class Classifier(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(Classifier, self).__init__()
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        self.fc2 = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

接下来，我们可以定义交叉熵损失函数并计算损失值：

criterion = nn.CrossEntropyLoss()
output = model(input)
loss = criterion(output, target)

其中，input是模型的预测值，维度为(batch_size, num_classes)，target是真实标签，维度为(batch_size,)。交叉熵损失函数会自动将target转化为one-hot编码，并计算预测值与真实标签之间的差异。

设置权重

在实际应用中，我们经常会遇到不同类别之间存在不平衡问题的情况。某些类别的样本数量可能远远多于其他类别，这会导致模型对样本数量较多的类别更加关注，而对样本数量较少的类别忽视。为了解决这个问题，我们可以通过设置交叉熵损失函数的权重来平衡各个类别之间的影响。

Pytorch中的交叉熵损失函数提供了一个名为weight的参数，用于设置每个类别的权重。这个权重可以是一个张量，维度与类别数量相同，其中每个元素表示对应类别的权重。例如，对于一个具有5个类别的分类任务，我们可以定义不同类别之间的权重如下：

weight = torch.tensor([1, 2, 3, 4, 5])
criterion = nn.CrossEntropyLoss(weight=weight)

在这个例子中，第一个类别的权重为1，第二个类别的权重为2，以此类推。通过设置不同权重，我们可以调整模型对每个类别的关注程度。通常情况下，样本数量较少的类别会被赋予更高的权重，以平衡样本数量较多的类别的影响。

示例说明

为了更好地理解权重设置在交叉熵损失函数中的影响，我们以一个简单的二分类问题为例。假设我们有一个数据集，包含两个类别的样本，分别为猫和狗。为了模拟类别不平衡的情况，我们生成1000个猫的样本和100个狗的样本。我们将使用Pytorch来训练一个分类器，同时比较不同权重设置下的模型性能。

首先，我们需要创建一个包含猫和狗样本的数据集。为了简化问题，我们将使用随机生成的特征向量作为输入，并将猫标签设置为0，狗标签设置为1。

import torch
from torch.utils.data import Dataset, DataLoader

class CatDogDataset(Dataset):
    def __init__(self):
        # Generate random features
        self.features = torch.randn((1100, 10))
        # Set labels
        self.labels = torch.cat([torch.zeros((1000,)), torch.ones((100,))])

    def __getitem__(self, index):
        return self.features[index], self.labels[index]

    def __len__(self):
        return len(self.features)

dataset = CatDogDataset()

接下来，我们可以定义模型和训练过程。这里我们使用与前文中相同的全连接神经网络结构，并将权重设置为[1, 1]，即两个类别的权重相等。

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

model = Classifier(input_dim=10, hidden_dim=16, output_dim=2)
criterion = nn.CrossEntropyLoss(weight=torch.tensor([1, 1]))
optimizer = optim.SGD(model.parameters(), lr=0.1)

def train(model, dataloader, criterion, optimizer):
    model.train()
    for inputs, targets in dataloader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, targets)
        loss.backward()
        optimizer.step()

train_loader = DataLoader(dataset, batch_size=32, shuffle=True)
train(model, train_loader, criterion, optimizer)

现在我们可以根据训练好的模型对测试集进行预测，并计算模型在每个类别上的准确率。

class_accuracy = [0, 0]
total_samples = [0, 0]

def test(model, dataloader):
    model.eval()
    for inputs, targets in dataloader:
        outputs = model(inputs)
        predictions = torch.argmax(outputs, dim=1)
        for label, prediction in zip(targets, predictions):
            if label == 0:
                total_samples[0] += 1
                if label == prediction:
                    class_accuracy[0] += 1
            else:
                total_samples[1] += 1
                if label == prediction:
                    class_accuracy[1] += 1

test_loader = DataLoader(dataset, batch_size=32, shuffle=False)
test(model, test_loader)

accuracy_cat = class_accuracy[0] / total_samples[0]
accuracy_dog = class_accuracy[1] / total_samples[1]
print("Accuracy - Cat: {:.2f}%, Dog: {:.2f}%".format(accuracy_cat * 100, accuracy_dog * 100))

此时，模型在猫类别上的准确率和狗类别上的准确率应该是相等的，因为我们对两个类别设置了相同的权重。接下来，我们尝试不同的权重设置，观察模型性能的变化。

# 设置权重为[1, 10]
criterion = nn.CrossEntropyLoss(weight=torch.tensor([1, 10]))
train(model, train_loader, criterion, optimizer)
test(model, test_loader)
accuracy_cat = class_accuracy[0] / total_samples[0]
accuracy_dog = class_accuracy[1] / total_samples[1]
print("Accuracy - Cat: {:.2f}%, Dog: {:.2f}%".format(accuracy_cat * 100, accuracy_dog * 100))