怎么在Pytorch中求模型准确率

这篇文章给大家介绍怎么在Pytorch中求模型准确率，内容非常详细，感兴趣的小伙伴们可以参考借鉴，希望对大家能有所帮助。

方法一：直接在epoch过程中求取准确率

简介：此段代码是LeNet5中截取的。

def train_model(model,train_loader):    optimizer = torch.optim.Adam(model.parameters())    loss_func = nn.CrossEntropyLoss()    EPOCHS = 5    for epoch in range(EPOCHS):        correct = 0        for batch_idx,(X_batch,y_batch) in enumerate(train_loader):            optimizer.zero_grad()            #这里是只取训练数据的意思吗，X_batch和y_batch是怎么分开的?            #答：X_batch和y_batch是一一对应的，只不过顺序打乱了，参考torch.utils.data.ipynb            output = model(X_batch.float())   #X_batch.float()是什么意思            loss = loss_func(output,y_batch)            loss.backward()            optimizer.step()                        # Total correct predictions            #第一个1代表取每行的最大值，第二个1代表只取最大值的索引             #这两行代码是求准确率的地方            predicted = torch.max(output.data,1)[1]            correct += (predicted == y_batch).sum()            #print(correct)            if batch_idx % 100 == 0:                print('Epoch :{}[{}/{}({:.0f}%)]\t Loss:{:.6f}\t Accuracy:{:.3f}'.format(epoch,batch_idx * len(X_batch),len(train_loader.dataset),100.*batch_idx / len(train_loader),loss.data.item(),float(correct*100)/float(BATCH_SIZE)*(batch_idx+1)))                if __name__ == '__main__':    myModel = LeNet5()    print(myModel)    train_model(myModel,train_loader)    evaluate(myModel,test_loader,BATCH_SIZE)

方法二：构建函数，然后在epoch中调用该函数

简介：此段代码是对Titanic(泰坦尼克号）数据分析截取。

epochs = 10log_step_freq = 30 dfhistory = pd.DataFrame(columns = ['epoch','loss',metric_name,'val_loss','val_'+metric_name])print('Start Training...')nowtime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')print('========='*8 + '%s'%nowtime) for epoch in range(1,epochs+1):        #1.训练循环    net.train()    loss_sum = 0.0    metric_sum = 0.0    step = 1        for step,(features,labels) in enumerate(dl_train,1):        #梯度清零        optimizer.zero_grad()                #正向传播求损失        predictions = net(features)        loss = loss_func(predictions,labels)        metric = metric_func(predictions,labels)                #反向传播求梯度        loss.backward()        optimizer.step()                #打印batch级别日志        loss_sum += loss.item()        metric_sum += metric.item()        if step%log_step_freq == 0:            print(('[Step = %d] loss: %.3f,' + metric_name+': %.3f %%')%(step,loss_sum/step,100*metric_sum/step))                #2,验证循环    net.eval()    val_loss_sum = 0.0    val_metric_sum = 0.0    val_step =1            for val_step,(features,labels) in enumerate(dl_valid,1):        #关闭梯度计算        with torch.no_grad():            pred = net(features)            val_loss = loss_func(pred,labels)            val_metric = metric_func(labels,pred)        val_loss_sum += val_loss.item()        val_metric_sum += val_metric.item()                #3,记录日志    info = (epoch,loss_sum/step,100*metric_sum/step,            val_loss_sum/val_step,100*val_metric_sum/val_step)    dfhistory.loc[epoch-1] = info            #打印epoch级别日志    print(('\nEPOCH = %d,loss = %.3f,' + metric_name+\            '=%.3f %%,val_loss = %.3f'+' val_'+metric_name+'= %.3f %%')%info)    nowtime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')    print('\n'+'=========='*8 + '%s'%nowtime)print('Finishing Training...')

补充：Pytorch实现Top1准确率和Top5准确率

之前一直不清楚Top1和Top5是什么，其实搞清楚了很简单，就是两种衡量指标，其中，Top1就是普通的Accuracy，Top5比Top1衡量标准更“严格”，

