个人中心
gpt4 book ai didi

Pytorch中求模型准确率的两种方法小结

转载 作者：qq735679552 更新时间：2022-09-27 22:32:09 26 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Pytorch中求模型准确率的两种方法小结由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

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

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
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(泰坦尼克号）数据分析截取.

Pytorch中求模型准确率的两种方法小结

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
epochs = 10
log_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实现如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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 / total
 
def 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()

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

沿给定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 。

?
1
2
3
4
5
import torch
output = torch.tensor([[ - 5.4783 , 0.2298 ],
                            [ - 4.2573 , - 0.4794 ],
                            [ - 0.1070 , - 5.1511 ],
                            [ - 0.1785 , - 4.3339 ]])

得到其top1值操作如下:

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

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

结果如下， 。

?
1
2
3
4
5
_
tensor([[ 0.2298 ],
         [ - 0.4794 ],
         [ - 0.1070 ],
         [ - 0.1785 ]])
?
1
2
3
4
5
pred
tensor([[ 1 ],
         [ 1 ],
         [ 0 ],
         [ 0 ]])

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

以上为个人经验，希望能给大家一个参考，也希望大家多多支持我.

原文链接：https://blog.csdn.net/zihao_c/article/details/109400124 。

最后此篇关于Pytorch中求模型准确率的两种方法小结的文章就讲到这里了,如果你想了解更多关于Pytorch中求模型准确率的两种方法小结的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

26 4 0
文章推荐： director.js实现前端路由使用实例
文章推荐： JSON.parseObject和JSON.toJSONString实例详解
文章推荐： js与jquery回车提交的方法
文章推荐： Python集成学习之Blending算法详解
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com