如何在PyTorch中找到混淆矩阵并绘制图像分类器的混淆矩阵图

Question

基本上这是VGG-16模型，我进行了迁移学习和微调模型，两周前我训练了这个模型并发现测试和训练精度都不错，但现在我需要模型的类别精度。我正在尝试找出混淆矩阵，并希望绘制该矩阵。 训练代码:

# Training the model again from the last CNN Block to The End of the Network
dataset = 'C:\\Users\\Sara Latif Khan\\OneDrive\\Desktop\\FYP_\\Scene15\\15-Scene'
model = model.to(device)
optimizer = Adam(filter(lambda p: p.requires_grad, model.parameters()))

#Training Fixed Feature Extractor for 15 epochs
num_epochs = 5
batch_loss = 0
cum_epoch_loss = 0 #cumulative loss for each batch

for e in range(num_epochs):
    cum_epoch_loss = 0
  
    for batch, (images, labels) in enumerate(trainloader,1):
        images = images.to(device)
        labels = labels.to(device)

        optimizer.zero_grad()
        logps = model(images)
        loss = criterion(logps, labels)
        loss.backward()
        optimizer.step()
    
        batch_loss += loss.item()
        print(f'Epoch({e}/{num_epochs} : Batch number({batch}/{len(trainloader)}) : Batch loss : {loss.item()}')
        torch.save(model, dataset+'_model_'+str(e)+'.pt')
    
print(f'Training loss : {batch_loss/len(trainloader)}')

这是我使用的代码，用于基于测试装载器中的数据检查模型的准确性。

model. to('cpu')

model.eval()
with torch.no_grad():
    num_correct = 0
    total = 0
    
    #set_trace ()
    for batch, (images,labels) in enumerate(testloader,1):
        
        logps = model(images)
        output = torch.exp(logps)
        
        pred = torch.argmax(output,1)
        total += labels.size(0)
        
        num_correct += (pred==labels).sum().item()
        print(f'Batch ({batch} / {len(testloader)})')
        
        # to check the accuracy of model on 5 batches
        # if batch == 5:
            # break
            
    print(f'Accuracy of the model on {total} test images: {num_correct * 100 / total }% ')  

接下来，我需要找到模型的类别准确率。 我正在使用Jupyter笔记本工作。 我应该重新加载保存的模型并找到混淆矩阵，还是有其他更合适的方法。

- Sarah Latif Khan

Answer 1

你需要保存测试集的所有预测结果和目标值。

predictions, targets = [], []
for images, labels in testloader:
    logps = model(images)
    output = torch.exp(logps)
    pred = torch.argmax(output, 1)

    # convert to numpy arrays
    pred = pred.detach().cpu().numpy()
    labels = labels.detach().cpu().numpy()
    
    for i in range(len(pred)):
        predictions.append(pred[i])
        targets.append(labels[i])

现在您已经将测试集的所有预测结果和实际目标存储下来。 下一步是创建混淆矩阵。我想我可以直接给您我经常使用的函数：

def create_confusion_matrix(y_true, y_pred, classes):
    """ creates and plots a confusion matrix given two list (targets and predictions)
    :param list y_true: list of all targets (in this case integers bc. they are indices)
    :param list y_pred: list of all predictions (in this case one-hot encoded)
    :param dict classes: a dictionary of the countries with they index representation
    """

    amount_classes = len(classes)

    confusion_matrix = np.zeros((amount_classes, amount_classes))
    for idx in range(len(y_true)):
        target = y_true[idx][0]

        output = y_pred[idx]
        output = list(output).index(max(output))

        confusion_matrix[target][output] += 1

    fig, ax = plt.subplots(1)

    ax.matshow(confusion_matrix)
    ax.set_xticks(np.arange(len(list(classes.keys()))))
    ax.set_yticks(np.arange(len(list(classes.keys()))))

    ax.set_xticklabels(list(classes.keys()))
    ax.set_yticklabels(list(classes.keys()))

    plt.setp(ax.get_xticklabels(), rotation=45, ha="left", rotation_mode="anchor")
    plt.setp(ax.get_yticklabels(), rotation=45, ha="right", rotation_mode="anchor")

    plt.show()

所以，y_true是所有目标，y_pred是所有预测结果，classes是一个字典，将标签映射到实际的类名，例如：

classes = {"dog": [1, 0], "cat": [0, 1]}

然后只需调用：

create_confusion_matrix(targets, predictions, classes)

可能你需要稍微修改一下代码，但我希望这对你有用。 :)

- Theodor Peifer

---

谢谢您的回复，我将会实现它，希望这对我有用。 - Sarah Latif Khan

这对我很有效。再次感谢@Thoedor Peifer。 - Sarah Latif Khan