• 企业400电话
  • 微网小程序
  • AI电话机器人
  • 电商代运营
  • 全 部 栏 目

    企业400电话 网络优化推广 AI电话机器人 呼叫中心 网站建设 商标✡知产 微网小程序 电商运营 彩铃•短信 增值拓展业务
    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 = 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实现如下:

    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()

    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

    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]])
    pred
    tensor([[1],
            [1],
            [0],
            [0]])

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

    以上为个人经验,希望能给大家一个参考,也希望大家多多支持脚本之家。

    您可能感兴趣的文章:
    • 在pytorch中计算准确率,召回率和F1值的操作
    • Pytorch 实现计算分类器准确率(总分类及子分类)
    • Pytorch 计算误判率,计算准确率,计算召回率的例子
    • pytorch绘制并显示loss曲线和acc曲线,LeNet5识别图像准确率
    上一篇:Python集成学习之Blending算法详解
    下一篇:pytorch 如何打印网络回传梯度
  • 相关文章
  • 

    © 2016-2020 巨人网络通讯 版权所有

    《增值电信业务经营许可证》 苏ICP备15040257号-8

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