evaluator/sqa3d_eval.py

import os
import json
import collections
from pathlib import Path

import numpy as np
import torch

from data.data_utils import SQA3DAnswer
from evaluator.build import EVALUATOR_REGISTRY
import re

@EVALUATOR_REGISTRY.register()
class SQA3DEval():
    # 0: what, 1: is, 2: how, 3: can, 4: which, 5: others
    def __init__(self, cfg, task_name):
        self.eval_dict = {
            'target_metric': [], 'ans1_acc': [], 'ans10_acc': [], 'non_color_ans1_acc': [], 'non_color_ans10_acc': [],
            'type0_acc': [], 'type1_acc': [], 'type2_acc': [],
            'type0_acc': [], 'type1_acc': [], 'type2_acc': [],
            'type3_acc': [], 'type4_acc': [], 'type5_acc': []
        }
        # run
        self.total_count = 0
        self.non_color_total_count = 0
        self.type_count = {
            'type0_count': 1e-10, 'type1_count': 1e-10, 'type2_count': 1e-10,
            'type3_count': 1e-10, 'type4_count': 1e-10, 'type5_count': 1e-10
        }
        self.best_result = -np.inf
        self.base_dir = cfg.data.scan_family_base

        answer_data = json.load(
            open(os.path.join(self.base_dir,
                              'annotations/sqa_task/answer_dict.json'), encoding='utf-8')
        )[0]
        
        color_terms = [
            "orange", "pink", "maroon", "grey", "gray", "purple",
            "red", "yellow", "brown", "blue", "green", "silver", "gold",
            "tan", "turquoise", "beige", "white", "black", "chocolate",
            "multicolored",
            "black and red", "yellow and orange", "black white",
            "light brown", "dark brown",
            "balck", "whitec"  
        ]

        # Collect all color-related answers with their ids
        self.color_ids = [answer_data[name] for name in color_terms]
        answer_counter = []
        for data in answer_data.keys():
            answer_counter.append(data)
        answer_counter = collections.Counter(sorted(answer_counter))
        answer_cands = answer_counter.keys()
        self.answer_vocab = SQA3DAnswer(answer_cands)

        self.save = cfg.eval.save
        if self.save:
            self.eval_results = []
            self.save_dir = Path(cfg.exp_dir) / "eval_results" / task_name
            self.save_dir.mkdir(parents=True, exist_ok=True)

    def update(self, data_dict):
        metrics = self.batch_metrics(data_dict)
        batch_count = metrics['total_count']
        self.total_count += batch_count
        non_color_batch_count = metrics['non_color_total_count']
        self.non_color_total_count += non_color_batch_count
        for key in metrics:
            if 'type' in key and 'count' in key:
                self.type_count[key] += metrics[key]

        if self.save:
            for i in range(metrics["total_count"]):
                self.eval_results.append({
                    # vision
                    "source": data_dict['source'][i],
                    "scan_id": data_dict['scan_id'][i],
                    "anchor": data_dict['anchor_locs'][i],
                    'anchor_ort': data_dict['anchor_orientation'][i],
                    # language
                    "instruction": data_dict['prompt_after_obj'][i],
                    "response_gt": data_dict['answer_list'][i].split('[answer_seq]'),
                    "response_pred": data_dict['output_text'][i]
                })

        # save eval dict
        for key in self.eval_dict.keys():
            if 'type' in key:
                self.eval_dict[key].append(float(metrics[key]) * metrics['type' + key[4] + '_count'])
            elif 'non_color' not in key:
                self.eval_dict[key].append(float(metrics[key]) * batch_count)
            else:
                self.eval_dict[key].append(float(metrics[key]) * non_color_batch_count)

    def batch_metrics(self, data_dict):
        metrics = {}

        # ans
        choice_1 = data_dict['answer_scores'].argmax(dim=-1)
        choice_10 = torch.topk(data_dict['answer_scores'].detach(), 10, -1)[1]
        
        correct1 = 0
        correct10 = 0
        
        non_color_correct1 = 0
        non_color_correct10 = 0
        total_non_color = 0
        
        correct_type = {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0}
        count_type = {0: 1e-10, 1: 1e-10, 2: 1e-10, 3: 1e-10, 4: 1e-10, 5: 1e-10}
        for i in range(data_dict['answer_label'].shape[0]):
            gt_id = data_dict['answer_label'][i].argmax().item()
            if gt_id not in self.color_ids:
                total_non_color += 1
            
            count_type[data_dict['sqa_type'][i].item()] += 1
            if data_dict['answer_label'][i, choice_1[i]] == 1:
                if choice_1[i] not in self.color_ids:
                    non_color_correct1 += 1
                correct1 += 1
                correct_type[data_dict['sqa_type'][i].item()] += 1
            for j in range(10):
                if data_dict['answer_label'][i, choice_10[i, j]] == 1:
                    if choice_10[i,j] not in self.color_ids:
                        non_color_correct10 += 1
                    correct10 += 1
                    break
                
        metrics['ans1_acc'] = correct1 / float(len(choice_1))
        metrics['ans10_acc'] = correct10 / float(len(choice_1))
        
        metrics['non_color_ans1_acc'] = non_color_correct1 / float(total_non_color)
        metrics['non_color_ans10_acc'] = non_color_correct10 / float(total_non_color)

        # question type acc
        for key in count_type.keys():
            metrics['type' + str(key) + '_acc'] = correct_type[key] / count_type[key]
            metrics['type' + str(key) + '_count'] = count_type[key]

        metrics['target_metric'] = metrics['ans1_acc']
        metrics["total_count"] = data_dict["answer_scores"].shape[0]
        metrics["non_color_total_count"] = total_non_color
        return metrics

    def reset(self):
        for key in self.eval_dict.keys():
            self.eval_dict[key] = []
        self.total_count = 0
        self.non_color_total_count = 0
        self.type_count = {
            'type0_count': 1e-10, 'type1_count': 1e-10, 'type2_count': 1e-10, 
            'type3_count': 1e-10, 'type4_count': 1e-10, 'type5_count': 1e-10
        }
        if self.save:
            self.eval_results = []

    def record(self, split='val'):
        # record
        for k, v in self.eval_dict.items():
            if k == "answer_top10":
                continue
            if 'type' in k:
                self.eval_dict[k] = sum(v) / self.type_count['type' + k[4] + '_count']
            elif 'non_color' not in k:
                self.eval_dict[k] = sum(v) / self.total_count
                print(k, 'overall', sum(v), self.total_count)
            elif 'non_color' in k:
                self.eval_dict[k] = sum(v) / self.non_color_total_count
                print(k, 'non_color', sum(v), self.non_color_total_count)

        if self.eval_dict["target_metric"] > self.best_result:
            is_best = True
            self.best_result = self.eval_dict["target_metric"]
        else:
            is_best = False

        if self.save and (is_best or split == 'test'):
            torch.save(self.eval_results, str(self.save_dir / 'results.pt'))

        return is_best, self.eval_dict