分类导航

程序问答发布时间：2022-06-02 发布网站：大佬教程 code.js-code.com

大佬教程收集整理的这篇文章主要介绍了如何检查 BCELoss Pytorch 的准确性？，大佬教程大佬觉得挺不错的，现在分享给大家，也给大家做个参考。

如何解决如何检查 BCELoss Pytorch 的准确性？？

开发过程中遇到如何检查 BCELoss Pytorch 的准确性？的问题如何解决？下面主要结合日常开发的经验，给出你关于如何检查 BCELoss Pytorch 的准确性？的解决方法建议，希望对你解决如何检查 BCELoss Pytorch 的准确性？有所启发或帮助；

我正在尝试使用 Pytorch 获取 Heartdisease.csv 并预测患者是否患有心脏病....csv 提供 13 个输入和 1 个目标

我正在使用 bceloss，但在理解如何编写准确性检查函数时遇到问题。

我的 num_samples 是正确的，但不是我的 num_correct。我认为这是不理解预测张量的结果。现在我的 num_correct 通常超过 8000 而我的 num_samples 是 303...

非常感谢有关如何编写此检查准确性函数的任何见解

我在谷歌合作实验室写的

#imports
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import Dataset,DataLoader
import pandas as pd

#create fully connected network
class NN(nn.ModulE):
  def __init__(self,input_size,num_classes):
    super(NN,self).__init__()
    self.outputs = nn.linear(input_size,1)

  def forWARD(self,X):
     x = self.outputs(X)
     return torch.sigmoID(X) 

#set device
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

#hyperparameters
input_size = 13 # 13 inputs
num_classes = 1 # heartdisease or not
learning_rate = 0.001
batch_size = 64
num_epochs = 1

#load data
class MyDataset(Dataset):
    def __init__(self,root,n_inp):
        self.df = pd.read_csv(root)
        self.data = self.df.to_numpy()
        self.x,self.y = (torch.from_numpy(self.data[:,:n_inp]),torch.from_numpy(self.data[:,n_inp:]))
    def __getitem__(self,IDX):
        return self.x[IDx,:],self.Y[IDx,:]
    def __len__(self):
        return len(self.data)

Train_dataset = MyDataset("heart.csv",input_sizE)
Train_loader = DataLoader(Train_dataset,batch_size=batch_size,shuffle =TruE)
test_dataset = MyDataset("heart.csv",input_sizE)
test_loader = DataLoader(test_dataset,shuffle =TruE)

#initialize network
model = NN(input_size=input_size,num_classes=num_classes).to(devicE)

#loss and optimizer
criterion = nn.bceloss()
optimizer = optim.Adam(model.parameters(),lr=learning_ratE)

#Train network
for epoch in range(num_epochs):
  for batch_IDx,(data,targets) in enumerate(Train_loader):
    #get data to cuda if possible
    data = data.to(device=devicE)
    targets = targets.to(device=devicE)

    #forWARD
    scores = model(data.float())
    targets = targets.float()
    loss = criterion(scores,targets)

    #BACkWARD
    optimizer.zero_grad()
    loss.BACkWARD()

    #grad descent or adam step
    optimizer.step()

#check accuracy of model
def check_accuracy(loader,model):
  num_correct = 0
  num_samples = 0
  model.eval()

  with torch.no_grad():
    for x,y in loader:
      x = x.to(device=devicE)
      y = y.to(device=devicE)

      scores = model(x.float())
      _,preDictions = scores.max(1)
      num_correct += (preDictions == y).sum()
      num_samples += preDictions.size(0)
    
    print("Got {} / {} with accuracy {}".format(num_correct,num_samples,float(num_correct)/float(num_samples)*100))

  model.Train()

print("checking accuracy on Training data")
check_accuracy(Train_loader,model)

print("checking accuracy on test data")
check_accuracy(test_loader,model)

解决方法

注意：不要自欺欺人。单个线性层 + sigmoid + BCE 损失 = 逻辑回归。这是一个线性模型，因此在将其称为“神经网络”时请注意这一点，该术语通常保留用于类似网络，但至少具有一个隐藏层和非线性激活。

模型 sigmoid 函数末尾的 forWARD() 层返回一个 (N,1) 大小的张量，其中 N 是批量大小。换句话说，它为每个数据点返回一个标量。每个标量都是一个介于 0 到 1 之间的值（这是 sigmoid 函数的范围）。

这个想法是将这些标量解释为与正类相对应的概率。假设1对应心脏病，0对应没有心脏病；心脏病为正类，无心脏病为负类。现在假设分数是 0.6。这可能被解释为相关标签是心脏病的概率为 60%，相关标签没有心脏病的概率为 40%。这种对 sigmoid 输出的解释是 BCE 损失开始的动机（最终只是一个负对数似然）。

所以你可以做的是检查你的分数是否大于 0.5。如果是这样，预测心脏病。如果不是，则预测没有心脏病。

现在，您正在从维度 1 的分数计算最大值，这没有任何作用，因为维度 1 的大小已经为 1；取单个值的最大值只会为您提供该值。

尝试这样的事情：

def check_accuracy(loader,model):
  num_correct = 0
  num_samples = 0
  model.eval()

  with torch.no_grad():
    for x,y in loader:
      x = x.to(device=devicE)
      y = y.to(device=devicE)

      scores = model(x.float())
      // Create a Boolean tensor (True for scores > 0.5,false for others)
      // and then cast it to a long tensor (Trues -> 1,falses -> 0)
      preDictions = (scores > 0.5).long()
      num_correct += (preDictions == y).sum()
      num_samples += preDictions.size(0)
    
    print("Got {} / {} with accuracy {}".format(num_correct,num_samples,float(num_correct)/float(num_samples)*100))

  model.Train()