关于计算loss

一、

def train(model, device, train_loader, optimizer, epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = F.nll_loss(output, target)
        loss.backward()
        optimizer.step()
        if(batch_idx+1)%30 == 0: 
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
                100. * batch_idx / len(train_loader), loss.item()))

for epoch in range(1, EPOCHS + 1):
    train(model, DEVICE, train_loader, optimizer, epoch)

Train Epoch: 1 [14848/60000 (25%)] Loss: 0.272529
Train Epoch: 1 [30208/60000 (50%)] Loss: 0.235455
Train Epoch: 1 [45568/60000 (75%)] Loss: 0.101858
上述计算的是一个迭代步的loss

二、
当数据量大，每10迭代输出一次loss时，
每一轮的迭代次数是len(dataset) // batch_size

   for epoch in range(Start_iter,Freeze_epoch):
       if epoch%2 == 0:
           adjust_learning_rate(optimizer,lr,0.7,epoch)
       loc_loss = 0
       conf_loss = 0
       for iteration,batch in enumerate(gen):
           if iteration >= epoch_size:
               break
           images,targets = batch[0],batch[1]
           with torch.no_grad():
               if Cuda:
                   images = Variable(torch.from_numpy(images).type(torch.FloatTensor)).cuda()
                   targets = [Variable(torch.from_numpy(ann).type(torch.FloatTensor)).cuda() for ann in targets]
               else:
                   images = Variable(torch.from_numpy(images).type(torch.FloatTensor))
                   targets = [Variable(torch.from_numpy(ann).type(torch.FloatTensor)) for ann in targets]

           # 前向传播
           out = net(images)
           # 梯度清零
           optimizer.zero_grad()
           # 计算loss
           loss_l,loss_c = criterion(out,targets)
           loss = loss_l + loss_c
           # 反向传播
           loss.backward()
           optimizer.step()

           # 加上
           loc_loss += loss_l.item()
           conf_loss += loss_c.item()

           print('\nEpoch:'+str(epoch+1) + '/' + str(Epoch))
           print('iter:' + str(iteration) + '/' + str(epoch_size) +
                 ' || Loc_Loss: %.4f || Conf_Loss: %.4f ||'% (loc_loss/(iteration+1),conf_loss/(iteration+1)),end=' ')

loc_loss 和conf_loss 是每迭代一次，累计一次，每一轮都置为0.

loc_loss/(iteration+1)求的是每轮中前iteration+1的平均loss，计算的是每迭代次的

loss.item() pytorch中，.item()方法 是得到一个元素张量里面的元素值
具体就是 用于将一个零维张量转换成浮点数。