Pytorch中accuracy和loss的计算知识点总结

PyTorch中accuracy和loss的计算知识点总结

在PyTorch中，accuracy和loss是深度学习模型训练和评估的两个重要指标。本文将对这两个指标的计算方法进行详细讲解，并提供两个示例说明。

1. 计算accuracy

accuracy是模型分类任务中的一个重要指标，用于衡量模型在测试集上的分类准确率。在PyTorch中，可以使用以下代码计算accuracy：

def accuracy(outputs, labels):
    _, predicted = torch.max(outputs, 1)
    correct = (predicted == labels).sum().item()
    total = labels.size(0)
    acc = correct / total
    return acc

其中，outputs是模型在测试集上的输出，labels是测试集的标签。首先，使用torch.max函数获取每个样本的预测类别。然后，将预测类别与真实类别进行比较，计算出正确分类的样本数。最后，将正确分类的样本数除以总样本数，得到accuracy。

2. 计算loss

loss是模型训练和评估中的一个重要指标，用于衡量模型在训练集上的拟合程度。在PyTorch中，可以使用以下代码计算loss：

def loss_fn(outputs, labels):
    loss = nn.CrossEntropyLoss()
    loss = loss(outputs, labels)
    return loss

其中，outputs是模型在训练集上的输出，labels是训练集的标签。首先，使用nn.CrossEntropyLoss函数定义交叉熵损失函数。然后，将模型输出和标签作为输入，计算出交叉熵损失函数的值。

示例1：使用PyTorch进行图像分类

以下是一个使用PyTorch进行图像分类的示例代码，其中包含了accuracy和loss的计算方法：

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.datasets as datasets
import torchvision.transforms as transforms

# 定义模型
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(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# 实例化模型
net = Net()

# 加载数据集
transform = transforms.Compose([
    transforms.Resize(32),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.5, 0.5, 0.5],
                         std=[0.5, 0.5, 0.5])
])
train_dataset = datasets.CIFAR10(root='./data', train=True,
                                 download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64,
                                           shuffle=True, num_workers=2)

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

# 训练模型
for epoch in range(10):
    running_loss = 0.0
    running_acc = 0.0
    for i, data in enumerate(train_loader, 0):
        inputs, labels = data
        optimizer.zero_grad()
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        acc = accuracy(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        running_acc += acc
    print('[%d] loss: %.3f, acc: %.3f' % (epoch + 1, running_loss / len(train_loader), running_acc / len(train_loader)))

# 测试模型
transform = transforms.Compose([
    transforms.Resize(32),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.5, 0.5, 0.5],
                         std=[0.5, 0.5, 0.5])
])
test_dataset = datasets.CIFAR10(root='./data', train=False,
                                download=True, transform=transform)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64,
                                          shuffle=False, num_workers=2)
correct = 0
total = 0
with torch.no_grad():
    for data in test_loader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
print('Accuracy: %.2f %%' % (100 * correct / total))

在上面的代码中，我们首先定义了一个Net类，该类继承自nn.Module类，并定义了一个包含两个卷积层和三个全连接层的模型。然后，我们实例化了该模型，并使用CIFAR10数据集加载了训练数据集和测试数据集。接下来，我们定义了交叉熵损失函数和随机梯度下降优化器，并使用训练数据集训练模型，并在每个epoch结束时输出了损失值和accuracy。最后，我们使用测试数据集测试模型，并计算了模型的准确率。

示例2：使用PyTorch进行文本分类

以下是一个使用PyTorch进行文本分类的示例代码，其中包含了accuracy和loss的计算方法：

import torch
import torch.nn as nn
import torch.optim as optim
from torchtext.datasets import AG_NEWS
from torchtext.data.utils import get_tokenizer
from torchtext.vocab import build_vocab_from_iterator
from torchtext.data.utils import get_numericalization_processor
from torchtext.data.functional import to_map_style_dataset
from torch.utils.data import DataLoader

# 加载数据集
train_iter = AG_NEWS(split='train')
tokenizer = get_tokenizer('basic_english')
vocab = build_vocab_from_iterator(map(tokenizer, train_iter), specials=["<unk>"])
processor = get_numericalization_processor(vocab)
train_dataset = to_map_style_dataset(train_iter, processor)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)

# 定义模型
class Net(nn.Module):
    def __init__(self, vocab_size, embedding_dim, num_classes):
        super(Net, self).__init__()
        self.embedding = nn.EmbeddingBag(vocab_size, embedding_dim, sparse=True)
        self.fc = nn.Linear(embedding_dim, num_classes)

    def forward(self, text, offsets):
        embedded = self.embedding(text, offsets)
        return self.fc(embedded)

# 实例化模型
vocab_size = len(vocab)
embedding_dim = 64
num_classes = len(train_iter.get_labels())
net = Net(vocab_size, embedding_dim, num_classes)

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01)

# 训练模型
for epoch in range(10):
    running_loss = 0.0
    running_acc = 0.0
    for i, data in enumerate(train_loader, 0):
        text, offsets = data['text'], data['offsets']
        optimizer.zero_grad()
        outputs = net(text, offsets)
        labels = data['label']
        loss = criterion(outputs, labels)
        acc = accuracy(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        running_acc += acc
    print('[%d] loss: %.3f, acc: %.3f' % (epoch + 1, running_loss / len(train_loader), running_acc / len(train_loader)))

在上面的代码中，我们首先使用torchtext库加载了AG_NEWS数据集，并使用get_tokenizer函数和build_vocab_from_iterator函数构建了词汇表。然后，使用get_numericalization_processor函数将文本转换为数字，并使用to_map_style_dataset函数将数据集转换为PyTorch的MapDataset格式。接下来，我们定义了一个Net类，该类继承自nn.Module类，并定义了一个包含一个EmbeddingBag层和一个全连接层的模型。然后，我们实例化了该模型，并定义了交叉熵损失函数和随机梯度下降优化器。接下来，我们使用训练数据集训练模型，并在每个epoch结束时输出了损失值和accuracy。