v1

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

app.py

@@ -99,7 +99,8 @@ def bot_streaming(message, history):
         time.sleep(0.02)
         yield buffer
 
-demo = gr.ChatInterface(fn=bot_streaming, title="☄️ Meteor", 
+demo = gr.ChatInterface(fn=bot_streaming, title="☄️ Meteor",
+                        examples=[{"text": "Show the detailed recipe for this dish.", "files":["./lobster.jpg"]}],
                         description="Meteor is efficient 7B size Large Language and Vision Model built on the help of traversal of rationale",
                         stop_btn="Stop Generation", multimodal=True)
 demo.launch()

eval/create_evaluator.py

@@ -1,529 +0,0 @@
-import os
-import re
-import json
-import shortuuid
-import numpy as np
-import pandas as pd
-from config import *
-from collections import defaultdict
-from eval.utils import *
-
-class BaseEvaluator:
-    def __init__(self):
-        super(BaseEvaluator, self).__init__()
-
-        # Create evaluation results folder
-        self.save_dir = os.path.join(DATASET_ROOT, "eval_results")
-        if not os.path.exists(self.save_dir):
-            os.makedirs(self.save_dir)
-
-    def reset(self):
-        # Reset results for new dataset evaluation
-        self.gen_answers = []
-        self.inputs = []
-    
-    def process(self, inputs, outputs):
-        # Merge results
-        self.inputs.extend(inputs)
-        self.gen_answers.extend(outputs)
-
-class Evaluator(BaseEvaluator):
-    def __init__(self):
-        """
-        Eval Datasets
-
-        - VQAv2
-        - GQA
-        - SQA-IMG
-        - VizWiz
-        - TextVQA
-        - POPE
-        - MME
-        - MMBench
-        - MMBench-CN
-        - QBench
-        - MM-Vet
-        - MMMU
-        - MathVista
-        - AI2D
-        - HallusionBench
-        - ChartQA
-        - SEED
-        - LLaVA Wild
-        - BLINK
-        - MathVerse
-
-        """
-              
-        super().__init__()
-    
-    def evaluate(self, model, dataset, accel):
-
-        # gathering all gpu to one device
-        self.inputs = accel.gather_for_metrics(self.inputs)
-        self.gen_answers = accel.gather_for_metrics(self.gen_answers)
-        
-        if accel.is_main_process:
-            # check for duplicates
-            self.inputs, self.gen_answers = remove_duplicate(dataset, self.inputs, self.gen_answers)
-
-            # Select evaluation for dataset
-            if dataset == "vqav2":
-                return self.evaluate_vqa(model, accel)
-            elif dataset == "gqa":
-                return self.evaluate_gqa(model, accel)
-            elif dataset == "sqa":
-                return self.evaluate_sqa(model, accel)
-            elif dataset == "vizwiz":
-                return self.evaluate_vizwiz(model, accel)
-            elif dataset == "textvqa":
-                return self.evaluate_textvqa(model, accel)
-            elif dataset == "pope":
-                return self.evaluate_pope(model, accel)
-            elif dataset == "mme":
-                return self.evaluate_mme(model, accel)
-            elif dataset == "mmbench":
-                return self.evaluate_mmbench(model, accel)
-            elif dataset == "mmbench_dev":
-                return self.evaluate_mmbench_dev(model, accel)
-            elif dataset == "mmbench_cn":
-                return self.evaluate_mmbench_cn(model, accel)
-            elif dataset == "mmbench_cn_dev":
-                return self.evaluate_mmbench_cn_dev(model, accel)
-            elif dataset == "qbench":
-                return self.evaluate_qbench(model, accel)
-            elif dataset == "mm-vet":
-                return self.evaluate_mmvet(model, accel)
-            elif dataset == "mmmu":
-                return self.evaluate_mmmu(model, accel)
-            elif dataset == "mathvista":
-                return self.evaluate_mathvista(model, accel)
-            elif dataset == "ai2d":
-                return self.evaluate_ai2d(model, accel)
-            elif dataset == "hallusionbench":
-                return self.evaluate_hallusionbench(model, accel)
-            elif dataset == "chartqa":
-                return self.evaluate_chartqa(model, accel)
-            elif dataset == "seed":
-                return self.evaluate_seed(model, accel)
-            elif dataset == "llava":
-                return self.evaluate_llava(model, accel)
-            elif dataset == "blink":
-                return self.evaluate_blink(model, accel)
-            elif dataset == "mathverse":
-                return self.evaluate_mathverse(model, accel)
-            elif dataset == "mmstar":
-                return self.evaluate_mmstar(model, accel)
-            else:
-                raise ValueError(
-                    f'{dataset} is not an available dataset.')
-        else:
-            return None
-        
-    def evaluate_vqa(self, model, accel):
-        # VQAv2 Evaluation for EvalAI server
-        pred_answers = [{'question_id': inputs['id'], 'answer': answer} for inputs, answer in zip(self.inputs, self.gen_answers)]
-        pred_pth = os.path.join(self.save_dir, f"{model}_vqav2_results.json")
-        json.dump(pred_answers, open(pred_pth, "w"))
-        accel.print(f"Finished evaluating VQAv2. Evaluate the result file saved to {pred_pth} on EvalAI server.")
-        return 
-    
-    def evaluate_gqa(self, model, accel):
-        # GQA Evaluation
-        pred_answers = {inputs['id']: answer for inputs, answer in zip(self.inputs, self.gen_answers)}
-        # pred_answers = [{'question_id': inputs['id'], 'answer': answer} for inputs, answer in zip(self.inputs, self.gen_answers)]
-        pred_pth = os.path.join(self.save_dir, f"{model}_gqa_results.json")
-        json.dump(pred_answers, open(pred_pth, "w"))
-        accel.print("GQA Results:")
-        results = eval_gqa(pred_answers, json.load(open(os.path.join(DATASET_ROOT, GQA))))
-        return results['accuracy']
-    
-    def evaluate_sqa(self, model, accel):
-        # SQA Evaluation
-        pred_answers = [{'question_id': inputs['id'], 'answer': convert_to_choice(answer, inputs['candidates']), 'gt': inputs['gt']} for inputs, answer in zip(self.inputs, self.gen_answers)]
-        pred_pth = os.path.join(self.save_dir, f"{model}_sqa_results.json")
-        json.dump(pred_answers, open(pred_pth, "w"))
-
-        # Compute accuracy
-        results = [(answer['answer'] == answer['gt']) for answer in pred_answers]
-        accel.print (f"SQA Accuracy: {np.mean(results)*100} %")
-        return np.mean(results)*100
-    
-    def evaluate_vizwiz(self, model, accel):
-        # VizWiz Evaluation
-        evaluator = EvalAIAnswerProcessor()
-        pred_answers = [{'image': inputs['id'], 'answer': evaluator(answer)} for inputs, answer in zip(self.inputs, self.gen_answers)]
-        pred_pth = os.path.join(self.save_dir, f"{model}_vizwiz_results.json")
-        json.dump(pred_answers, open(pred_pth, "w"))
-        accel.print(f"Finished evaluating VizWiz. Evaluate the result file saved to {pred_pth} on EvalAI server.")
-        return 
-    
-    def evaluate_textvqa(self, model, accel):
-        # TextVQA Evaluation
-        pred_answers = [{'question_id': inputs['id'], 'pred_answer': answer, 'question': inputs['question'], 'gt_answers': inputs['gt']} for inputs, answer in zip(self.inputs, self.gen_answers)]
-        pred_pth = os.path.join(self.save_dir, f"{model}_textvqa_results.json")
-        json.dump(pred_answers, open(pred_pth, "w"))
-            
-        evaluator = TextVQAAccuracyEvaluator()
-        results = evaluator.eval_pred_list(pred_answers)*100
-        accel.print (f"TextVQA Accuracy: {results} %")
-        return results
-    
-    def evaluate_pope(self, model, accel):
-        # POPE Evaluation
-        pred_answers = [{'question_id': inputs['id'], 'answer': answer, 'question': inputs['question'], 'category': inputs['category']} for inputs, answer in zip(self.inputs, self.gen_answers)]
-        pred_pth = os.path.join(self.save_dir, f"{model}_pope_results.json")
-        json.dump(pred_answers, open(pred_pth, "w"))
-
-        pope_results = {}
-        pope_results['adversarial'] = None
-        pope_results['popular'] = None
-        pope_results['random'] = None
-
-        categories = ['adversarial', 'popular', 'random']
-        files = [POPE_ADVERSARIAL, POPE_POPULAR, POPE_RANDOM]
-
-        for category, file in zip(categories, files):
-            cur_answers = [x for x in pred_answers if x['category'] == category]
-            cur_answers = sorted(cur_answers, key=lambda x:x["question_id"])
-            pope_results[category] = eval_pope(cur_answers, os.path.join(DATASET_ROOT, file))
-        accel.print (f"POPE Adversarial Accuracy: {pope_results['adversarial']} %")
-        accel.print (f"POPE Popular Accuracy: {pope_results['popular']} %")
-        accel.print (f"POPE Random Accuracy: {pope_results['random']} %")
-        return pope_results
-    
-    def evaluate_mme(self, model, accel):
-        # MME Evaluation
-        pred_answers = [{'question_id': inputs['id'], 'answer': answer,  "question": inputs['question'], 'category': inputs['category']} for inputs, answer in zip(self.inputs, self.gen_answers)]
-        pred_pth = os.path.join(self.save_dir, f"{model}_mme_results.json")
-        json.dump(pred_answers, open(pred_pth, "w"))
-
-        ground_truth = get_gt(data_path=os.path.join(DATASET_ROOT, MME_DIR))
-        result_dir = os.path.join(self.save_dir, 'mme')
-        os.makedirs(result_dir, exist_ok=True)
-        results = defaultdict(list)
-
-        for answer in pred_answers:
-            file = answer['question_id'].split('/')[-1].split('.')[0] + '.txt'
-            results[answer['category']].append((file, answer['question'], answer['answer']))
-
-        for category, cate_tups in results.items():
-            with open(os.path.join(result_dir, f'{category}.txt'), 'w') as fp:
-                questions = set() # check for duplicates
-                for file, prompt, answer in cate_tups:
-                    if 'Answer the question using a single word or phrase.' in prompt:
-                        prompt = prompt.replace('Answer the question using a single word or phrase.', '').strip()
-                    if 'Please answer yes or no.' not in prompt:
-                        prompt = prompt + ' Please answer yes or no.'
-                        if (category, file, prompt) not in ground_truth:
-                            prompt = prompt.replace(' Please answer yes or no.', '  Please answer yes or no.')
-                    gt_ans = ground_truth[category, file, prompt]
-                    dup = file, prompt, gt_ans
-                    tup = file, prompt, gt_ans, answer
-                    if dup in questions:
-                        continue
-                    questions.add(dup)
-                    fp.write('\t'.join(tup) + '\n')
-
-        evaluator = MMEEvaluator()
-        scores = evaluator.process_result(result_dir)
-        accel.print("MME Scores:")
-        accel.print(scores)
-        for eval_type, eval_scores in scores.items():
-            accel.print("===========", eval_type, "===========")
-            accel.print("total score:", eval_scores['total'], "\n")
-            for task_name, score in eval_scores.items():
-                accel.print("\t", task_name, " score:", score)
-            accel.print("\n")
-        return scores
-    
-    def evaluate_mmbench(self, model, accel):
-        # MMBench Evaluation
-        df = pd.read_table(os.path.join(DATASET_ROOT, MMBENCH))
-        cur_df = df.copy()
-        cur_df = cur_df.drop(columns=['hint', 'category', 'source', 'image', 'comment', 'l2-category'])
-        cur_df.insert(6, 'prediction', None)
-        for inputs, answer in zip(self.inputs, self.gen_answers):
-            cur_df.loc[df['index'] == inputs['id'], 'prediction'] = answer
-        pred_pth = os.path.join(self.save_dir, f"{model}_mmbench_results.xlsx")
-        cur_df.to_excel(pred_pth, index=False, engine='openpyxl')
-        accel.print(f"Finished evaluating MMBench. Change {pred_pth} name to submission.xlsx and evaluate the result file saved to {pred_pth} on OpenCompass server.")
-        return 
-    
-    def evaluate_mmbench_dev(self, model, accel):
-        # MMBench Dev Evaluation
-        df = pd.read_table(os.path.join(DATASET_ROOT, MMBENCH_DEV))
-        cur_df = df.copy()
-        cur_df = cur_df.drop(columns=['hint', 'category', 'source', 'image', 'comment', 'l2-category'])
-        cur_df.insert(6, 'prediction', None)
-        for inputs, answer in zip(self.inputs, self.gen_answers):
-            cur_df.loc[df['index'] == inputs['id'], 'prediction'] = answer[0]
-        pred_pth = os.path.join(self.save_dir, f"{model}_mmbench_dev_results.xlsx")
-        cur_df.to_excel(pred_pth, index=False, engine='openpyxl')
-        accuracy = (cur_df['prediction'] == cur_df['answer']).mean()
-        accel.print(f'MMBench_dev Accuracy: {accuracy:.2%}')
-        return 
-    
-    def evaluate_mmbench_cn(self, model, accel):
-        # MMBench_CN Evaluation
-        df = pd.read_table(os.path.join(DATASET_ROOT, MMBENCH_CN))
-        cur_df = df.copy()
-        cur_df = cur_df.drop(columns=['hint', 'category', 'source', 'image', 'comment', 'l2-category'])
-        cur_df.insert(6, 'prediction', None)
-        for inputs, answer in zip(self.inputs, self.gen_answers):
-            cur_df.loc[df['index'] == inputs['id'], 'prediction'] = answer
-        pred_pth = os.path.join(self.save_dir, f"{model}_mmbench_cn_results.xlsx")
-        cur_df.to_excel(pred_pth, index=False, engine='openpyxl')
-        accel.print(f"Finished evaluating MMBench_CN. Change {pred_pth} name to submission.xlsx and evaluate the result file saved to {pred_pth} on OpenCompass server.")
-        return 
-    
-    def evaluate_mmbench_cn_dev(self, model, accel):
-        # MMBench_CN Dev Evaluation
-        df = pd.read_table(os.path.join(DATASET_ROOT, MMBENCH_CN_DEV))
-        cur_df = df.copy()
-        cur_df = cur_df.drop(columns=['hint', 'category', 'source', 'image', 'comment', 'l2-category'])
-        cur_df.insert(6, 'prediction', None)
-        for inputs, answer in zip(self.inputs, self.gen_answers):
-            cur_df.loc[df['index'] == inputs['id'], 'prediction'] = answer[0]
-        pred_pth = os.path.join(self.save_dir, f"{model}_mmbench_cn_dev_results.xlsx")
-        cur_df.to_excel(pred_pth, index=False, engine='openpyxl')
-        accuracy = (cur_df['prediction'] == cur_df['answer']).mean()
-        accel.print(f'MMBench_CN_dev Accuracy: {accuracy:.2%}')
-        return 
-    
-    def evaluate_qbench(self, model, accel):
-        # QBench Evaluation
-        pred_answers = [{'id': inputs['id'], 'answer': convert_to_choice(answer, inputs['candidates']), 'gt': inputs['gt'], 'candidates': inputs['candidates']} for inputs, answer in zip(self.inputs, self.gen_answers)]
-        pred_pth = os.path.join(self.save_dir, f'{model}_qbench_results.jsonl')
-        with open(pred_pth, "w") as pf:
-            pf.write(json.dumps(pred_answers) + "\n")
-
-        results = [(pred['candidates'][pred['answer']] == pred['gt']) for pred in pred_answers]
-        accel.print (f"QBench Accuracy: {np.mean(results)*100} %")
-        return np.mean(results)*100
-    
-    def evaluate_mmvet(self, model, accel):
-        # MM-Vet Evaluation
-        cur_result = {f"{inputs['id']}": answer for inputs, answer in zip(self.inputs, self.gen_answers)}
-        pred_pth = os.path.join(self.save_dir, f'{model}_mmvet_results.json')
-        with open(pred_pth, 'w') as f:
-            json.dump(cur_result, f, indent=2)
-        
-        accel.print(f"Finished evaluating MM-Vet. Evaluate the result file saved to {pred_pth}.")
-        return 
-    
-    def evaluate_mmmu(self, model, accel):
-        # MMMU Evaluation
-        predictions = {inputs['id']: answer for inputs, answer in zip(self.inputs, self.gen_answers)}
-        answers = {inputs['id']: {'ground_truth': inputs['gt'], 'question_type': inputs['question_type']} for inputs, answer in zip(self.inputs, self.gen_answers)}
-        pred_pth = os.path.join(self.save_dir, f'{model}_mmmu_results.json')
-        with open(pred_pth, "w") as f:
-            json.dump(predictions, f, indent=2)
-        ans_pth = os.path.join(self.save_dir, 'mmmu_answers.json')
-        with open(ans_pth, "w") as pf:
-            json.dump(answers, pf, indent=2)
-
-        # group by category
-        output_dict_w_cat = {}
-        for data_id, parsed_pred in predictions.items():
-            category = "_".join(data_id.split("_")[1:-1])
-            if category not in output_dict_w_cat:
-                output_dict_w_cat.update({category: {}})
-            output_dict_w_cat[category].update({data_id: parsed_pred})
-
-        # group by category
-        answer_dict_w_cat = {}
-        for data_id, parsed_pred in answers.items():
-            category = "_".join(data_id.split("_")[1:-1])
-            if category not in answer_dict_w_cat:
-                answer_dict_w_cat.update({category: {}})
-            answer_dict_w_cat[category].update({data_id: parsed_pred})
-
-        evaluation_result = {}
-
-        for category in CAT_SHORT2LONG.values():
-            accel.print("Evaluating: {}".format(category))
-            # get cat_outputs and cat_answers
-            try:
-                cat_outputs = output_dict_w_cat[category]
-                cat_answers = answer_dict_w_cat[category]
-            except KeyError:
-                accel.print("Skipping {} for not found".format(category))
-                continue
-
-            exampels_to_eval = []
-            for data_id, parsed_pred in cat_outputs.items():
-                question_type = cat_answers[data_id]['question_type']
-                if question_type != 'multiple-choice':
-                    parsed_pred = parse_open_response(parsed_pred) # mainly for type consistency (make it number, etc.)
-                else:
-                    parsed_pred = parsed_pred
-
-                exampels_to_eval.append({
-                    "id": data_id,
-                    "question_type": question_type,
-                    "answer": cat_answers[data_id]['ground_truth'],
-                    "parsed_pred": parsed_pred
-                })
-
-            judge_dict, metric_dict = evaluate(exampels_to_eval)
-            metric_dict.update({"num_example": len(exampels_to_eval)})
-
-            evaluation_result[category] = metric_dict
-
-        printable_results = {}
-        # add domain Subject
-        for domain, in_domain_cats in DOMAIN_CAT2SUB_CAT.items():
-            in_domain_cat_results = {}
-            for cat_name in in_domain_cats: # use the order in DOMAIN_CAT2SUB_CAT
-                if cat_name in evaluation_result.keys():
-                    in_domain_cat_results[cat_name] = evaluation_result[cat_name]
-                else:
-                    pass
-            in_domain_ins_acc = calculate_ins_level_acc(in_domain_cat_results)
-            in_domain_data_num = sum([cat_results['num_example'] for cat_results in in_domain_cat_results.values()])
-            printable_results['Overall-' + domain] = {"num": int(in_domain_data_num),
-                                                    "acc": round(in_domain_ins_acc, 3)
-                                                    }
-            # add sub category
-            for cat_name, cat_results in in_domain_cat_results.items():
-                printable_results[cat_name] = {"num": int(cat_results['num_example']),
-                                            "acc": round(cat_results['acc'], 3)
-                                            }
-            
-        # table.append(["-----------------------------", "-----", "----"])
-        all_ins_acc = calculate_ins_level_acc(evaluation_result)
-        printable_results['Overall'] = {"num": sum([cat_results['num_example'] for cat_results in evaluation_result.values()]),
-                                        "acc": round(all_ins_acc, 3)
-                                        }
-
-        accel.print(printable_results)
-        return 
-    
-    def evaluate_mathvista(self, model, accel):
-        # MathVista Evaluation
-        pred_answers = [{'pid': inputs['id'], 'image': inputs['id'], 'response': answer, 
-                         'question_type': inputs['question_type'], 'answer_type': inputs['answer_type'], 'metadata': inputs['metadata'], 
-                         'choices': inputs['choices'], 'query': inputs['question'], 'precision': inputs['precision'],} for inputs, answer in zip(self.inputs, self.gen_answers)]
-        predictions = {pred['pid']: pred for pred in pred_answers}
-        pred_pth = os.path.join(self.save_dir, f"{model}_mathvista_results.json")
-        json.dump(predictions, open(pred_pth, "w"))
-        
-        accel.print(f"Finished evaluating MathVista. Evaluate the result file saved to {pred_pth}.")
-        return 
-    
-    def evaluate_ai2d(self, model, accel):
-        # AI2D Evaluation
-        pred_answers = [{'question_id': inputs['id'], 'answer': answer, 'gt': inputs['gt']} for inputs, answer in zip(self.inputs, self.gen_answers)]
-        pred_pth = os.path.join(self.save_dir, f"{model}_ai2d_results.json")
-        json.dump(pred_answers, open(pred_pth, "w"))
-
-        # Compute accuracy
-        pattern = re.compile(r'[A-Z]')
-        results = [(char_to_int(pattern.findall(answer)[0]) == inputs['gt']) for inputs, answer in zip(self.inputs, self.gen_answers)]
-
-        accel.print(f"AI2D Accuracy: {np.mean(results)*100} %")
-        return np.mean(results)*100
-    
-    def evaluate_hallusionbench(self, model, accel):
-        # HallusionBench Evaluation
-        pred_answers = [{'answer': '1' if answer.lower().find('yes') != -1 else '0', 'question': inputs['question'], 'gt': inputs['gt']} for inputs, answer in zip(self.inputs, self.gen_answers)]
-        pred_pth = os.path.join(self.save_dir, f"{model}_hallusionbench_results.json")
-        json.dump(pred_answers, open(pred_pth, "w"))
-
-        # Compute accuracy
-        results = [(answer['answer'] == answer['gt']) for answer in pred_answers]
-        accel.print(f"HallusionBench Accuracy: {np.mean(results)*100} %")
-        return np.mean(results)*100
-    
-    def evaluate_chartqa(self, model, accel):
-        # ChartQA Evaluation
-        # post processing
-        processed_answers = []
-        for x in self.gen_answers:
-            if any(i.isdigit() for i in x):
-                processed_answers.append(x.split(" ")[0])
-            else:
-                processed_answers.append(x)
-        pred_answers = [{'answer': answer, 'question': inputs['question'], 'annotation': inputs['gt']} for inputs, answer in zip(self.inputs, processed_answers)]
-        pred_pth = os.path.join(self.save_dir, f"{model}_chartqa_results.json")
-        json.dump(pred_answers, open(pred_pth, "w"))
-
-        # Compute accuracy
-        acc = evaluate_relaxed_accuracy(pred_answers)
-        accel.print(f"ChartQA Accuracy: {acc*100}%")
-        return acc
-    
-    def evaluate_seed(self, model, accel):
-        # SEED Evaluation
-        pred_answers = [{'answer': answer, 'question': inputs['question'], 'question_id': inputs['id'], 'gt': inputs['gt'], 'question_type': inputs['question_type']} for inputs, answer in zip(self.inputs, self.gen_answers)]
-        pred_pth = os.path.join(self.save_dir, f"{model}_seed_results.json")
-        json.dump(pred_answers, open(pred_pth, "w"))
-
-        # Compute accuracy
-        results = [(answer['answer'] == answer['gt']) for answer in pred_answers]
-        accel.print (f"SEED Accuracy: {np.mean(results)*100} %")
-
-        # Per question type accuracy
-        for k, v in SEED_TYPES.items():
-            sub_results = []
-            for pred in pred_answers:
-                if pred['question_type'] == k:
-                    sub_results.append(pred['answer'] == pred['gt'])
-            accel.print (f"{v}: {np.mean(sub_results)*100} %")
-        
-        return np.mean(results)*100
-    
-    def evaluate_llava(self, model, accel):
-        # LLaVA-in-the-Wild Evaluation
-        pred_answers = [{'question_id': inputs['id'],  'prompt': inputs['question'], 'text': answer, "answer_id": shortuuid.uuid()} for inputs, answer in zip(self.inputs, self.gen_answers)]
-        sorted_answers = sorted(pred_answers, key=lambda x: x['question_id'])
-        pred_pth = os.path.join(self.save_dir, f'{model}_llava_results.jsonl')
-        ans_file = open(pred_pth, "w")
-        for pred in sorted_answers:
-            ans_file.write(json.dumps(pred) + "\n")
-            ans_file.flush()
-        ans_file.close()
-
-        accel.print(f"Finished evaluating LLaVA-in-the-wild. Evaluate the result file saved to {pred_pth}.")
-        return 
-    
-    def evaluate_blink(self, model, accel):
-        # BLINK Evaluation
-        # TODO
-        return 
-    
-    def evaluate_mathverse(self, model, accel):
-        # Mathverse Evaluation
-        pred_answers = [{'sample_index' : inputs['id'], 'problem_index' : inputs['problem_index'], 'problem_version' : inputs['problem_version'],
-                        'question' : inputs['origin_question'], 'answer' : inputs['gt'],
-                        'question_type': inputs['question_type'], 'question_type': inputs['question_type'], 
-                        'metadata': inputs['metadata'], 'query_wo': inputs['question'], 'query_cot' : inputs['query_cot'], 'model_answer' : answer} for inputs, answer in zip(self.inputs, self.gen_answers)]
-
-        # answers = [item for item in pred_answers if item['problem_version'] != 'Text_Only']
-        # text_only_answers = [item for item in pred_answers if item['problem_version'] == 'Text_Only']
-        
-        pred_pth = os.path.join(self.save_dir, f'{model}_mathverse_results.json')
-        json.dump(pred_answers, open(pred_pth, "w"))
-        pred_pth = os.path.join(self.save_dir, f'{model}_mathverse_scores.json')
-        eval_mathverse(self.save_dir, pred_answers,f'{model}_mathverse_extracts.json', f'{model}_mathverse_scores.json')
-        accel.print(f"Finished evaluating MathVerse. Evaluate the result file saved to {pred_pth}.")
-        # TODO
-        return 
-
-    def evaluate_mmstar(self, model, accel):
-        pred_answers = [{'question': inputs['question'],
-                        'answer': inputs['answer'],
-                        'category': inputs['category'],
-                        'l2_category': inputs['l2_category'],
-                        # 'bench': inputs['bench'],
-                        'prediction' : answer} for inputs, answer in zip(self.inputs, self.gen_answers)]
-        
-        pred_pth = os.path.join(self.save_dir, f'{model}_mmstar_results.json')
-        json.dump(pred_answers, open(pred_pth, "w"))
-        
-        df = pd.DataFrame(pred_answers)
-                        
-        eval_mmstar(df, self.save_dir, f'{model}_mmstar_scores.json')
-        pred_pth = os.path.join(self.save_dir, f'{model}_mmstar_scores.json')
-        accel.print(f"Finished evaluating MMStar. Evaluate the result file saved to {pred_pth}.")

eval/llavabench/eval.sh

@@ -1,11 +0,0 @@
-python eval/llavabench/eval_gpt_review_bench.py \
-    --question /mnt/ssd/lbk-cvpr/dataset/llava-bench-in-the-wild/questions.jsonl \
-    --context /mnt/ssd/lbk-cvpr/dataset/llava-bench-in-the-wild/context.jsonl \
-    --rule eval/llavabench/rule.json \
-    --answer-list \
-        /mnt/ssd/lbk-cvpr/dataset/llava-bench-in-the-wild/answers_gpt4.jsonl \
-        /mnt/ssd/lbk-cvpr/dataset/eval_results/Meteor_llava_results.jsonl \
-    --output \
-        /mnt/ssd/lbk-cvpr/dataset/eval_results/reviews_meteor_llava_results_step3.jsonl
-
-python eval/llavabench/summarize_gpt_review.py -f /mnt/ssd/lbk-cvpr/dataset/eval_results/reviews_meteor_llava_results_step3.jsonl

eval/llavabench/eval_gpt_review_bench.py

@@ -1,122 +0,0 @@
-import argparse
-import json
-import os
-
-import openai
-import time
-
-NUM_SECONDS_TO_SLEEP = 0.5
-
-openai.api_key= ""
-
-def get_eval(content: str, max_tokens: int):
-    while True:
-        try:
-            response = openai.ChatCompletion.create(
-                model='gpt-4-0613',
-                messages=[{
-                    'role': 'system',
-                    'content': 'You are a helpful and precise assistant for checking the quality of the answer.'
-                }, {
-                    'role': 'user',
-                    'content': content,
-                }],
-                temperature=0.2,  # TODO: figure out which temperature is best for evaluation
-                max_tokens=max_tokens,
-            )
-            break
-        except openai.error.RateLimitError:
-            pass
-        except Exception as e:
-            print(e)
-        time.sleep(NUM_SECONDS_TO_SLEEP)
-
-    return response['choices'][0]['message']['content']
-
-
-def parse_score(review):
-    try:
-        score_pair = review.split('\n')[0]
-        score_pair = score_pair.replace(',', ' ')
-        sp = score_pair.split(' ')
-        if len(sp) == 2:
-            return [float(sp[0]), float(sp[1])]
-        else:
-            print('error', review)
-            return [-1, -1]
-    except Exception as e:
-        print(e)
-        print('error', review)
-        return [-1, -1]
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser(description='ChatGPT-based QA evaluation.')
-    parser.add_argument('-q', '--question')
-    parser.add_argument('-c', '--context')
-    parser.add_argument('-a', '--answer-list', nargs='+', default=[])
-    parser.add_argument('-r', '--rule')
-    parser.add_argument('-o', '--output')
-    parser.add_argument('--max-tokens', type=int, default=1024, help='maximum number of tokens produced in the output')
-    args = parser.parse_args()
-
-    f_q = open(os.path.expanduser(args.question))
-    f_ans1 = open(os.path.expanduser(args.answer_list[0]))
-    f_ans2 = open(os.path.expanduser(args.answer_list[1]))
-    rule_dict = json.load(open(os.path.expanduser(args.rule), 'r'))
-
-    if os.path.isfile(os.path.expanduser(args.output)):
-        cur_reviews = [json.loads(line) for line in open(os.path.expanduser(args.output))]
-    else:
-        cur_reviews = []
-
-    review_file = open(f'{args.output}', 'a')
-
-    context_list = [json.loads(line) for line in open(os.path.expanduser(args.context))]
-    image_to_context = {context['image']: context for context in context_list}
-
-    handles = []
-    idx = 0
-    for ques_js, ans1_js, ans2_js in zip(f_q, f_ans1, f_ans2):
-        ques = json.loads(ques_js)
-        ans1 = json.loads(ans1_js)
-        ans2 = json.loads(ans2_js)
-
-        inst = image_to_context[ques['image']]
-
-        if isinstance(inst['caption'], list):
-            cap_str = '\n'.join(inst['caption'])
-        else:
-            cap_str = inst['caption']
-
-        category = 'llava_bench_' + json.loads(ques_js)['category']
-        if category in rule_dict:
-            rule = rule_dict[category]
-        else:
-            assert False, f"Visual QA category not found in rule file: {category}."
-        prompt = rule['prompt']
-        role = rule['role']
-        content = (f'[Context]\n{cap_str}\n\n'
-                   f'[Question]\n{ques["text"]}\n\n'
-                   f'[{role} 1]\n{ans1["text"]}\n\n[End of {role} 1]\n\n'
-                   f'[{role} 2]\n{ans2["text"]}\n\n[End of {role} 2]\n\n'
-                   f'[System]\n{prompt}\n\n')
-        cur_js = {
-            'id': idx+1,
-            'question_id': ques['question_id'],
-            'answer1_id': ans1.get('answer_id', ans1['question_id']),
-            'answer2_id': ans2.get('answer_id', ans2['answer_id']),
-            'category': category
-        }
-        if idx >= len(cur_reviews):
-            review = get_eval(content, args.max_tokens)
-            scores = parse_score(review)
-            cur_js['content'] = review
-            cur_js['tuple'] = scores
-            review_file.write(json.dumps(cur_js) + '\n')
-            review_file.flush()
-        else:
-            print(f'Skipping {idx} as we already have it.')
-        idx += 1
-        print(idx)
-    review_file.close()

eval/llavabench/rule.json

@@ -1,11 +0,0 @@
-{
-    "coding": {"role": "Assistant", "prompt": "Your task is to evaluate the coding abilities of the above two assistants. They have been asked to implement a program to solve a given problem. Please review their code submissions, paying close attention to their problem-solving approach, code structure, readability, and the inclusion of helpful comments.\n\nPlease ensure that the assistants' submissions:\n\n1. Correctly implement the given problem statement.\n2. Contain accurate and efficient code.\n3. Include clear and concise comments that explain the code's logic and functionality.\n4. Adhere to proper coding standards and best practices.\n\nOnce you have carefully reviewed both submissions, provide detailed feedback on their strengths and weaknesses, along with any suggestions for improvement. You should first output a single line containing two scores on the scale of 1-10 (1: no code/no sense; 10: perfect) for Assistant 1 and 2, respectively. Then give extra comments starting from the next line."},
-    "math":  {"role": "Assistant", "prompt": "We would like to request your feedback on the mathematical proficiency of two AI assistants regarding the given user question.\nFirstly, please solve the problem independently, without referring to the answers provided by Assistant 1 and Assistant 2.\nAfterward, please examine the problem-solving process of Assistant 1 and Assistant 2 step-by-step to ensure their correctness, identifying any incorrect steps if present. Your evaluation should take into account not only the answer but also the problem-solving steps.\nFinally, please output a Python tuple containing two numerical scores for Assistant 1 and Assistant 2, ranging from 1 to 10, respectively. If applicable, explain the reasons for any variations in their scores and determine which assistant performed better."},
-    "default":  {"role": "Assistant", "prompt": "We would like to request your feedback on the performance of two AI assistants in response to the user question displayed above.\nPlease rate the helpfulness, relevance, accuracy, level of details of their responses. Each assistant receives an overall score on a scale of 1 to 10, where a higher score indicates better overall performance.\nPlease first output a single line containing only two values indicating the scores for Assistant 1 and 2, respectively. The two scores are separated by a space.\nIn the subsequent line, please provide a comprehensive explanation of your evaluation, avoiding any potential bias and ensuring that the order in which the responses were presented does not affect your judgment."},
-    "conv":  {"role": "Assistant", "prompt": "We would like to request your feedback on the performance of two AI assistants in response to the user question displayed above. The user asks the question on observing an image. For your reference, the visual content in the image is represented with five descriptive sentences describing the same image and the bounding box coordinates of each object in the scene. These coordinates are in the form of bounding boxes, represented as (x1, y1, x2, y2) with floating numbers ranging from 0 to 1. These values correspond to the top left x, top left y, bottom right x, and bottom right y. \nPlease rate the helpfulness, relevance, accuracy, level of details of their responses. Each assistant receives an overall score on a scale of 1 to 10, where a higher score indicates better overall performance.\nPlease first output a single line containing only two values indicating the scores for Assistant 1 and 2, respectively. The two scores are separated by a space.\nIn the subsequent line, please provide a comprehensive explanation of your evaluation, avoiding any potential bias and ensuring that the order in which the responses were presented does not affect your judgment."},
-    "detail":  {"role": "Assistant", "prompt": "We would like to request your feedback on the performance of two AI assistants in response to the user question displayed above. The user asks the question on observing an image. For your reference, the visual content in the image is represented with five descriptive sentences describing the same image and the bounding box coordinates of each object in the scene. These coordinates are in the form of bounding boxes, represented as (x1, y1, x2, y2) with floating numbers ranging from 0 to 1. These values correspond to the top left x, top left y, bottom right x, and bottom right y. \nPlease rate the helpfulness, relevance, accuracy, level of details of their responses. Each assistant receives an overall score on a scale of 1 to 10, where a higher score indicates better overall performance.\nPlease first output a single line containing only two values indicating the scores for Assistant 1 and 2, respectively. The two scores are separated by a space.\nIn the subsequent line, please provide a comprehensive explanation of your evaluation, avoiding any potential bias and ensuring that the order in which the responses were presented does not affect your judgment."},
-    "complex":  {"role": "Assistant", "prompt": "We would like to request your feedback on the performance of two AI assistants in response to the user question displayed above. The user asks the question on observing an image. For your reference, the visual content in the image is represented with five descriptive sentences describing the same image and the bounding box coordinates of each object in the scene. These coordinates are in the form of bounding boxes, represented as (x1, y1, x2, y2) with floating numbers ranging from 0 to 1. These values correspond to the top left x, top left y, bottom right x, and bottom right y. \nPlease rate the helpfulness, relevance, accuracy, level of details of their responses. Each assistant receives an overall score on a scale of 1 to 10, where a higher score indicates better overall performance.\nPlease first output a single line containing only two values indicating the scores for Assistant 1 and 2, respectively. The two scores are separated by a space.\nIn the subsequent line, please provide a comprehensive explanation of your evaluation, avoiding any potential bias and ensuring that the order in which the responses were presented does not affect your judgment."},
-    "llava_bench_conv":  {"role": "Assistant", "prompt": "We would like to request your feedback on the performance of two AI assistants in response to the user question displayed above. The user asks the question on observing an image. For your reference, the visual content in the image is represented with a few sentences describing the image. \nPlease rate the helpfulness, relevance, accuracy, level of details of their responses. Each assistant receives an overall score on a scale of 1 to 10, where a higher score indicates better overall performance.\nPlease first output a single line containing only two values indicating the scores for Assistant 1 and 2, respectively. The two scores are separated by a space.\nIn the subsequent line, please provide a comprehensive explanation of your evaluation, avoiding any potential bias and ensuring that the order in which the responses were presented does not affect your judgment."},
-    "llava_bench_detail":  {"role": "Assistant", "prompt": "We would like to request your feedback on the performance of two AI assistants in response to the user question displayed above. The user asks the question on observing an image. For your reference, the visual content in the image is represented with a few sentences describing the image. \nPlease rate the helpfulness, relevance, accuracy, level of details of their responses. Each assistant receives an overall score on a scale of 1 to 10, where a higher score indicates better overall performance.\nPlease first output a single line containing only two values indicating the scores for Assistant 1 and 2, respectively. The two scores are separated by a space.\nIn the subsequent line, please provide a comprehensive explanation of your evaluation, avoiding any potential bias and ensuring that the order in which the responses were presented does not affect your judgment."},
-    "llava_bench_complex":  {"role": "Assistant", "prompt": "We would like to request your feedback on the performance of two AI assistants in response to the user question displayed above. The user asks the question on observing an image. For your reference, the visual content in the image is represented with a few sentences describing the image. \nPlease rate the helpfulness, relevance, accuracy, level of details of their responses. Each assistant receives an overall score on a scale of 1 to 10, where a higher score indicates better overall performance.\nPlease first output a single line containing only two values indicating the scores for Assistant 1 and 2, respectively. The two scores are separated by a space.\nIn the subsequent line, please provide a comprehensive explanation of your evaluation, avoiding any potential bias and ensuring that the order in which the responses were presented does not affect your judgment."}
-}

eval/llavabench/summarize_gpt_review.py

@@ -1,60 +0,0 @@
-import json
-import os
-from collections import defaultdict
-
-import numpy as np
-
-import argparse
-
-def parse_args():
-    parser = argparse.ArgumentParser(description='ChatGPT-based QA evaluation.')
-    parser.add_argument('-d', '--dir', default=None)
-    parser.add_argument('-v', '--version', default=None)
-    parser.add_argument('-s', '--select', nargs='*', default=None)
-    parser.add_argument('-f', '--files', nargs='*', default=[])
-    parser.add_argument('-i', '--ignore', nargs='*', default=[])
-    return parser.parse_args()
-
-
-if __name__ == '__main__':
-    args = parse_args()
-
-    if args.ignore is not None:
-        args.ignore = [int(x) for x in args.ignore]
-
-    if len(args.files) > 0:
-        review_files = args.files
-    else:
-        review_files = [x for x in os.listdir(args.dir) if x.endswith('.jsonl') and (x.startswith('gpt4_text') or x.startswith('reviews_') or x.startswith('review_') or 'review' in args.dir)]
-
-    for review_file in sorted(review_files):
-        config = os.path.basename(review_file).replace('gpt4_text_', '').replace('.jsonl', '')
-        if args.select is not None and any(x not in config for x in args.select):
-            continue
-        if '0613' in config:
-            version = '0613'
-        else:
-            version = '0314'
-        if args.version is not None and args.version != version:
-            continue
-        scores = defaultdict(list)
-        print(config)
-        with open(os.path.join(args.dir, review_file) if args.dir is not None else review_file) as f:
-            for review_str in f:
-                review = json.loads(review_str)
-                if review['question_id'] in args.ignore:
-                    continue
-                if 'category' in review:
-                    scores[review['category']].append(review['tuple'])
-                    scores['all'].append(review['tuple'])
-                else:
-                    if 'tuple' in review:
-                        scores['all'].append(review['tuple'])
-                    else:
-                        scores['all'].append(review['score'])
-        for k, v in sorted(scores.items()):
-            stats = np.asarray(v).mean(0).tolist()
-            stats = [round(x, 3) for x in stats]
-            # print(k, stats, round(stats[1]/stats[0]*100, 1))
-            print(k, round(stats[1]/stats[0]*100, 1), round(stats[0] * 10, 1), round(stats[1] * 10, 1))
-        print('=================================')

eval/mathvista/calculate_score.py

@@ -1,259 +0,0 @@
-import os
-import re
-import argparse
-import pandas as pd
-
-# !pip install python-Levenshtein
-from Levenshtein import distance
-
-import sys
-sys.path.append('../')
-from utilities import *
-
-
-def get_most_similar(prediction, choices):
-    """
-    Use the Levenshtein distance (or edit distance) to determine which of the choices is most similar to the given prediction
-    """
-    distances = [distance(prediction, choice) for choice in choices]
-    ind = distances.index(min(distances))
-    return choices[ind]
-    # return min(choices, key=lambda choice: distance(prediction, choice))
-
-
-def normalize_extracted_answer(extraction, choices, question_type, answer_type, precision):
-    """
-    Normalize the extracted answer to match the answer type
-    """
-    if question_type == 'multi_choice':
-        # make sure the extraction is a string
-        if isinstance(extraction, str):
-            extraction = extraction.strip()
-        else:
-            try:
-                extraction = str(extraction)
-            except:
-                extraction = ""
-    
-        # extract "A" from "(A) text"
-        letter = re.findall(r'\(([a-zA-Z])\)', extraction)
-        if len(letter) > 0:
-            extraction = letter[0].upper()
-        
-        options = [chr(ord('A') + i) for i in range(len(choices))]
-            
-        if extraction in options:
-            # convert option letter to text, e.g. "A" -> "text"
-            ind = options.index(extraction)
-            extraction = choices[ind]
-        else:
-            # select the most similar option
-            extraction = get_most_similar(extraction, choices)
-        assert extraction in choices
-
-    elif answer_type == 'integer':
-        try:
-            extraction = str(int(float(extraction)))
-        except:
-            extraction = None
-
-    elif answer_type == 'float':
-        try:
-            extraction = str(round(float(extraction), precision))
-        except:
-            extraction = None
-        
-    elif answer_type == 'list':
-        try:
-            extraction = str(extraction)
-        except:
-            extraction = None
-
-    return extraction
-    
-
-def safe_equal(prediction, answer):
-    """
-    Check if the prediction is equal to the answer, even if they are of different types
-    """
-    try:
-        if prediction == answer:
-            return True
-        return False
-    except Exception as e:
-        print(e)
-        return False
-
-
-def get_acc_with_contion(res_pd, key, value):
-    if key == 'skills':
-        # if value in res_pd[key]:
-        total_pd = res_pd[res_pd[key].apply(lambda x: value in x)]
-    else:
-        total_pd = res_pd[res_pd[key] == value]
-
-    correct_pd = total_pd[total_pd['true_false'] == True]
-    acc = "{:.2f}".format(len(correct_pd) / len(total_pd) * 100)
-    return len(correct_pd), len(total_pd), acc
-        
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--output_dir', type=str, default='../results')
-    parser.add_argument('--output_file', type=str, default='output.json')
-    parser.add_argument('--score_file', type=str, default='scores.json')
-    parser.add_argument('--gt_file', type=str, default='../data/testmini.json', help='ground truth file')
-    parser.add_argument('--number', type=int, default=-1, help='number of problems to run')
-    parser.add_argument('--rerun', action='store_true', help='rerun the evaluation')
-    parser.add_argument('--caculate_gain', action='store_true', help='caculate the socre gains over random guess')
-    parser.add_argument('--random_file', type=str, default='score_random_guess.json')  
-    args = parser.parse_args()
-
-    # args
-    output_file = os.path.join(args.output_dir, args.output_file)
-
-    # # quick test
-    # output_file = '../results/llava-llama-2-13b/output_llava_llama_2_13b.json'
-
-    # read json
-    print(f"Reading {output_file}...")
-    results = read_json(output_file)
-
-    # read ground truth
-    print(f"Reading {args.gt_file}...")
-    gts = read_json(args.gt_file)
-
-    # full pids
-    full_pids = list(results.keys())
-    if args.number > 0:
-        full_pids = full_pids[:min(args.number, len(full_pids))]
-    print("Number of testing problems:", len(full_pids))
-    
-    ## [1] Evaluate if the prediction is true or false
-    print("\nEvaluating the predictions...")
-    update_json_flag = False
-    for pid in full_pids:
-        problem = results[pid]
-        # print(problem)
-
-        if args.rerun:
-            if 'prediction' in problem:
-                del problem['prediction']
-            if 'true_false' in problem:
-                del problem['true_false']
-
-        choices = problem['choices']
-        question_type = problem['question_type']
-        answer_type = problem['answer_type']
-        precision = problem['precision']
-        extraction = problem['extraction']
-
-        if 'answer' in problem:
-            answer = problem['answer']
-        else:
-            answer = gts[pid]['answer']
-            problem['answer'] = answer
-
-        # normalize the extracted answer to match the answer type
-        prediction = normalize_extracted_answer(extraction, choices, question_type, answer_type, precision)
-
-        # verify the prediction is true or false
-        true_false = safe_equal(prediction, answer)
-        
-        # update the problem
-        if "true_false" not in problem:
-            update_json_flag = True
-
-        elif true_false != problem['true_false']:
-            update_json_flag = True
-
-        if "prediction" not in problem:
-            update_json_flag = True
-
-        elif prediction !=  problem['prediction']:
-            update_json_flag = True
-            
-        problem['prediction'] = prediction
-        problem['true_false'] = true_false
-
-    # save the updated json
-    if update_json_flag:
-        print("\n!!!Some problems are updated.!!!")
-        print(f"\nSaving {output_file}...")
-        save_json(results, output_file)
-
-    ## [2] Calculate the average accuracy
-    total = len(full_pids)
-    correct = 0
-    for pid in full_pids:
-        if results[pid]['true_false']:
-            correct += 1
-    accuracy = str(round(correct / total * 100, 2))
-    print(f"\nCorrect: {correct}, Total: {total}, Accuracy: {accuracy}%")
-
-    scores = {"average": {"accuracy": accuracy, "correct": correct, "total": total}}
-    
-    ## [3] Calculate the fine-grained accuracy scores
-    
-    # merge the 'metadata' attribute into the data
-    for pid in results:
-        results[pid].update(results[pid].pop('metadata'))
-
-    # convert the data to a pandas DataFrame
-    df = pd.DataFrame(results).T
-
-    print(len(df))
-    print("Number of test problems:", len(df))
-    # assert len(df) == 1000 # Important!!!
-
-    # asign the target keys for evaluation
-    target_keys = ['question_type', 'answer_type', 'language', 'source', 'category', 'task', 'context', 'grade', 'skills']
-     
-    for key in target_keys:
-        print(f"\nType: [{key}]")
-        # get the unique values of the key
-        if key == 'skills':
-            # the value is a list
-            values = []
-            for i in range(len(df)):
-                values += df[key][i]
-            values = list(set(values))
-        else:
-            values = df[key].unique()
-        #print(values)
-
-        # calculate the accuracy for each value
-        scores[key] = {}
-        for value in values:
-            correct, total, acc = get_acc_with_contion(df, key, value)
-            if total > 0:
-                print(f"[{value}]: {acc}% ({correct}/{total})")
-                scores[key][value] = {"accuracy": acc, "correct": correct, "total": total}
-        
-        # sort the scores by accuracy
-        scores[key] = dict(sorted(scores[key].items(), key=lambda item: float(item[1]['accuracy']), reverse=True))
-
-    # save the scores
-    scores_file = os.path.join(args.output_dir, args.score_file)
-    print(f"\nSaving {scores_file}...")
-    save_json(scores, scores_file)
-    print("\nDone!")
-
-    # [4] Calculate the score gains over random guess
-    if args.caculate_gain:
-        random_file = os.path.join(args.output_dir, args.random_file)
-        random_scores = json.load(open(random_file))
-
-        print("\nCalculating the score gains...")
-        for key in scores:
-            if key == 'average':
-                gain = round(float(scores[key]['accuracy']) - float(random_scores[key]['accuracy']), 2)
-                scores[key]['acc_gain'] = gain
-            else:
-                for sub_key in scores[key]:
-                    gain = round(float(scores[key][sub_key]['accuracy']) - float(random_scores[key][sub_key]['accuracy']), 2)
-                    scores[key][sub_key]['acc_gain'] = str(gain)
-
-        # save the score gains
-        print(f"\nSaving {scores_file}...")    
-        save_json(scores, scores_file)
-        print("\nDone!")

eval/mathvista/eval.sh

@@ -1,9 +0,0 @@
-# python eval/mathvista/extract_answer.py \
-# --output_dir /mnt/ssd/lbk-cvpr/dataset/eval_results \
-# --output_file Meteor_mathvista_results.json 
-
-python eval/mathvista/calculate_score.py \
---output_dir /mnt/ssd/lbk-cvpr/dataset/eval_results \
---output_file Meteor_mathvista_results_refixed.json  \
---score_file Meteor_mathvista_scores.json \
---gt_file /mnt/ssd/lbk-cvpr/dataset/MathVista/annot_testmini.json \

eval/mathvista/extract_answer.py

@@ -1,150 +0,0 @@
-import os
-import re
-import time
-import argparse
-
-from tqdm import tqdm
-
-import sys
-sys.path.append('../')
-from utilities import *
-
-# OpenAI
-import openai
-openai.api_key = ""
-# print(openai.api_key)
-
-# load demo prompt
-from prompts.ext_ans import demo_prompt
-
-
-def verify_extraction(extraction):
-    extraction = extraction.strip()
-    if extraction == "" or extraction == None:
-        return False
-    return True
-
-
-def create_test_prompt(demo_prompt, query, response):
-    demo_prompt = demo_prompt.strip()
-    test_prompt = f"{query}\n\n{response}"
-    full_prompt = f"{demo_prompt}\n\n{test_prompt}\n\nExtracted answer: "
-    return full_prompt
-
-
-def extract_answer(response, problem, quick_extract=False):
-    question_type = problem['question_type']
-    answer_type = problem['answer_type']
-    choices = problem['choices']
-    query = problem['query']
-    pid = problem['pid']
-
-    if response == "":
-        return ""
-    
-    if question_type == 'multi_choice' and response in choices:
-        return response
-    
-    if answer_type == "integer":
-        try:
-            extraction = int(response)
-            return str(extraction)
-        except:
-            pass
-
-    if answer_type == "float":
-        try:
-            extraction = str(float(response))
-            return extraction
-        except:
-            pass
-
-    # quick extraction
-    if quick_extract:
-        print("Quickly extracting answer...")
-        # The answer is "text". -> "text"
-        try:
-            result = re.search(r'The answer is "(.*)"\.', response)
-            if result:
-                extraction = result.group(1)
-                return extraction
-        except:
-            pass
-
-    # general extraction
-    try:
-        full_prompt = create_test_prompt(demo_prompt, query, response)
-        extraction = get_chat_response(full_prompt, openai.api_key)
-        return extraction
-    except Exception as e:
-        print(e)
-        print(f"Error in extracting answer for {pid}")
-
-    return ""
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser()
-    # input
-    parser.add_argument('--output_dir', type=str, default='../results')
-    parser.add_argument('--output_file', type=str, default='answer.json')
-    parser.add_argument('--response_label', type=str, default='response', help='response label for the input file')
-    # model
-    parser.add_argument('--llm_engine', type=str, default='gpt-4-0613', help='llm engine',
-                        choices = ['gpt-3.5-turbo', 'gpt-3.5', 'gpt-4', 'gpt-4-0314', 'gpt-4-0613'])
-    parser.add_argument('--number', type=int, default=-1, help='number of problems to run')
-    parser.add_argument('--quick_extract', action='store_true', help='use rules to extract answer for some problems')
-    parser.add_argument('--rerun', action='store_true', help='rerun the answer extraction')
-    # output
-    parser.add_argument('--save_every', type=int, default=10, help='save every n problems')
-    parser.add_argument('--output_label', type=str, default='', help='label for the output file')
-    args = parser.parse_args()
-
-    # args
-    label = args.response_label
-    result_file = os.path.join(args.output_dir, args.output_file)
-
-    if args.output_label != '':
-        output_file = result_file.replace('.json', f'_{args.output_label}.json')
-    else:
-        output_file = result_file
-
-    # read results
-    print(f"Reading {result_file}...")
-    results = read_json(result_file)
-
-    # full pids
-    full_pids = list(results.keys())
-    if args.number > 0:
-        full_pids = full_pids[:min(args.number, len(full_pids))]
-    print("Number of testing problems:", len(full_pids))
-
-    # test pids
-    if args.rerun:
-        test_pids = full_pids
-    else:
-        test_pids = []
-        for pid in full_pids:
-            # print(pid)
-            if 'extraction' not in results[pid] or not verify_extraction(results[pid]['extraction']):
-                test_pids.append(pid)
-    
-    test_num = len(test_pids)
-    print("Number of problems to run:", test_num)
-    # print(test_pids)
-
-    # tqdm, enumerate results
-    for i, pid in enumerate(tqdm(test_pids)):
-        problem = results[pid]
-
-        assert label in problem
-        response = problem[label]       
-
-        
-        extraction  = extract_answer(response, problem, args.quick_extract)
-        results[pid]['extraction'] = extraction
-
-        if i % args.save_every == 0 or i == test_num - 1:
-            print(f"Saving results to {output_file}...")
-            save_json(results, output_file)
-            print(f"Results saved.")

eval/mathvista/prompts/ext_ans.py

@@ -1,42 +0,0 @@
-
-
-# pids = 852,  104,  824,  506,  540
-
-demo_prompt = """
-Please read the following example. Then extract the answer from the model response and type it at the end of the prompt.
-
-Hint: Please answer the question requiring an integer answer and provide the final value, e.g., 1, 2, 3, at the end.
-Question: Which number is missing?
-
-Model response: The number missing in the sequence is 14.
-
-Extracted answer: 14
-
-Hint: Please answer the question requiring a floating-point number with one decimal place and provide the final value, e.g., 1.2, 1.3, 1.4, at the end.
-Question: What is the fraction of females facing the camera?
-
-Model response: The fraction of females facing the camera is 0.6, which means that six out of ten females in the group are facing the camera.
-
-Extracted answer: 0.6
-
-Hint: Please answer the question requiring a floating-point number with two decimal places and provide the final value, e.g., 1.23, 1.34, 1.45, at the end.
-Question: How much money does Luca need to buy a sour apple candy and a butterscotch candy? (Unit: $)
-
-Model response: Luca needs $1.45 to buy a sour apple candy and a butterscotch candy.
-
-Extracted answer: 1.45
-
-Hint: Please answer the question requiring a Python list as an answer and provide the final list, e.g., [1, 2, 3], [1.2, 1.3, 1.4], at the end.
-Question: Between which two years does the line  graph saw its maximum peak?
-
-Model response: The line graph saw its maximum peak between 2007 and 2008.
-
-Extracted answer: [2007, 2008]
-
-Hint: Please answer the question and provide the correct option letter, e.g., A, B, C, D, at the end.
-Question: What fraction of the shape is blue?\nChoices:\n(A) 3/11\n(B) 8/11\n(C) 6/11\n(D) 3/5
-
-Model response: The correct answer is (B) 8/11.
-
-Extracted answer: B
-"""

eval/mathvista/utilities.py

@@ -1,199 +0,0 @@
-import os
-import cv2
-import json
-import time
-import pickle
-import openai
-import re
-from word2number import w2n
-
-
-def create_dir(output_dir):
-    if not os.path.exists(output_dir):
-        os.makedirs(output_dir)
-    
-
-def read_csv(file):
-    data = []
-    with open(file, 'r') as f:
-        for line in f:
-            data.append(line.strip())
-    return data
-
-
-def read_pandas_csv(csv_path):
-    # read a pandas csv sheet 
-    import pandas as pd
-    df = pd.read_csv(csv_path)
-    return df
-
-
-def read_json(path):
-    with open(path, 'r', encoding='utf-8') as f:
-        return json.load(f)
-
-
-def read_jsonl(file):
-    with open(file, 'r') as f:
-        data = [json.loads(line) for line in f]
-    return data
-
-
-def read_pickle(path):
-    with open(path, 'rb') as f:
-        return pickle.load(f)
-
-
-def save_json(data, path):
-    with open(path, 'w') as f:
-        json.dump(data, f, indent=4)
-
-
-def save_array_img(path, image):
-    cv2.imwrite(path, image)
-
-
-def contains_digit(text):
-    # check if text contains a digit
-    if any(char.isdigit() for char in text):
-        return True
-    return False  
-    
-def contains_number_word(text):
-    # check if text contains a number word
-    ignore_words = ["a", "an", "point"]
-    words = re.findall(r'\b\w+\b', text)  # This regex pattern matches any word in the text
-    for word in words:
-        if word in ignore_words:
-            continue
-        try:
-            w2n.word_to_num(word)
-            return True  # If the word can be converted to a number, return True
-        except ValueError:
-            continue  # If the word can't be converted to a number, continue with the next word
-    
-    # check if text contains a digit
-    if any(char.isdigit() for char in text):
-        return True
-
-    return False  # If none of the words could be converted to a number, return False
-
-
-def contains_quantity_word(text, special_keep_words=[]):
-    # check if text contains a quantity word
-    quantity_words = ["most", "least", "fewest"
-                      "more", "less", "fewer", 
-                      "largest", "smallest", "greatest", 
-                      "larger", "smaller", "greater", 
-                      "highest", "lowest", "higher", "lower",
-                      "increase", "decrease",
-                      "minimum", "maximum", "max", "min",
-                      "mean", "average", "median",
-                      "total", "sum", "add", "subtract",
-                      "difference", "quotient", "gap",
-                      "half", "double", "twice", "triple",
-                      "square", "cube", "root",
-                      "approximate", "approximation",
-                      "triangle", "rectangle", "circle", "square", "cube", "sphere", "cylinder", "cone", "pyramid",
-                      "multiply", "divide",
-                      "percentage", "percent", "ratio", "proportion", "fraction", "rate", 
-                    ]
-    
-    quantity_words += special_keep_words # dataset specific words
-    
-    words = re.findall(r'\b\w+\b', text)  # This regex pattern matches any word in the text
-    if any(word in quantity_words for word in words):
-        return True
-
-    return False  # If none of the words could be converted to a number, return False
-
-
-def is_bool_word(text):
-    if text in ["Yes", "No", "True", "False", 
-                "yes", "no", "true", "false", 
-                "YES", "NO", "TRUE", "FALSE"]:
-        return True
-    return False
-
-
-def is_digit_string(text):
-    # remove ".0000"
-    text = text.strip()
-    text = re.sub(r'\.0+$', '', text)
-    try:
-        int(text)
-        return True
-    except ValueError:
-        return False
-   
-    
-def is_float_string(text):
-    # text is a float string if it contains a "." and can be converted to a float
-    if "." in text:
-        try:
-            float(text)
-            return True
-        except ValueError:
-            return False
-    return False
-
-
-def copy_image(image_path, output_image_path):
-    from shutil import copyfile
-    copyfile(image_path, output_image_path)
-
-
-def copy_dir(src_dir, dst_dir):
-    from shutil import copytree
-    # copy the source directory to the target directory
-    copytree(src_dir, dst_dir)
-
-
-import PIL.Image as Image
-def get_image_size(img_path):
-    img = Image.open(img_path)
-    width, height = img.size
-    return width, height
-
-
-def get_chat_response(promot, api_key, model="gpt-3.5-turbo", temperature=0, max_tokens=256, n=1, patience=10000000,
- sleep_time=0):
-    messages = [
-        {"role": "user", "content": promot},
-    ]
-    # print("I am here")
-    while patience > 0:
-        patience -= 1
-        try:
-            response = openai.ChatCompletion.create(model=model,
-                                                messages=messages,
-                                                api_key=api_key,
-                                                temperature=temperature,
-                                                max_tokens=max_tokens,
-                                                n=n)
-            if n == 1:
-                prediction = response['choices'][0]['message']['content'].strip()
-                if prediction != "" and prediction != None:
-                    return prediction
-            else:
-                prediction = [choice['message']['content'].strip() for choice in response['choices']]
-                if prediction[0] != "" and prediction[0] != None:
-                    return prediction
-
-        except Exception as e:
-            if "Rate limit" not in str(e):
-                print(e)
-
-            if "Please reduce the length of the messages" in str(e):
-                print("!!Reduce promot size")
-                # reduce input prompt and keep the tail
-                new_size = int(len(promot) * 0.9)
-                new_start = len(promot) - new_size
-                promot = promot[new_start:]
-                messages = [
-                    {"role": "user", "content": promot},
-                ]
-                
-            if sleep_time > 0:
-                time.sleep(sleep_time)
-    return ""

eval/mm-vet/eval.sh

@@ -1 +0,0 @@
-python eval/mm-vet/evaluate_mmvet.py

eval/mm-vet/evaluate_mmvet.py

@@ -1,250 +0,0 @@
-import openai
-import json
-
-import os
-from tqdm import tqdm
-import pandas as pd
-import numpy as np
-from collections import Counter
-import time 
-
-gpt_model = "gpt-4-0613"
-openai.api_key= ""
-DATASET_ROOT=""
-MMVET = "mm-vet/mm-vet.json"
-
-prompt = """Compare the ground truth and prediction from AI models, to give a correctness score for the prediction. <AND> in the ground truth means it is totally right only when all elements in the ground truth are present in the prediction, and <OR> means it is totally right when any one element in the ground truth is present in the prediction. The correctness score is 0.0 (totally wrong), 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, or 1.0 (totally right). Just complete the last space of the correctness score.
-
-Question | Ground truth | Prediction | Correctness
---- | --- | --- | ---
-What is x in the equation? | -1 <AND> -5 | x = 3 | 0.0
-What is x in the equation? | -1 <AND> -5 | x = -1 | 0.5
-What is x in the equation? | -1 <AND> -5 | x = -5 | 0.5
-What is x in the equation? | -1 <AND> -5 | x = -5 or 5 | 0.5
-What is x in the equation? | -1 <AND> -5 | x = -1 or x = -5 | 1.0
-Can you explain this meme? | This meme is poking fun at the fact that the names of the countries Iceland and Greenland are misleading. Despite its name, Iceland is known for its beautiful green landscapes, while Greenland is mostly covered in ice and snow. The meme is saying that the person has trust issues because the names of these countries do not accurately represent their landscapes. | The meme talks about Iceland and Greenland. It's pointing out that despite their names, Iceland is not very icy and Greenland isn't very green. | 0.4
-Can you explain this meme? | This meme is poking fun at the fact that the names of the countries Iceland and Greenland are misleading. Despite its name, Iceland is known for its beautiful green landscapes, while Greenland is mostly covered in ice and snow. The meme is saying that the person has trust issues because the names of these countries do not accurately represent their landscapes. | The meme is using humor to point out the misleading nature of Iceland's and Greenland's names. Iceland, despite its name, has lush green landscapes while Greenland is mostly covered in ice and snow. The text 'This is why I have trust issues' is a playful way to suggest that these contradictions can lead to distrust or confusion. The humor in this meme is derived from the unexpected contrast between the names of the countries and their actual physical characteristics. | 1.0
-"""
-
-# load metadata
-decimal_places = 1 # number of decimal places to round to
-
-
-sub_set = None
-sub_set_name = ''
-
-mmvet_metadata = os.path.join(DATASET_ROOT, MMVET)
-with open(mmvet_metadata, 'r') as f:
-    data = json.load(f)
-
-
-counter = Counter()
-cap_set_list = []
-cap_set_counter = []
-len_data = 0
-for id, value in data.items():
-    if sub_set is not None and id not in sub_set:
-        continue
-    question = value["question"]
-    answer = value["answer"]
-    cap = value["capability"]
-    cap = set(cap)
-    counter.update(cap)
-    if cap not in cap_set_list:
-        cap_set_list.append(cap)
-        cap_set_counter.append(1)
-    else:
-        cap_set_counter[cap_set_list.index(cap)] += 1
-    
-    len_data += 1
-
-sorted_list = counter.most_common()
-columns = [k for k, v in sorted_list]
-columns.append("total")
-columns.append("std")
-columns.append('runs')
-df = pd.DataFrame(columns=columns)
-
-
-cap_set_sorted_indices = np.argsort(-np.array(cap_set_counter))
-new_cap_set_list = []
-new_cap_set_counter = []
-for index in cap_set_sorted_indices:
-    new_cap_set_list.append(cap_set_list[index])
-    new_cap_set_counter.append(cap_set_counter[index])
-
-cap_set_list = new_cap_set_list
-cap_set_counter = new_cap_set_counter
-cap_set_names = ["_".join(list(cap_set)) for cap_set in cap_set_list]
-
-columns2 = cap_set_names
-columns2.append("total")
-columns2.append("std")
-columns2.append('runs')
-df2 = pd.DataFrame(columns=columns2)
-
-###### change your model name ######
-model = "Meteor"
-result_path = os.path.join(DATASET_ROOT, "eval_results")
-num_run = 1 # we set it as 5 in the paper
-model_results_file = os.path.join(result_path, f"{model}_mmvet_results.json")
-
-# grade results for each sample to svae
-grade_file = f'{model}_{gpt_model}-grade-{num_run}runs.json'
-grade_file = os.path.join(result_path, grade_file)
-
-# score results regarding capabilities/capability integration to save
-cap_score_file = f'{model}_{sub_set_name}{gpt_model}-cap-score-{num_run}runs.csv'
-cap_score_file = os.path.join(result_path, cap_score_file)
-cap_int_score_file = f'{model}_{sub_set_name}{gpt_model}-cap-int-score-{num_run}runs.csv'
-cap_int_score_file = os.path.join(result_path, cap_int_score_file)
-
-with open(model_results_file) as f:
-    results = json.load(f)
-if os.path.exists(grade_file):
-    with open(grade_file, 'r') as f:
-        grade_results = json.load(f)
-else:
-    grade_results = {}
-
-
-def need_more_runs():
-    need_more_runs = False
-    if len(grade_results) > 0:
-        for k, v in grade_results.items():
-            if len(v['score']) < num_run:
-                need_more_runs = True
-                break
-    return need_more_runs or len(grade_results) < len_data
-
-
-while need_more_runs():
-    for j in range(num_run):
-        print(f'eval run {j}')
-        for id, line in tqdm(data.items()):
-            if sub_set is not None and id not in sub_set:
-                continue
-            if id in grade_results and len(grade_results[id]['score']) >= (j + 1):
-                continue
-
-            model_pred = results[id]
-            
-            question = prompt + '\n' + ' | '.join([line['question'], line['answer'].replace("<AND>", " <AND> ").replace("<OR>", " <OR> "), model_pred, ""])
-            messages = [
-            {"role": "user", "content": question},
-            ]
-
-            if id not in grade_results:
-                sample_grade = {'model': [], 'content': [], 'score': []}
-            else:
-                sample_grade = grade_results[id]
-
-            
-            grade_sample_run_complete = False
-            temperature = 0.0
-
-            while not grade_sample_run_complete:
-                try:
-                    response = openai.ChatCompletion.create(
-                        model=gpt_model,
-                        max_tokens=3,
-                        temperature=temperature,
-                        messages=messages)
-                    content = response['choices'][0]['message']['content']
-                    flag = True
-                    try_time = 1
-                    while flag:
-                        try:
-                            content = content.split(' ')[0].strip()
-                            score = float(content)
-                            if score > 1.0 or score < 0.0:
-                                assert False
-                            flag = False
-                        except:
-                            question = prompt + '\n' + ' | '.join([line['question'], line['answer'].replace("<AND>", " <AND> ").replace("<OR>", " <OR> "), model_pred, ""]) + "\nPredict the correctness of the answer (digit): "
-                            messages = [
-                            {"role": "user", "content": question},
-                            ]
-                            response = openai.ChatCompletion.create(
-                                model=gpt_model,
-                                max_tokens=3,
-                                temperature=temperature,
-                                messages=messages)
-                            content = response['choices'][0]['message']['content']
-                            try_time += 1
-                            temperature += 0.5
-                            print(f"{id} try {try_time} times")
-                            print(content)
-                            if try_time > 5:
-                                score = 0.0
-                                flag = False
-                    grade_sample_run_complete = True
-                except:
-                    # gpt4 may have token rate limit
-                    print("sleep 30s")
-                    time.sleep(30)
-
-            if len(sample_grade['model']) >= j + 1:
-                sample_grade['model'][j] = response['model']
-                sample_grade['content'][j] = content
-                sample_grade['score'][j] = score
-            else:
-                sample_grade['model'].append(response['model'])
-                sample_grade['content'].append(content)
-                sample_grade['score'].append(score)
-            grade_results[id] = sample_grade
-
-            with open(grade_file, 'w') as f:
-                json.dump(grade_results, f, indent=4)
-
-
-assert not need_more_runs()
-cap_socres = {k: [0.0]*num_run for k in columns[:-2]}
-counter['total'] = len_data
-
-cap_socres2 = {k: [0.0]*num_run for k in columns2[:-2]}
-counter2 = {columns2[i]:cap_set_counter[i] for i in range(len(cap_set_counter))}
-counter2['total'] = len_data
-
-for k, v in grade_results.items():
-    if sub_set is not None and k not in sub_set:
-        continue
-    for i in range(num_run):
-        score = v['score'][i]
-        caps = set(data[k]['capability'])
-        for c in caps:
-            cap_socres[c][i] += score
-        
-        cap_socres['total'][i] += score
-
-        index = cap_set_list.index(caps)
-        cap_socres2[cap_set_names[index]][i] += score
-        cap_socres2['total'][i] += score
-
-for k, v in cap_socres.items():
-    cap_socres[k] = np.array(v) / counter[k] *100
-
-
-std = round(cap_socres['total'].std(), decimal_places)
-total_copy = cap_socres['total'].copy()
-runs = str(list(np.round(total_copy, decimal_places)))
-
-for k, v in cap_socres.items():
-    cap_socres[k] = round(v.mean(), decimal_places)
-
-cap_socres['std'] = std
-cap_socres['runs'] = runs
-df.loc[model] = cap_socres
-
-
-for k, v in cap_socres2.items():
-    cap_socres2[k] = round(np.mean(np.array(v) / counter2[k] *100), decimal_places)
-cap_socres2['std'] = std
-cap_socres2['runs'] = runs
-df2.loc[model] = cap_socres2
-
-df.to_csv(cap_score_file)
-df2.to_csv(cap_int_score_file)
-
-print(df)
-print(df2)

eval/utils.py

@@ -1,1351 +0,0 @@
-import os
-import re
-import json
-import openai
-from typing import Dict
-from tqdm import tqdm
-import random
-import numpy as np
-from sklearn.metrics import accuracy_score, precision_score, recall_score, confusion_matrix
-from typing import Optional
-from collections import defaultdict
-from eval.mathvista.utilities import get_chat_response
-from config import *
-from copy import deepcopy
-
-random.seed(42)
-
-# SEED Question types
-SEED_TYPES = {1: 'Scene Understanding', 2: 'Instance Identity', 3: 'Instance Location', 4: 'Instance Attributes', 5: 'Instances Counting', 6: 'Spatial Relation', 7: 'Instance Interaction', 8: 'Visual Reasoning', 9: 'Text Understanding'}
-
-# Check for duplicated questions, items
-def remove_duplicate(dataset, inputs, gen_answers):
-    if dataset == "mme": 
-        return inputs, gen_answers
-    elif dataset == "pope": 
-        questions = set()
-        new_inputs, new_answers = [], []
-        for i, a in zip(inputs, gen_answers):
-            dup = i['id'], i['category']
-            if dup in questions:
-                continue
-            questions.add(dup)
-            new_inputs.append(i)
-            new_answers.append(a)
-    else:
-        questions = set()
-        new_inputs, new_answers = [], []
-        for i, a in zip(inputs, gen_answers):
-            if i['id'] in questions:
-                continue
-            questions.add(i['id'])
-            new_inputs.append(i)
-            new_answers.append(a)
-    return new_inputs, new_answers
-
-class EvalAIAnswerProcessor:
-    """
-    Processes an answer similar to Eval AI
-        copied from
-        https://github.com/facebookresearch/mmf/blob/c46b3b3391275b4181567db80943473a89ab98ab/pythia/tasks/processors.py#L897
-    """
-
-    CONTRACTIONS = {
-        "aint": "ain't",
-        "arent": "aren't",
-        "cant": "can't",
-        "couldve": "could've",
-        "couldnt": "couldn't",
-        "couldn'tve": "couldn't've",
-        "couldnt've": "couldn't've",
-        "didnt": "didn't",
-        "doesnt": "doesn't",
-        "dont": "don't",
-        "hadnt": "hadn't",
-        "hadnt've": "hadn't've",
-        "hadn'tve": "hadn't've",
-        "hasnt": "hasn't",
-        "havent": "haven't",
-        "hed": "he'd",
-        "hed've": "he'd've",
-        "he'dve": "he'd've",
-        "hes": "he's",
-        "howd": "how'd",
-        "howll": "how'll",
-        "hows": "how's",
-        "Id've": "I'd've",
-        "I'dve": "I'd've",
-        "Im": "I'm",
-        "Ive": "I've",
-        "isnt": "isn't",
-        "itd": "it'd",
-        "itd've": "it'd've",
-        "it'dve": "it'd've",
-        "itll": "it'll",
-        "let's": "let's",
-        "maam": "ma'am",
-        "mightnt": "mightn't",
-        "mightnt've": "mightn't've",
-        "mightn'tve": "mightn't've",
-        "mightve": "might've",
-        "mustnt": "mustn't",
-        "mustve": "must've",
-        "neednt": "needn't",
-        "notve": "not've",
-        "oclock": "o'clock",
-        "oughtnt": "oughtn't",
-        "ow's'at": "'ow's'at",
-        "'ows'at": "'ow's'at",
-        "'ow'sat": "'ow's'at",
-        "shant": "shan't",
-        "shed've": "she'd've",
-        "she'dve": "she'd've",
-        "she's": "she's",
-        "shouldve": "should've",
-        "shouldnt": "shouldn't",
-        "shouldnt've": "shouldn't've",
-        "shouldn'tve": "shouldn't've",
-        "somebody'd": "somebodyd",
-        "somebodyd've": "somebody'd've",
-        "somebody'dve": "somebody'd've",
-        "somebodyll": "somebody'll",
-        "somebodys": "somebody's",
-        "someoned": "someone'd",
-        "someoned've": "someone'd've",
-        "someone'dve": "someone'd've",
-        "someonell": "someone'll",
-        "someones": "someone's",
-        "somethingd": "something'd",
-        "somethingd've": "something'd've",
-        "something'dve": "something'd've",
-        "somethingll": "something'll",
-        "thats": "that's",
-        "thered": "there'd",
-        "thered've": "there'd've",
-        "there'dve": "there'd've",
-        "therere": "there're",
-        "theres": "there's",
-        "theyd": "they'd",
-        "theyd've": "they'd've",
-        "they'dve": "they'd've",
-        "theyll": "they'll",
-        "theyre": "they're",
-        "theyve": "they've",
-        "twas": "'twas",
-        "wasnt": "wasn't",
-        "wed've": "we'd've",
-        "we'dve": "we'd've",
-        "weve": "we've",
-        "werent": "weren't",
-        "whatll": "what'll",
-        "whatre": "what're",
-        "whats": "what's",
-        "whatve": "what've",
-        "whens": "when's",
-        "whered": "where'd",
-        "wheres": "where's",
-        "whereve": "where've",
-        "whod": "who'd",
-        "whod've": "who'd've",
-        "who'dve": "who'd've",
-        "wholl": "who'll",
-        "whos": "who's",
-        "whove": "who've",
-        "whyll": "why'll",
-        "whyre": "why're",
-        "whys": "why's",
-        "wont": "won't",
-        "wouldve": "would've",
-        "wouldnt": "wouldn't",
-        "wouldnt've": "wouldn't've",
-        "wouldn'tve": "wouldn't've",
-        "yall": "y'all",
-        "yall'll": "y'all'll",
-        "y'allll": "y'all'll",
-        "yall'd've": "y'all'd've",
-        "y'alld've": "y'all'd've",
-        "y'all'dve": "y'all'd've",
-        "youd": "you'd",
-        "youd've": "you'd've",
-        "you'dve": "you'd've",
-        "youll": "you'll",
-        "youre": "you're",
-        "youve": "you've",
-    }
-
-    NUMBER_MAP = {
-        "none": "0",
-        "zero": "0",
-        "one": "1",
-        "two": "2",
-        "three": "3",
-        "four": "4",
-        "five": "5",
-        "six": "6",
-        "seven": "7",
-        "eight": "8",
-        "nine": "9",
-        "ten": "10",
-    }
-    ARTICLES = ["a", "an", "the"]
-    PERIOD_STRIP = re.compile(r"(?!<=\d)(\.)(?!\d)")
-    COMMA_STRIP = re.compile(r"(?<=\d)(\,)+(?=\d)")
-    PUNCTUATIONS = [
-        ";",
-        r"/",
-        "[",
-        "]",
-        '"',
-        "{",
-        "}",
-        "(",
-        ")",
-        "=",
-        "+",
-        "\\",
-        "_",
-        "-",
-        ">",
-        "<",
-        "@",
-        "`",
-        ",",
-        "?",
-        "!",
-    ]
-
-    def __init__(self, *args, **kwargs):
-        pass
-
-    def word_tokenize(self, word):
-        word = word.lower()
-        word = word.replace(",", "").replace("?", "").replace("'s", " 's")
-        return word.strip()
-
-    def process_punctuation(self, in_text):
-        out_text = in_text
-        for p in self.PUNCTUATIONS:
-            if (p + " " in in_text or " " + p in in_text) or (
-                re.search(self.COMMA_STRIP, in_text) is not None
-            ):
-                out_text = out_text.replace(p, "")
-            else:
-                out_text = out_text.replace(p, " ")
-        out_text = self.PERIOD_STRIP.sub("", out_text, re.UNICODE)
-        return out_text
-
-    def process_digit_article(self, in_text):
-        out_text = []
-        temp_text = in_text.lower().split()
-        for word in temp_text:
-            word = self.NUMBER_MAP.setdefault(word, word)
-            if word not in self.ARTICLES:
-                out_text.append(word)
-            else:
-                pass
-        for word_id, word in enumerate(out_text):
-            if word in self.CONTRACTIONS:
-                out_text[word_id] = self.CONTRACTIONS[word]
-        out_text = " ".join(out_text)
-        return out_text
-
-    def __call__(self, item):
-        item = self.word_tokenize(item)
-        item = item.replace("\n", " ").replace("\t", " ").strip()
-        item = self.process_punctuation(item)
-        item = self.process_digit_article(item)
-        return item
-
-
-class TextVQAAccuracyEvaluator:
-    def __init__(self):
-        self.answer_processor = EvalAIAnswerProcessor()
-
-    def _compute_answer_scores(self, raw_answers):
-        """
-        compute the accuracy (soft score) of human answers
-        """
-        answers = [self.answer_processor(a) for a in raw_answers]
-        assert len(answers) == 10
-        gt_answers = list(enumerate(answers))
-        unique_answers = set(answers)
-        unique_answer_scores = {}
-
-        for unique_answer in unique_answers:
-            accs = []
-            for gt_answer in gt_answers:
-                other_answers = [item for item in gt_answers if item != gt_answer]
-                matching_answers = [
-                    item for item in other_answers if item[1] == unique_answer
-                ]
-                acc = min(1, float(len(matching_answers)) / 3)
-                accs.append(acc)
-            unique_answer_scores[unique_answer] = sum(accs) / len(accs)
-
-        return unique_answer_scores
-
-    def eval_pred_list(self, pred_list):
-        pred_scores = []
-        for entry in pred_list:
-            pred_answer = self.answer_processor(entry["pred_answer"])
-            unique_answer_scores = self._compute_answer_scores(entry["gt_answers"])
-            score = unique_answer_scores.get(pred_answer, 0.0)
-            pred_scores.append(score)
-
-        accuracy = sum(pred_scores) / len(pred_scores)
-        return accuracy
-
-# MME
-class MMEEvaluator:
-    def divide_chunks(self, l, n=2):
-        # looping till length l
-        for i in range(0, len(l), n): 
-            yield l[i:i + n]
-        
-        return 
-
-    def parse_pred_ans(self, pred_ans):
-        pred_label = None
-        if pred_ans in ["yes", "no"]:
-            pred_label = pred_ans
-        else:
-            prefix_pred_ans = pred_ans[:4]
-
-            if "yes" in prefix_pred_ans:
-                pred_label = "yes"
-            elif "no" in prefix_pred_ans:
-                pred_label = "no"
-            else:
-                pred_label = "other"
-
-        return pred_label
-
-
-    def compute_metric(self, gts, preds):
-        assert len(gts) == len(preds)
-
-        label_map = {
-            "yes": 1,
-            "no": 0,
-            "other": -1,
-        }
-        
-        gts = [label_map[x] for x in gts]
-        preds = [label_map[x] for x in preds]
-
-        acc = accuracy_score(gts, preds) 
-
-        clean_gts = []
-        clean_preds = []
-        other_num = 0 
-        for gt, pred in zip(gts, preds):
-            if pred == -1:
-                other_num += 1
-                continue
-            clean_gts.append(gt)
-            clean_preds.append(pred)
-        
-
-        conf_mat = confusion_matrix(clean_gts, clean_preds, labels=[1,0])
-        precision = precision_score(clean_gts, clean_preds, average='binary')
-        recall = recall_score(clean_gts, clean_preds, average='binary')
-        tp, fn = conf_mat[0]
-        fp, tn = conf_mat[1]
-
-        metric_dict = dict()
-        metric_dict = {
-            "TP": tp,
-            "FN": fn,
-            "TN": tn,
-            "FP": fp,
-            "precision": precision,
-            "recall": recall,
-            "other_num": other_num,
-            "acc": acc,
-        }
-
-        return metric_dict
-
-
-    def process_result(self, results_dir):
-        eval_type_dict = {
-            "Perception": ["existence", "count", "position", "color", "posters", "celebrity", "scene", "landmark", "artwork", "OCR"],
-            "Cognition": ["commonsense_reasoning", "numerical_calculation", "text_translation", "code_reasoning"]
-        }
-
-        model_score_dict = dict()
-        for eval_type, task_name_list in eval_type_dict.items():
-           
-            scores = 0
-            task_score_dict = dict()
-
-            for task_name in task_name_list:
-                if not os.path.exists(results_dir):
-                    os.makedirs(results_dir)
-                task_txt = os.path.join(results_dir, task_name + ".txt")
-                lines = open(task_txt, 'r').readlines()
-                chunk_lines = list(self.divide_chunks(lines)) # one image corresponds to two questions
-                
-                img_num = len(chunk_lines)
-                task_other_ans_num = 0
-                task_score = 0
-                acc_plus_correct_num = 0
-                gts = []
-                preds = []
-
-                for img_items in chunk_lines:
-                    assert len(img_items) == 2
-                    img_correct_num = 0
-
-                    for img_item in img_items:
-                        img_name, question, gt_ans, pred_ans = img_item.split("\t")
-
-                        gt_ans = gt_ans.lower()
-                        pred_ans = pred_ans.lower()
-
-                        assert gt_ans in ["yes", "no"] # gt can only be yes or no.
-
-                        pred_ans = self.parse_pred_ans(pred_ans)
-                        assert pred_ans in ["yes", "no", "other"]
-
-                        gts.append(gt_ans)
-                        preds.append(pred_ans)
-                        
-                        if gt_ans == pred_ans:
-                            img_correct_num += 1
-                        
-                        if pred_ans not in ["yes", "no"]:
-                            task_other_ans_num += 1
-
-                    if img_correct_num == 2:
-                        acc_plus_correct_num += 1
-
-                # cal TP precision acc, etc.
-                metric_dict = self.compute_metric(gts, preds)
-                acc_plus = acc_plus_correct_num / img_num
-                metric_dict["acc_plus"] = acc_plus
-                
-                
-                for k, v in metric_dict.items():
-                    if k in ["acc", "acc_plus"]:
-                        task_score += v*100
-                
-                task_score_dict[task_name] = task_score
-                
-                scores += task_score
-            task_score_dict['total'] = scores
-            model_score_dict[eval_type] = task_score_dict
-        return model_score_dict
-
-# For MMMU, convert all <image #> tokens to <image>
-def replace_image_tokens(question):
-    replaced = set()
-    def replace_token(match):
-        token = match.group(0)
-        if token not in replaced:
-            replaced.add(token)
-            return '<image>'
-        return token
-
-    pattern = re.compile(r'<image\s\d+>')
-    return pattern.sub(replace_token, question)
-
-# For MMMU, count all <image #> tokens
-def count_unique_image_tokens(string):
-    pattern = r'<image\s\d+>'
-    matches = re.findall(pattern, string)
-    return len(set(matches))
-
-# TextVQA    
-def prompt_processor(self, prompt):
-    if prompt.startswith('OCR tokens: '):
-        pattern = r"Question: (.*?) Short answer:"
-        match = re.search(pattern, prompt, re.DOTALL)
-        question = match.group(1)
-    elif 'Reference OCR token: ' in prompt and len(prompt.split('\n')) == 3:
-        if prompt.startswith('Reference OCR token:'):
-            question = prompt.split('\n')[1]
-        else:
-            question = prompt.split('\n')[0]
-    elif len(prompt.split('\n')) == 2:
-        question = prompt.split('\n')[0]
-    else:
-        assert False
-
-    return question.lower()
-
-# Convert answer to integer
-def char_to_int(char):
-    return ord(char.upper()) - ord('A')
-
-# In case model does not output a single letter, find the choice in answer
-def convert_to_choice(answer, candidates):
-    options = ["A", "B", "C", "D", "E"]
-    if answer in options:
-        extracted_answer = answer
-    elif len(answer) >= 2 and answer[0] in options and "." in answer:
-        extracted_answer= answer[0]
-    else:
-        pattern = re.compile(r'The answer is ([A-Z]).')
-        res = pattern.findall(answer)
-        if len(res) == 1:
-            extracted_answer = res[0]  # 'A', 'B', ...
-        else:
-            extracted_answer = "FAILED"
-
-    if extracted_answer in options[:len(candidates)]:
-        return options.index(extracted_answer)
-    else:
-        return -1
-    
-def get_pred_idx(prediction, choices, options):
-    """
-    Get the index (e.g. 2) from the prediction (e.g. 'C')
-    """
-    if prediction in options[:len(choices)]:
-        return options.index(prediction)
-    else:
-        return -1
-
-# Chart QA
-def relaxed_correctness(target: str,
-                        prediction: str,
-                        max_relative_change: float = 0.05) -> bool:
-    """Calculates relaxed correctness.
-
-    The correctness tolerates certain error ratio defined by max_relative_change.
-    See https://arxiv.org/pdf/2203.10244.pdf, end of section 5.1:
-    “Following Methani et al. (2020), we use a relaxed accuracy measure for the
-    numeric answers to allow a minor inaccuracy that may result from the automatic
-    data extraction process. We consider an answer to be correct if it is within
-    5% of the gold answer. For non-numeric answers, we still need an exact match
-    to consider an answer to be correct.”
-
-    Args:
-    target: Target string.
-    prediction: Predicted string.
-    max_relative_change: Maximum relative change.
-
-    Returns:
-    Whether the prediction was correct given the specified tolerance.
-    """
-
-    def _to_float(text: str) -> Optional[float]:
-        try:
-            if text.endswith('%'):
-                # Convert percentages to floats.
-                return float(text.rstrip('%')) / 100.0
-            else:
-                return float(text)
-        except ValueError:
-            return None
-
-    prediction_float = _to_float(prediction)
-    target_float = _to_float(target)
-    if prediction_float is not None and target_float:
-        relative_change = abs(prediction_float -
-                            target_float) / abs(target_float)
-        return relative_change <= max_relative_change
-    else:
-        return prediction.lower() == target.lower()
-
-# MME
-def get_gt(data_path):
-    ground_truth = {}
-    for category in os.listdir(data_path):
-        category_dir = os.path.join(data_path, category)
-        if not os.path.isdir(category_dir):
-            continue
-        if os.path.exists(os.path.join(category_dir, 'images')):
-            image_path = os.path.join(category_dir, 'images')
-            qa_path = os.path.join(category_dir, 'questions_answers_YN')
-        else:
-            image_path = qa_path = category_dir
-        assert os.path.isdir(image_path), image_path
-        assert os.path.isdir(qa_path), qa_path
-        for file in os.listdir(qa_path):
-            if not file.endswith('.txt'):
-                continue
-            for line in open(os.path.join(qa_path, file)):
-                question, answer = line.strip().split('\t')
-                ground_truth[(category, file, question)] = answer
-    return ground_truth
-
-# Chart QA
-def relaxed_correctness(target: str,
-                        prediction: str,
-                        max_relative_change: float = 0.05) -> bool:
-    """Calculates relaxed correctness.
-
-    The correctness tolerates certain error ratio defined by max_relative_change.
-    See https://arxiv.org/pdf/2203.10244.pdf, end of section 5.1:
-    “Following Methani et al. (2020), we use a relaxed accuracy measure for the
-    numeric answers to allow a minor inaccuracy that may result from the automatic
-    data extraction process. We consider an answer to be correct if it is within
-    5% of the gold answer. For non-numeric answers, we still need an exact match
-    to consider an answer to be correct.”
-
-    Args:
-    target: Target string.
-    prediction: Predicted string.
-    max_relative_change: Maximum relative change.
-
-    Returns:
-    Whether the prediction was correct given the specified tolerance.
-    """
-
-    def _to_float(text: str) -> Optional[float]:
-        try:
-            if text.endswith('%'):
-                # Convert percentages to floats.
-                return float(text.rstrip('%'))
-            else:
-                return float(text)
-        except ValueError:
-            return None
-
-    prediction_float = _to_float(prediction)
-    target_float = _to_float(target)
-    if prediction_float is not None and target_float:
-        relative_change = abs(prediction_float -
-                            target_float) / abs(target_float)
-        return relative_change <= max_relative_change
-    else:
-        return prediction.lower() == target.lower()
-        
-def evaluate_relaxed_accuracy(entries):
-    scores = []
-    for elem in entries:
-        if isinstance(elem['annotation'], str):
-            elem['annotation'] = [elem['annotation']]
-        score = max([
-            relaxed_correctness(elem['answer'].strip(), ann)
-            for ann in elem['annotation']
-        ])
-        scores.append(score)
-    return sum(scores) / len(scores)
-
-# POPE
-def eval_pope(answers, label_file):
-    label_list = [json.loads(q)['label'] for q in open(label_file, 'r')]
-
-    for answer in answers:
-        text = answer['answer'].lower()
-
-        # Only keep the first sentence
-        if text.find('.') != -1:
-            text = text.split('.')[0]
-
-        text = text.replace(',', '')
-        words = text.split(' ')
-        if 'No' in words or 'not' in words or 'no' in words:
-            answer['answer'] = 'no'
-        else:
-            answer['answer'] = 'yes'
-
-    for i in range(len(label_list)):
-        if label_list[i] == 'no':
-            label_list[i] = 0
-        else:
-            label_list[i] = 1
-
-    pred_list = []
-    for answer in answers:
-        if answer['answer'] == 'no':
-            pred_list.append(0)
-        else:
-            pred_list.append(1)
-
-    pos = 1
-    neg = 0
-
-    TP, TN, FP, FN = 0, 0, 0, 0
-    for pred, label in zip(pred_list, label_list):
-        if pred == pos and label == pos:
-            TP += 1
-        elif pred == pos and label == neg:
-            FP += 1
-        elif pred == neg and label == neg:
-            TN += 1
-        elif pred == neg and label == pos:
-            FN += 1
-
-    acc = (TP + TN) / (TP + TN + FP + FN)
-    return acc
-
-# Eval GQA
-# book to float
-def toScore(b):
-    return float(1 if b else 0)
-
-# Compute average of a list
-def avg(l):
-    if len(l) == 0:
-        return 0
-    return float(sum(l)) / len(l)
-
-def eval_gqa(predictions, questions):
-    # Initialize data structure to track all metrics: e.g. accuracy, validity and plausibility, as well as 
-    # accuracy per question type, length and number of reasoning steps.
-    scores = {
-        "accuracy": [], # list of accuracies per question (1 if correct else 0). Will be averaged ultimately.
-        "binary": [], # list of accuracies per a binary question (1 if correct else 0). Will be averaged ultimately.
-        "open": [], # list of accuracies per an open question (1 if correct else 0). Will be averaged ultimately.
-        "validity": [], # list of validity per question (1 if valid else 0).
-        "plausibility": [], # list of plausibility per question (1 if plausible else 0). 
-        "consistency": [], # list of consistency scores for entailed questions.
-        "accuracyPerStructuralType": defaultdict(list), # list of question accuracies for each structural type (e.g. compare, logic questions).
-        "accuracyPerSemanticType": defaultdict(list), # list of question accuracies for each semantic type (e.g. questions about an object, an attribute, a relation).
-        "accuracyPerLength": defaultdict(list), # list of question accuracies per question's word number.
-        "accuracyPerSteps": defaultdict(list), # list of question accuracies per question's reasoning length (steps number).
-        "grounding": [] # list of grounding scores for each question.
-    }
-
-    # Initialize golden and predicted histograms per each question group. Used to compute the distribution metric.
-    dist = {
-        "gold": defaultdict(lambda: defaultdict(int)),
-        "predicted": defaultdict(lambda: defaultdict(int))
-    }
-
-    ##### Question lengths - words numbers and reasoning steps number
-    ##########################################################################################
-
-    # Compute question length (words number)
-    def getWordsNum(question):
-        return len(question["question"].split())
-
-    # Compute number of reasoning steps (excluding the final "querying" step which doesn't increase effective reasoning length)
-    def getStepsNum(question):
-        return len([c for c in question["semantic"] if not (any([o in "{}: {}".format(c["operation"], c["argument"]) 
-            for o in ["exist", "query: name", "choose name"]]))])
-
-    ##### Main score computation 
-    ##########################################################################################
-
-    # Loop over the questions and compute mterics
-    for qid, question in questions.items():
-        gold = question["answer"]
-        if qid not in predictions:
-            continue
-        predicted = predictions[qid].lower()
-
-        correct = (predicted == gold)
-        score = toScore(correct)
-
-        wordsNum = getWordsNum(question)
-        stepsNum = getStepsNum(question)
-        
-        # Compute scores over the balanced dataset (more robust against cheating by making educated guesses)
-        if question["isBalanced"]:
-            # Update accuracy
-            scores["accuracy"].append(score)
-            scores["accuracyPerLength"][wordsNum].append(score)
-            scores["accuracyPerSteps"][stepsNum].append(score)
-            scores["accuracyPerStructuralType"][question["types"]["structural"]].append(score)
-            scores["accuracyPerSemanticType"][question["types"]["semantic"]].append(score)
-            answerType = "open" if question["types"]["structural"] == "query" else "binary"
-            scores[answerType].append(score)
-    
-            # Update histograms for gold and predicted answers
-            globalGroup = question["groups"]["global"]
-            if globalGroup is not None:
-                dist["gold"][globalGroup][gold] += 1
-                dist["predicted"][globalGroup][predicted] += 1
-
-    # Average scores over all questions (in the balanced dataset) and print scores
-    metrics = [
-        "binary",
-        "open",
-        "accuracy",
-        "consistency",
-        "validity",
-        "plausibility",
-        "grounding",
-    ]
-
-    detailedMetrics = [
-        ("accuracyPerStructuralType", "Accuracy / structural type"), 
-        ("accuracyPerSemanticType", "Accuracy / semantic type"), 
-        ("accuracyPerSteps", "Accuracy / steps number"),
-        ("accuracyPerLength", "Accuracy / words number") 
-    ]
-
-    subMetrics = {
-        "attr": "attribute",
-        "cat": "category",
-        "global": "scene",
-        "obj": "object",
-        "rel": "relation" 
-    }
-    # average
-    for k in metrics:
-        if isinstance(scores[k], list):
-            scores[k] = avg(scores[k]) * 100
-
-    for k, _ in detailedMetrics:
-        for t in scores[k]:
-            scores[k][t] = avg(scores[k][t]) * 100, len(scores[k][t])
-
-    # print
-    print("")
-    for m in metrics:
-        # skip grounding and consistency scores if not requested
-        if m == "grounding":
-            continue
-        if m == "consistency":
-            continue
-
-        # print score
-        print("{title}: {score:.2f}{suffix}".format(title = m.capitalize(), score = scores[m], 
-            suffix = " (lower is better)" if m == "distribution" else "%"))
-
-    for m, mPrintName in detailedMetrics:
-        print("")
-        # print metric title
-        print("{}:".format(mPrintName))
-        
-        for t in sorted(list(scores[m].keys())):
-            # set sub-metric title
-            tName = t
-            if isinstance(scores[k], list):
-                tName = subMetrics.get(t, t).capitalize()
-
-            # print score
-            print("  {title}: {score:.2f}{suffix} ({amount} questions)".format(title = tName, 
-                score = scores[m][t][0], suffix = "%", amount = scores[m][t][1]))    
-            
-    return scores
-
-# MMMU
-DOMAIN_CAT2SUB_CAT = {
-  'Art and Design': ['Art', 'Art_Theory', 'Design', 'Music'],
-  'Business': ['Accounting', 'Economics', 'Finance', 'Manage','Marketing'],
-  'Science': ['Biology', 'Chemistry', 'Geography', 'Math', 'Physics',],
-  'Health and Medicine': ['Basic_Medical_Science', 'Clinical_Medicine', 'Diagnostics_and_Laboratory_Medicine', 'Pharmacy', 'Public_Health'],
-  'Humanities and Social Science': ['History', 'Literature', 'Sociology', 'Psychology'],
-  'Tech and Engineering': ['Agriculture', 'Architecture_and_Engineering', 'Computer_Science', 'Electronics', 'Energy_and_Power', 'Materials', 'Mechanical_Engineering'],
-}
-
-
-CAT_SHORT2LONG = {
-    'acc': 'Accounting',
-    'agri': 'Agriculture',
-    'arch': 'Architecture_and_Engineering',
-    'art': 'Art',
-    'art_theory': 'Art_Theory',
-    'bas_med': 'Basic_Medical_Science',
-    'bio': 'Biology',
-    'chem': 'Chemistry',
-    'cli_med': 'Clinical_Medicine',
-    'cs': 'Computer_Science',
-    'design': 'Design',
-    'diag_med': 'Diagnostics_and_Laboratory_Medicine',
-    'econ': 'Economics',
-    'elec': 'Electronics',
-    'ep': 'Energy_and_Power',
-    'fin': 'Finance',
-    'geo': 'Geography',
-    'his': 'History',
-    'liter': 'Literature',
-    'manage': 'Manage',
-    'mark': 'Marketing',
-    'mate': 'Materials',
-    'math': 'Math',
-    'mech': 'Mechanical_Engineering',
-    'music': 'Music',
-    'phar': 'Pharmacy',
-    'phys': 'Physics',
-    'psy': 'Psychology',
-    'pub_health': 'Public_Health',
-    'socio': 'Sociology'
-}
-
-"""Response Parsing and Evaluation for various models"""
-
-# ----------- Process Multi-choice -------------
-def parse_multi_choice_response(response, all_choices, index2ans):
-    """
-    Parse the prediction from the generated response.
-    Return the predicted index e.g., A, B, C, D.
-    """
-    for char in [',', '.', '!', '?', ';', ':', "'"]:
-        response = response.strip(char)
-    response = " " + response + " " # add space to avoid partial match
-
-    index_ans = True
-    ans_with_brack = False
-    candidates = []
-    for choice in all_choices:  # e.g., (A) (B) (C) (D)
-        if f'({choice})' in response:
-            candidates.append(choice)
-            ans_with_brack = True
-
-    if len(candidates) == 0:
-        for choice in all_choices: # e.g., A B C D
-            if f' {choice} ' in response:
-                candidates.append(choice)
-
-    # if all above doesn't get candidates, check if the content is larger than 5 tokens and try to parse the example
-    if len(candidates) == 0 and len(response.split()) > 5:
-        for index, ans in index2ans.items():
-            if ans.lower() in response.lower():
-                candidates.append(index)
-                index_ans = False # it's content ans.
-
-    if len(candidates) == 0:  # still not get answer, randomly choose one.
-        pred_index = random.choice(all_choices)
-    elif len(candidates) > 1:
-        start_indexes = []
-        if index_ans:
-            if ans_with_brack: 
-                for can in candidates:
-                    index = response.rfind(f'({can})')
-                    start_indexes.append(index) # -1 will be ignored anyway
-                # start_indexes = [generated_response.index(f'({can})') for can in candidates]
-            else:
-                for can in candidates:
-                    index = response.rfind(f" {can} ")
-                    start_indexes.append(index)
-        else:
-            for can in candidates:
-                index = response.lower().rfind(index2ans[can].lower())
-                start_indexes.append(index)
-        # get the last one
-        pred_index = candidates[np.argmax(start_indexes)]
-    else: # if only one candidate, use it.
-        pred_index = candidates[0]
-
-    return pred_index
-
-# ----------- Process Open -------------
-def check_is_number(string):
-    """
-    Check if the given string a number.
-    """
-    try:
-        float(string.replace(',', ''))
-        return True
-    except ValueError:
-        # check if there's comma inside
-        return False
-
-def normalize_str(string):
-    """
-    Normalize the str to lower case and make them float numbers if possible.
-    """
-    # check if characters in the string
-
-    # if number, numerize it.
-    string = string.strip()
-
-    is_number = check_is_number(string)
-
-    if is_number:
-        string = string.replace(',', '')
-        string = float(string)
-        # leave 2 decimal
-        string = round(string, 2)
-        return [string]
-    else: # it's likely to be a string
-        # lower it 
-        string = string.lower()
-        if len(string) == 1:
-            return [" " + string, string + " "] # avoid trivial matches
-        return [string]
-
-def extract_numbers(string):
-    """
-    Exact all forms of numbers from a string with regex.
-    """
-    # Pattern for numbers with commas
-    pattern_commas = r'-?\b\d{1,3}(?:,\d{3})+\b'
-    # Pattern for scientific notation
-    pattern_scientific = r'-?\d+(?:\.\d+)?[eE][+-]?\d+'
-    # Pattern for simple numbers without commas
-    pattern_simple = r'-?(?:\d+\.\d+|\.\d+|\d+\b)(?![eE][+-]?\d+)(?![,\d])'
-
-    # Extract numbers with commas
-    numbers_with_commas = re.findall(pattern_commas, string)
-    # Extract numbers in scientific notation
-    numbers_scientific = re.findall(pattern_scientific, string)
-    # Extract simple numbers without commas
-    numbers_simple = re.findall(pattern_simple, string)
-
-    # Combine all extracted numbers
-    all_numbers = numbers_with_commas + numbers_scientific + numbers_simple
-    return all_numbers
-
-def parse_open_response(response):
-    """
-    Parse the prediction from the generated response.
-    Return a list of predicted strings or numbers.
-    """
-    # content = content.strip("\n").strip(".").strip(" ")
-    def get_key_subresponses(response):
-        key_responses = []
-        response = response.strip().strip(".").lower()
-        sub_responses = re.split(r'\.\s(?=[A-Z])|\n', response)
-        indicators_of_keys = ['could be ', 'so ', 'is ',
-                            'thus ', 'therefore ', 'final ', 'answer ', 'result ']
-        key_responses = []
-        for index, resp in enumerate(sub_responses):
-            # if last one, accept it's an equation (the entire response can be just one sentence with equation)
-            if index == len(sub_responses) - 1:
-                indicators_of_keys.extend(['='])
-            shortest_key_response = None # the shortest response that may contain the answer (tail part of the response)
-            for indicator in indicators_of_keys:
-                if indicator in resp:
-                    if not shortest_key_response:
-                        shortest_key_response = resp.split(indicator)[-1].strip()
-                    else:
-                        if len(resp.split(indicator)[-1].strip()) < len(shortest_key_response):
-                            shortest_key_response = resp.split(indicator)[-1].strip()
-                    # key_responses.append(resp.split(indicator)[1].strip())
-            
-            if shortest_key_response:
-                # and it's not trivial
-                if shortest_key_response.strip() not in [":", ",", ".", "!", "?", ";", ":", "'"]:
-                    key_responses.append(shortest_key_response)
-        if len(key_responses) == 0: # did not found any
-            return [response]
-        return key_responses
-    # pdb.set_trace()
-    key_responses = get_key_subresponses(response)
-
-    pred_list = key_responses.copy() # keep the original string response
-    for resp in key_responses:
-        pred_list.extend(extract_numbers(resp))
-
-    tmp_pred_list = []
-    for i in range(len(pred_list)):
-        tmp_pred_list.extend(normalize_str(pred_list[i]))
-    pred_list = tmp_pred_list
-
-    # remove duplicates
-    pred_list = list(set(pred_list))
-
-    return pred_list
-
-# ----------- Evaluation -------------
-
-def eval_multi_choice(gold_i, pred_i):
-    """
-    Evaluate a multiple choice instance.
-    """
-    correct = False
-    # only they are exactly the same, we consider it as correct
-    if isinstance(gold_i, list):
-        for answer in gold_i:
-            if answer == pred_i:
-                correct = True
-                break
-    else: # gold_i is a string
-        if gold_i == pred_i:
-            correct = True
-    return correct
-
-def eval_open(gold_i, pred_i):
-    """
-    Evaluate an open question instance
-    """
-    correct = False
-    if isinstance(gold_i, list):
-        # use float to avoid trivial matches
-        norm_answers = []
-        for answer in gold_i:
-            norm_answers.extend(normalize_str(answer))
-    else:
-        norm_answers = normalize_str(gold_i)
-    for pred in pred_i: # pred is already normalized in parse response phase
-        if isinstance(pred, str): # if it's a string, then find if ans in the pred_i
-            for norm_ans in norm_answers:
-                # only see if the string answer in the string pred
-                if isinstance(norm_ans, str) and norm_ans in pred:
-                    if not correct:
-                        correct = True
-                    break
-        else: # it's a float number
-            if pred in norm_answers:
-                if not correct:
-                    correct = True
-                break
-    return correct
-
-# ----------- Batch Evaluation -------------
-def evaluate(samples):
-    """
-    Batch evaluation for multiple choice and open questions.
-    """
-    pred_correct = 0
-    judge_dict = dict()
-    for sample in samples:
-        gold_i = sample['answer']
-        pred_i = sample['parsed_pred']
-        if sample['question_type'] == 'multiple-choice':
-            correct = eval_multi_choice(gold_i, pred_i)
-        else: # open question
-            correct = eval_open(gold_i, pred_i)
-
-        if correct:
-            judge_dict[sample['id']] = 'Correct'
-            pred_correct += 1
-        else:
-            judge_dict[sample['id']] = 'Wrong'
-
-    if len(samples) == 0:
-        return {'acc': 0}
-    return judge_dict, {'acc': pred_correct / len(samples)}
-
-
-
-# ----------- Calculate Accuracy -------------
-def calculate_ins_level_acc(results: Dict):
-    """Calculate the instruction level accuracy for given Subject results"""
-    acc = 0
-    ins_num = 0
-    for cat_results in results.values():
-        acc += cat_results['acc'] * cat_results['num_example']
-        ins_num += cat_results['num_example']
-    if ins_num == 0:
-        return 0
-    return acc / ins_num
-    
-def eval_mathverse(output_dir, results, extract_file, score_file):
-    openai.api_key = OPENAI_KEY
-    
-    demo_prompt_extract = """
-I am providing you a response from a model to a math problem, termed 'Model Response'. You should extract the answer from the response as 'Extracted Answer'. Directly output the extracted answer with no explanation.
-
-1.
-Model response: 'Rounded to two decimal places, the perimeter of the sector is approximately:\n\n(-2, 1)'
-Extracted Answer: (-2, 1)
-
-2.
-Model response: 'at those points.\n\nTherefore, the correct option that represents the meaning of the intersection points of the graphs is:\n\nD. They give the solutions to the equation $f(t)=g(t)$.",'
-Extracted Answer: D
-
-3.
-Model response: ' at 1 (there's a closed circle at y = 1), the range in interval notation is \\((-4, 1]\\).\n\nFinal values:\nDomain: \\((-3, 3]\\)\nRange: \\((-4, 1]\\)'
-Extracted Answer: Domain: \\((-3, 3]\\)\nRange: \\((-4, 1]\\)
-
-4.
-Model response: 'As it stands, I cannot provide the correct option letter because there isn't enough information to solve for 'y'.'
-Extracted Answer: null
-
-5.
-Model response: 'Given that AB = 17.6 meters, we can now substitute into the equation:\n\nd = 17.6 / cos(38\u00b0)\n\nTherefore, to one decimal place, the distance d between Ned and Bart is approximately 22.3 meters.'
-Extracted answer: 22.3
-
-6.
-Model response:  have all the coefficients for the quadratic function:\n\\( f(x) = ax^2 + bx + c \\)\n\\( f(x) = -1x^2 - 2x + 1 \\)\n\nTherefore, the equation for the graphed function \\( f \\) is:\n\\( f(x) = -x^2 - 2x + 1 \\)"'
-Extracted answer: f(x) = -x^2 - 2x + 1
-
-7.
-"""
-    demo_prompt_score = """
-Below are two answers to a math question. Question is [Question], [Standard Answer] is the standard answer to the question, and [Model_answer] is the answer extracted from a model's output to this question.  Determine whether these two answers are consistent.
-Please note that only when the [Model_answer] completely matches the [Standard Answer] means they are consistent. For non-multiple-choice questions, if the meaning is expressed in the same way, it is also considered consistent, for example, 0.5m and 50cm.
-If they are consistent, Judement is 1; if they are different, Judement is 0.
-
-[Question]: Write the set of numbers represented on the number line in interval notation.
-[Standard Answer]: (-2,1]
-[Model_answer] : Extracted Answer: \\((-2, 1)\\)
-Judgement: 0
-
-[Question]: As shown in the figure, circle O has a radius 1.0, if angle BAC = 60.0, then the length of BC is ()\nChoices:\nA:2\nB:2\u221a{{3}}\nC:\u221a{{3}}\nD:2\u221a{{2}}
-[Standard Answer]: C
-[Model_answer] : B:2\u221a{{3}}
-Judgement: 0
-
-[Question]: Find the domain and range of the function f using interval notation.
-[Standard Answer]: domain: [-4, 0) and range: (-3, 1]
-[Model_answer] : Range: \\((-4, 1]\\)
-Judgement: 0
-
-[Question]: As shown in the figure, circle O has a radius 1.0, if angle BAC = 60.0, then the length of BC is ()\nChoices:\nA:2\nB:2\u221a{{3}}\nC:\u221a{{3}}\nD:2\u221a{{2}}
-[Standard Answer]: C
-[Model_answer] : null
-Judgement: 0
-
-[Question]: Given the graph of the ellipse that intersects with x-axis at 9 and -9 and with y-axis at 3 and -3, determine its equation.A. \\frac{{x^2}}{{81}} + \\frac{{y^2}}{{9}} = 1 B. Can not determine.\n
-[Standard Answer]: A
-[Model_answer] : \\frac{{x^2}}{{81}} + \\frac{{y^2}}{{9}} = 1
-Judgement: 1
-
-[Question]: {question}
-[Standard Answer]: {gt}
-[Model_answer] : {extraction}
-Judgement: """
-    
-    def create_extract_prompt(demo_prompt, response, inst):
-        demo_prompt = demo_prompt.strip()
-        test_prompt = f"Model response: '{response}'\nExtracted Answer: "
-        full_prompt = f"{demo_prompt}\n\n{test_prompt}"
-        return full_prompt
-    
-    def create_scoring_prompt(demo_prompt, inst):
-        demo_prompt = demo_prompt.strip()
-        full_prompt = demo_prompt.format(question = inst['question'], gt=inst['answer'], extraction=inst['extraction'])
-        return full_prompt
-
-
-    def extract_answer(response, inst, api_key):
-        # general extraction
-        try:
-            full_prompt = create_extract_prompt(demo_prompt_extract, response, inst)
-            extraction = get_chat_response(full_prompt, api_key)
-            return extraction
-        except Exception as e:
-            print(e)
-            print(f"Error in extracting answer for {response}")
-        return ""
-    
-    def match_answer(inst, api_key):
-        try:
-            full_prompt = create_scoring_prompt(demo_prompt_score, inst)
-            extraction = get_chat_response(full_prompt, api_key)
-            return extraction.replace("Judgement:", "").strip()
-        except Exception as e:
-            print(e)
-            print(f"Error in matching answer")
-
-        return ""
-    
-    save_results = []
-    score_dict = defaultdict(lambda: defaultdict(list))
-    score_version_dict = defaultdict(list)
-    
-    for i, inst in enumerate(tqdm(results)):
-        response = inst['model_answer']
-        extraction = extract_answer(response, inst, OPENAI_KEY)
-        inst['extraction'] = extraction.replace('Extracted Answer: ', '').strip()
-        
-        judgement = match_answer(inst, OPENAI_KEY)
-        while True:
-            if judgement.strip() not in ['0', '1']:
-                print('Wrong return format: ', judgement)
-                judgement = match_answer(inst, OPENAI_KEY)
-            else:
-                inst['judgement'] = int(judgement)
-                break
-
-        save_results.append(inst)
-
-        score_dict[inst['metadata']['subject']][inst['metadata']['subfield']].append(inst['judgement'])
-        score_version_dict[inst['problem_version']].append(inst['judgement'])
-    
-    results_file = os.path.join(output_dir, extract_file)
-    with open(results_file, 'w') as f:
-        json.dump(save_results, f, indent=4)
-        
-    print(f"Save MathVerse Results at {results_file}")
-    
-    save_json = {}
-    # version level acc
-    total_cnt, right_cnt = 0, 0
-    for version in score_version_dict:
-        version_total_cnt = len(score_version_dict[version])
-        version_right_cnt = len([inst for inst in score_version_dict[version] if inst == 1])
-        total_cnt += version_total_cnt
-        right_cnt += version_right_cnt
-        print(f"{version} Acc: {(version_right_cnt/version_total_cnt):.3f}")
-        save_json[version] = f"{(version_right_cnt/version_total_cnt):.3f}"
-
-    print(f"Acc: {(right_cnt/total_cnt):.3f}")
-    
-    save_json["Total Acc"] = f"{(right_cnt/total_cnt):.3f}"
-    
-    scores_file = os.path.join(output_dir, score_file)
-    with open(scores_file, 'w') as f:
-        json.dump(save_json, f, indent=4)
-    
-    
-def eval_mmstar(eval_file, output_dir, score_file):
-    MMStar_score_l2 = {
-        'coarse perception': {
-            'image scene and topic': 0,
-            'image style & quality': 0,
-            'image emotion': 0
-        },
-        'fine-grained perception': {
-            'object counting': 0,
-            'recognition': 0,
-            'localization': 0
-        },
-        'instance reasoning': {
-            'single-instance reasoning': 0,
-            'cross-instance attribute reasoning': 0,
-            'cross-instance relation reasoning': 0
-        },
-        'logical reasoning': {
-            'code & sequence reasoning': 0,
-            'diagram reasoning': 0,
-            'common reasoning': 0
-        },
-        'science & technology': {
-            'biology & chemistry & physics': 0,
-            'electronics & energy & mechanical eng.': 0,
-            'geography & earth science & agriculture': 0
-        },
-        'math': {
-            'geometry': 0,
-            'numeric commonsense and calculation': 0,
-            'statistical reasoning': 0
-        },
-    }
-    MMStar_counter = deepcopy(MMStar_score_l2)
-
-    data = eval_file
-    lt = len(data)
-    lines = [data.iloc[i] for i in range(lt)]
-    for i in tqdm(range(len(lines))):
-        line = lines[i]
-        predict = str(line['prediction'])
-        answers = str(line['answer'])
-        # ori_bench = str(line['bench'])
-        category = str(line['category'])
-        l2_category = str(line['l2_category'])
-        MMStar_counter[category][l2_category] += 1
-
-        answer = answers.lower().strip().replace('\n', ' ')
-        predict = predict.lower().strip().replace('\n', ' ')
-        # if ori_bench == 'MathVista' and answer not in ['a', 'b', 'c', 'd']:
-        #     if answer in predict:
-        #         MMStar_score_l2[category][l2_category] += 1
-        # else:
-        try:
-            if answer == predict[0]:
-                MMStar_score_l2[category][l2_category] += 1
-            elif predict[0] == '(' and answer == predict[1]:
-                MMStar_score_l2[category][l2_category] += 1
-            elif predict[0:7] == 'option ' and answer == predict[7]:
-                MMStar_score_l2[category][l2_category] += 1
-            elif predict[0:14] == 'the answer is ' and answer == predict[14]:
-                MMStar_score_l2[category][l2_category] += 1
-        except Exception as e:
-            pass
-
-    MMStar_score = {}
-    MMStar_score['final score'] = 0
-    for k, v in MMStar_score_l2.items():
-        MMStar_score[k] = 0
-        for l2_k, l2_v in v.items():
-            if float(MMStar_counter[k][l2_k]) == 0:
-                MMStar_score[f'{k}({l2_k})'] = 0
-            else:
-                MMStar_score[f'{k}({l2_k})'] = float(l2_v) / \
-                    float(MMStar_counter[k][l2_k])
-            MMStar_score[k] += l2_v
-        MMStar_score['final score'] += MMStar_score[k]
-        MMStar_score[k] = float(MMStar_score[k]) / 250.0
-    MMStar_score['final score'] = float(MMStar_score['final score']) / 1500.0
-
-    score_pth = os.path.join(output_dir, score_file)
-    with open(score_pth, 'w') as f:
-        json.dump(MMStar_score, f, indent=4)
-        
-    print(
-        f'MMStar_eval successfully finished evaluating {eval_file}, results saved in {score_pth}')
-    print('Score: ')
-    for key, value in MMStar_score.items():
-        print('{}:{}'.format(key, value))