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。
本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：Pytorch中accuracy和loss的计算知识点总结 - Python技术站
微信扫一扫 
支付宝扫一扫 
