Pytorch中求模型準確率的兩種方法小結

Posted on by

方法一：直接在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），一般會進行轉置處理同真實值對比

以上為個人經驗，希望能給大傢一個參考，也希望大傢多多支持WalkonNet。

推薦閱讀：