具体来讲，比如一共需要分10类，每次分类器的输出结果都是10个相加为1的概率值，Top1就是这十个值中最大的那个概率值对应的分类恰好正确的频率，而Top5则是在十个概率值中从大到小排序出前五个，然后看看这前五个分类中是否存在那个正确分类，再计算频率。

Pytorch实现如下：

def evaluteTop1(model, loader):    model.eval()        correct = 0    total = len(loader.dataset)    for x,y in loader:        x,y = x.to(device), y.to(device)        with torch.no_grad():            logits = model(x)            pred = logits.argmax(dim=1)            correct += torch.eq(pred, y).sum().float().item()        #correct += torch.eq(pred, y).sum().item()    return correct / totaldef evaluteTop5(model, loader):    model.eval()    correct = 0    total = len(loader.dataset)    for x, y in loader:        x,y = x.to(device),y.to(device)        with torch.no_grad():            logits = model(x)            maxk = max((1,5))　　　　　　　 y_resize = y.view(-1,1)            _, pred = logits.topk(maxk, 1, True, True)            correct += torch.eq(pred, y_resize).sum().float().item()    return correct / total

注意：

y_resize = y.view(-1,1)是非常关键的一步，在correct的运算中，关键就是要pred和y_resize维度匹配，而原来的y是[128]，128是batch大小；

pred的维度则是[128,10]，假设这里是CIFAR10十分类；因此必须把y转化成[128,1]这种维度，但是不能直接是y.view(128,1)，因为遍历整个数据集的时候，

最后一个batch大小并不是128，所以view()里面第一个size就设为-1未知，而确保第二个size是1就行

补充：topk函数的具体用法

pytorch -- topk()

torch.topk(input, k, dim=None, largest=True, sorted=True, out=None) -> (Tensor, LongTensor)

pytorch中文官网文档

沿给定dim维度返回输入张量input中 k 个最大值。

如果不指定dim，则默认为input的最后一维。

如果为largest为 False ，则返回最小的 k 个值。

返回一个元组 (values,indices)，其中indices是原始输入张量input中测元素下标。

如果设定布尔值sorted 为_True_，将会确保返回的 k 个值被排序。

参数

input (Tensor) – 输入张量

k (int) – “top-k”中的k

dim (int, optional) – 排序的维

largest (bool, optional) – 布尔值，控制返回最大或最小值

sorted (bool, optional) – 布尔值，控制返回值是否排序

out (tuple, optional) – 可选输出张量 (Tensor, LongTensor) output buffer

实例

假设神经网络的输出如下，为二分类。batch_size=4

import torch output = torch.tensor([[-5.4783, 0.2298],                           [-4.2573, -0.4794],                           [-0.1070, -5.1511],                           [-0.1785, -4.3339]])

得到其top1值操作如下：

maxk = max((1,))  # 取top1准确率，若取top1和top5准确率改为max((1,5))_, pred = output.topk(maxk, 1, True, True)

topk参数中，maxk取得是top1准确率，dim=1是按行取值， largest=1是取最大值

结果如下，

_tensor([[ 0.2298],        [-0.4794],        [-0.1070],        [-0.1785]])

predtensor([[1],        [1],        [0],        [0]])

_是top1的值，pred是最大值的索引（size=4*1），一般会进行转置处理同真实值对比

pytorch的优点

1.PyTorch是相当简洁且高效快速的框架；2.设计追求最少的封装；3.设计符合人类思维，它让用户尽可能地专注于实现自己的想法；4.与google的Tensorflow类似，FAIR的支持足以确保PyTorch获得持续的开发更新；5.PyTorch作者亲自维护的论坛 供用户交流和求教问题6.入门简单

关于怎么在Pytorch中求模型准确率就分享到这里了，希望以上内容可以对大家有一定的帮助，可以学到更多知识。如果觉得文章不错，可以把它分享出去让更多的人看到。