validation.py

import torch
from torch.autograd import Variable
import time
import sys

from utils import AverageMeter, calculate_accuracy

from opts import parse_opts

opt = parse_opts()
device = torch.device("cuda" if opt.use_cuda else "cpu")


def val_epoch(epoch, data_loader, model, criterion, opt, logger):
    print('validation at epoch {}'.format(epoch))

    model.eval()
    batch_time = AverageMeter()
    data_time = AverageMeter()
    losses = AverageMeter()
    accuracies = AverageMeter()

    end_time = time.time()

    with torch.no_grad():
        for i, (inputs, targets) in enumerate(data_loader):

            data_time.update(time.time() - end_time)

            inputs, targets = inputs.to(device), targets.to(device)

            inputs = Variable(inputs).float()
            targets = Variable(targets).long()


            outputs = model(inputs)

            loss = criterion(outputs, targets)
            acc = calculate_accuracy(outputs, targets)

            losses.update(float(loss), inputs.size(0))
            accuracies.update(float(acc), inputs.size(0))

            batch_time.update(time.time() - end_time)
            end_time = time.time()


            print('Epoch: [{0}][{1}/{2}]\t'
              'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
              'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
              'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
              'Acc {acc.val:.3f} ({acc.avg:.3f})'.format(
            epoch,
            i + 1,
            len(data_loader),
            batch_time=batch_time,
            data_time=data_time,
            loss=losses,
            acc=accuracies))

        logger.log({'epoch': epoch, 'loss': losses.avg, 'acc': accuracies.avg})


    return losses.avg