def validate()

in py/validate.py [0:0]

• 59 lines of code
• 8 McCabe index (conditional complexity)

def validate(val_loader, limit, fpga_h=None, reference_model=None):
    batch_time = AverageMeter()
    losses = AverageMeter()
    top1 = AverageMeter()
    top5 = AverageMeter()
    end = time.time()

    ref_batch_time = AverageMeter()
    ref_losses = AverageMeter()
    ref_top1 = AverageMeter()
    ref_top5 = AverageMeter()
    ref_end = time.time()

    limit = limit or -1

    criterion = nn.CrossEntropyLoss()

    count = 0
    for i, (input, target) in enumerate(val_loader):
        count = count + 1
        if (count > limit and not (limit == -1)):
            break

        if (fpga_h):
            end = time.time()
#            fpga_h.forward_p(input)

        if (reference_model):
            ref_end = time.time()
            ref_output = reference_model.forward(input)
#            ref_target_var = torch.autograd.Variable(target, volatile=True)
            ref_target_var = torch.autograd.Variable(target)
            ref_loss = criterion(ref_output, ref_target_var)

            prec1, prec5 = accuracy(ref_output, target, topk=(1, 5))
            ref_losses.update(ref_loss.item(), input.size(0))
            ref_top1.update(prec1[0], input.size(0))
            ref_top5.update(prec5[0], input.size(0))

            # measure elapsed time
            ref_batch_time.update(time.time() - ref_end)

            print('CPU float32:       [{0}/{1}]\t'
                  'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
                  'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
                  'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
                  'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format(
                      (i + 1) * val_loader.batch_size,
                      len(val_loader) * val_loader.batch_size,
                      batch_time=ref_batch_time, loss=ref_losses,
                      top1=ref_top1, top5=ref_top5))
            sys.stdout.flush()

        if (fpga_h):

#            output = fpga_h.forward_f()
            output = fpga_h.forward(input)
#            target_var = torch.autograd.Variable(target, volatile=True)
            target_var = torch.autograd.Variable(target)
            loss = criterion(output, target_var)

            prec1, prec5 = accuracy(output, target, topk=(1, 5))
            losses.update(loss.item(), input.size(0))
            top1.update(prec1[0], input.size(0))
            top5.update(prec5[0], input.size(0))

            # measure elapsed time
            batch_time.update(time.time() - end)

            print('FPGA: [{0}/{1}]\t'
                  'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
                  'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
                  'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
                  'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format(
                      (i + 1) * val_loader.batch_size,
                      len(val_loader) * val_loader.batch_size,
                      batch_time=batch_time, loss=losses,
                      top1=top1, top5=top5))
            sys.stdout.flush()