Function validate

lib/core_function.py:172–275

(cfg, model, critetion, epoch, data_loader, logger, writer, devices, valIters, metrics_base='combine')

def validate(cfg, model, critetion, epoch, data_loader, logger, writer, devices, valIters, metrics_base='combine'):
    calculate_acc = get_acc_mesure_func(metrics_base)
    batch_time = AverageMeter()
    data_time = AverageMeter()
    losses = AverageMeter()
    acc = AverageMeter()
    
    #Switch to test mode
    model.eval()
    data_loader = tqdm(data_loader, dynamic_ncols=True)
    start = time.time()
    with torch.no_grad():
        for i, batch_data in enumerate(data_loader):
            inputs, labels, targets, heatmaps, cstency_heatmaps, offsets = get_batch_data(batch_data)
            inputs = inputs.to(devices, non_blocking=True, dtype=torch.float64).cuda()
            #Measuring data loading time
            data_time.update(time.time() - start)
            
            outputs = model(inputs)
            if isinstance(outputs, list):
                outputs = outputs[0]
            #In case outputs contain a dict key
            if isinstance(outputs, dict):
                outputs_hm = outputs['hm']
                outputs_cls = outputs['cls']
                outputs_offset = outputs['offset'] if 'offset' in outputs.keys() else None
                outputs_cstency = outputs['cstency'] if 'cstency' in outputs.keys() else None

            if 'Combined' in cfg.TRAIN.loss.type:
                labels = labels.cuda().to(non_blocking=True, dtype=torch.float64)
                # labels = labels.cuda().to(non_blocking=True).long()
                
                if offsets is not None:
                    offsets = offsets.cuda().to(non_blocking=True, dtype=torch.float64)
                
                if cstency_heatmaps is not None:
                    cstency_heatmaps = cstency_heatmaps.cuda().to(non_blocking=True, dtype=torch.float64)
                
                if cfg.TRAIN.loss.type != 'CombinedHeatmapBinaryLoss':
                    heatmaps = heatmaps.cuda().to(non_blocking=True, dtype=torch.float64)
                else:
                    heatmaps = targets.cuda().to(non_blocking=True, dtype=torch.float64)
                    
                loss_ = critetion(outputs_hm, heatmaps, outputs_cls.sigmoid(), labels, 
                                  offset_preds=outputs_offset, 
                                  offset_gts=offsets,
                                  cstency_preds=outputs_cstency,
                                  cstency_gts=cstency_heatmaps)
                loss = loss_['hm']
                if 'cls' in loss_.keys():
                    loss += loss_['cls']
                if 'dst_hm_cls' in loss_.keys():
                    loss += loss_['dst_hm_cls']
                if 'offset' in loss_.keys():
                    loss += loss_['offset']
                if 'cstency' in loss_.keys():
                    loss += loss_['cstency']
            else: