def evaluate_one_epoch()

in downstream/votenet/lib/ddp_trainer.py [0:0]

• 44 lines of code
• 23 McCabe index (conditional complexity)

    def evaluate_one_epoch(self, epoch_cnt):
        np.random.seed(0)
        stat_dict = {} # collect statistics

        ap_calculator = APCalculator(ap_iou_thresh=self.config.test.ap_iou, class2type_map=self.dataset_config.class2type)
        self.net.eval() # set model to eval mode (for bn and dp)
        for batch_idx, batch_data_label in enumerate(self.test_dataloader):
            if batch_idx % 10 == 0:
                logging.info('Eval batch: %d'%(batch_idx))
            for key in batch_data_label:
                if key == 'scan_name':
                    continue
                batch_data_label[key] = batch_data_label[key].cuda()
            
            # Forward pass
            inputs = {'point_clouds': batch_data_label['point_clouds']}
            if 'voxel_coords' in batch_data_label:
                inputs.update({
                    'voxel_coords': batch_data_label['voxel_coords'],
                    'voxel_inds':   batch_data_label['voxel_inds'],
                    'voxel_feats':  batch_data_label['voxel_feats']})

            with torch.no_grad():
                end_points = self.net(inputs)

            # Compute loss
            for key in batch_data_label:
                assert(key not in end_points)
                end_points[key] = batch_data_label[key]
            loss, end_points = criterion(end_points, self.dataset_config)

            # Accumulate statistics and print out
            for key in end_points:
                if 'loss' in key or 'acc' in key or 'ratio' in key:
                    if key not in stat_dict: stat_dict[key] = 0
                    stat_dict[key] += end_points[key].item()

            batch_pred_map_cls = parse_predictions(end_points, self.CONFIG_DICT) 
            batch_gt_map_cls = parse_groundtruths(end_points, self.CONFIG_DICT) 
            ap_calculator.step(batch_pred_map_cls, batch_gt_map_cls)

            # Dump evaluation results for visualization
            if self.config.data.dump_results and batch_idx == 0 and epoch_cnt %10 == 0 and self.is_master:
                dump_results(end_points, 'results', self.dataset_config) 

        # Log statistics
        logging.info('eval mean %s: %f'%(key, stat_dict[key]/(float(batch_idx+1))))
        if self.is_master:
            for key in sorted(stat_dict.keys()):
                self.writer.add_scalar('validation/{}'.format(key), stat_dict[key]/float(batch_idx+1),
                                (epoch_cnt+1)*len(self.train_dataloader)*self.config.data.batch_size)

        # Evaluate average precision
        metrics_dict = ap_calculator.compute_metrics()
        for key in metrics_dict:
            logging.info('eval %s: %f'%(key, metrics_dict[key]))
        if self.is_master:
            self.writer.add_scalar('validation/mAP{}'.format(self.config.test.ap_iou), metrics_dict['mAP'], (epoch_cnt+1)*len(self.train_dataloader)*self.config.data.batch_size)
        #mean_loss = stat_dict['loss']/float(batch_idx+1)

        return metrics_dict['mAP']