| import pandas as pd |
| from ...utils import can_infer, track_progress_rich |
| from ...smp import * |
| import numpy as np |
| import re |
|
|
| MMB_abbrs = { |
| 'coarse_perception': 'CP', |
| 'finegrained_perception (instance-level)': 'FP-S', |
| 'finegrained_perception (cross-instance)': 'FP-C', |
| 'logic_reasoning': 'LR', |
| 'relation_reasoning': 'RR', |
| 'attribute_reasoning': 'AR' |
| } |
|
|
| MMT_abbrs = { |
| 'visual_recognition': 'VR', |
| 'localization': 'Loc', |
| 'ocr': 'OCR', |
| 'counting': 'Count', |
| 'hallucination': 'HLN', |
| 'image_retrieval': 'IR', |
| 'threed': '3D', |
| 'visual_captioning': 'VC', |
| 'visual_grounding': 'VG', |
| 'doc_understanding': 'DU', |
| 'action_recognition': 'AR', |
| 'pixel_level_perception': 'PLP', |
| 'image-to-image_translation': 'I2IT', |
| 'relation_reasoning': 'RR', |
| 'intelligence_quotient_test': 'IQT', |
| 'emotion': 'Emo', |
| 'visual_illusion': 'VI', |
| 'meme_understanding': 'MemU', |
| 'visual_prompt_understanding': 'VPU', |
| 'anomaly_detection': 'AND', |
| 'keypoint_detection': 'KD', |
| 'visual_commonsense_reasoning': 'VCR', |
| 'image_evaluation_judgement': 'IEJ', |
| 'multiple_image_analysis': 'MIA', |
| 'cross_image_matching': 'CIM', |
| 'temporal_understanding': 'TU', |
| 'visual_code': 'VP', |
| 'medical_understanding': 'MedU', |
| 'autonomous_driving': 'AUD', |
| 'discipline_knowledge_reasoning': 'DKR', |
| 'embodied_ai': 'EA', |
| 'gui_navigation': 'GN' |
| } |
|
|
|
|
| def MMMU_preproc(data): |
| logger = get_logger('Evaluation') |
| cnt = 0 |
| As, Bs, Ans = list(data['A']), list(data['B']), list(data['answer']) |
| lt = len(data) |
| for i in range(lt): |
| if pd.isna(As[i]): |
| As[i] = Ans[i] |
| Bs[i] = 'Other Answers' |
| cnt += 1 |
| logger.info(f'During MMMU_preproc in Evaluation, {cnt} open questions are re-formulated to multi-choice ones. ') |
| data['A'] = As |
| data['B'] = Bs |
| return data |
|
|
|
|
| def report_acc(df): |
| |
| res = defaultdict(list) |
|
|
| if 'split' in df: |
| splits = list(set(df['split'])) |
| res['split'] = splits |
| else: |
| df['split'] = ['none'] * len(df) |
| res['split'] = ['none'] |
|
|
| for group in [None, 'l2-category', 'category']: |
| if group is None: |
| res['Overall'] = [np.mean(df[df['split'] == sp]['hit']) for sp in res['split']] |
| elif group not in df: |
| continue |
| else: |
| abilities = list(set(df[group])) |
| abilities.sort() |
| for ab in abilities: |
| ab_name = MMB_abbrs[ab] if ab in MMB_abbrs else ab |
| sub_df = df[df[group] == ab] |
| res[ab_name] = [np.mean(sub_df[sub_df['split'] == sp]['hit']) for sp in res['split']] |
| return pd.DataFrame(res) |
|
|
|
|
| def report_acc_MMT(df): |
| |
| res = defaultdict(list) |
| res['split'] = list() |
| res['Overall'] = list() |
| for _, name in MMT_abbrs.items(): |
| res[name] = list() |
|
|
| if 'split' in df: |
| splits = list(set(df['split'])) |
| res['split'] = splits |
|
|
| else: |
| df['split'] = ['none'] * len(df) |
| res['split'] = ['none'] |
|
|
| for group in [None, 'category', 'l2-category']: |
| if group is None: |
| res['Overall'] = [np.mean(df[df['split'] == sp]['hit']) for sp in res['split']] |
| res['Overall'].extend([np.mean(df['hit'])]) |
| elif group not in df: |
| continue |
| elif group == 'category': |
| abilities = list(set(df[group])) |
| abilities.sort() |
| for ab in abilities: |
| ab_name = ab |
| sub_df = df[df[group] == ab] |
| res[ab_name] = [np.mean(sub_df[sub_df['split'] == sp]['hit']) for sp in res['split']] |
| res[ab_name].extend([np.mean(sub_df['hit'])]) |
| else: |
| abilities = list(set(df[group])) |
| abilities.sort() |
| for ab in abilities: |
| sub_task_name_list = df[df['l2-category'] == ab]['category'].unique() |
| sub_task_acc = [] |
| for sub_task_name in sub_task_name_list: |
| sub_df = df[df['category'] == sub_task_name] |
| sub_task_acc.append([np.mean(sub_df[sub_df['split'] == sp]['hit']) for sp in res['split']]) |
|
|
| new_acc = [] |
| for i in range(len(sub_task_acc[0])): |
| new_acc.append(sum([_[i] for _ in sub_task_acc]) / len([_ for _ in sub_task_acc])) |
| ab_name = MMT_abbrs[ab] if ab in MMT_abbrs else ab |
| res[ab_name] = new_acc |
|
|
| sub_task_acc = [] |
| for sub_task_name in sub_task_name_list: |
| sub_df = df[df['category'] == sub_task_name] |
| sub_task_acc.append([np.mean(sub_df['hit'])]) |
| new_acc = [] |
| for i in range(len(sub_task_acc[0])): |
| new_acc.append(sum([_[i] for _ in sub_task_acc]) / len([_ for _ in sub_task_acc])) |
|
|
| res[ab_name].extend(new_acc) |
|
|
| res['split'].append('ALL') |
| return pd.DataFrame(res) |
|
|
|
|
| def build_prompt(question, options, prediction): |
| tmpl = ( |
| 'You are an AI assistant who will help me to match ' |
| 'an answer with several options of a single-choice question. ' |
| 'You are provided with a question, several options, and an answer, ' |
| 'and you need to find which option is most similar to the answer. ' |
| 'If the meaning of all options are significantly different from the answer, output Z. ' |
| 'Your should output a single uppercase character in A, B, C, D (if they are valid options), and Z. \n' |
| 'Example 1: \n' |
| 'Question: What is the main object in image?\nOptions: A. teddy bear B. rabbit C. cat D. dog\n' |
| 'Answer: a cute teddy bear\nYour output: A\n' |
| 'Example 2: \n' |
| 'Question: What is the main object in image?\nOptions: A. teddy bear B. rabbit C. cat D. dog\n' |
| 'Answer: Spider\nYour output: Z\n' |
| 'Example 3: \n' |
| 'Question: {}?\nOptions: {}\nAnswer: {}\nYour output: ' |
| ) |
| return tmpl.format(question, options, prediction) |
|
|
|
|
| def build_prompt_wemath(question, options, prediction): |
| tmpl = ( |
| 'You are an AI assistant who will help me to match ' |
| 'an answer with several options of a single-choice question. ' |
| 'You are provided with a question, several options, and an answer, ' |
| 'and you need to find which option is most similar to the answer. ' |
| 'If the meaning of all options are significantly different from the answer, output Z. ' |
| 'Your should output a single uppercase character in A, B, C, D, E, F, G (if they are valid options), and Z. \n' |
| 'Example 1: \n' |
| 'Question: <start>\nWhat is the main object in image?\nOptions: A. teddy bear B. rabbit C. cat D. dog\n<end>\n' |
| 'Answer: <start>\na cute teddy bear\n<end>\nYour output: A\n' |
| 'Example 2: \n' |
| 'Question: <start>\nWhat is the main object in image?\nOptions: A. teddy bear B. rabbit C. cat D. dog\n<end>\n' |
| 'Answer: <start>\nSpider\n<end>\nYour output: Z\n' |
| 'Example 3: \n' |
| 'Question: <start>\n{}\nOptions: {}\n<end>\nAnswer: <start>\n{}\n<end>\nYour output: ' |
| ) |
| question = question.replace( |
| ("Regarding the format, please answer following the template below, and be sure to include two <> symbols:\n" |
| "<Thought process>: <<your thought process>> <Answer>: <<your option>>"), |
| '', |
| ) |
| return tmpl.format(question, options, prediction) |
|
|
|
|
| def build_prompt_blink(question, options, prediction): |
| tmpl = ( |
| 'You are an AI assistant who will help me to match an answer with several options of a single-choice question. ' |
| 'You are provided with a question, several options, and an answer, ' |
| 'and you need to find which option is most similar to the answer. ' |
| "If the answer says things like refuse to answer, I'm sorry cannot help, etc., output Z." |
| 'If the meaning of all options are significantly different from the answer, ' |
| 'or the answer does not select any option, output Z. ' |
| 'Your should output one of the choices, A, B, C, D (if they are valid options), or Z.\n' |
| 'Example 1: \n' |
| 'Question: Which point is closer to the camera?\nSelect from the following choices.\n' |
| 'Options: A. Point A\nB. Point B\n(Z) Failed\n' |
| 'Answer: Point B, where the child is sitting, is closer to the camera.\nYour output: (B)\n' |
| 'Example 2: \n' |
| 'Question: Which point is closer to the camera?\nSelect from the following choices.\n' |
| 'Options: (A) Point A\n(B) Point B\n(Z) Failed\n' |
| "Answer: I'm sorry, but I can't assist with that request.\nYour output: (Z)\n" |
| 'Example 3: \n' |
| 'Question: Which point is corresponding to the reference point?\nSelect from the following choices.\n' |
| 'Options: (A) Point A\n(B) Point B\n(Z) Failed\n' |
| 'Answer:The reference point (REF) on the first image is at the tip of the pot, ' |
| 'which is the part used to Poke if the pots were used for that action. Looking at the second image, ' |
| 'we need to find the part of the object that would correspond to poking.\n' |
| "(A) Point A is at the tip of the spoon's handle, which is not used for poking.\n" |
| '(B) Point B is at the bottom of the spoon, which is not used for poking.\n' |
| '(C) Point C is on the side of the pspoonot, which is not used for poking.\n' |
| '(D) Point D is at the tip of the spoon, which is not used for poking.\n' |
| '\nTherefore, there is no correct answer in the choices\nYour output: (Z)\n' |
| 'Example 4: \n' |
| 'Question: {}?\nOptions: {}\n(Z) Failed\nAnswer: {}\nYour output: ' |
| ) |
| return tmpl.format(question, options, prediction) |
|
|
|
|
| def build_prompt_cn(question, options, prediction): |
| tmpl = ( |
| '你是一个帮助我匹配答案与单选题中多个选项的 AI 助手。' |
| '你会被提供：一个问题，多个选项，一个答案。你的任务是找到与答案意义最相近的选项。' |
| '如果所有选项的意义都与答案显著不同，则输出 Z。' |
| '你应该输出一个单个的大写字母，例如 A, B, C, D（如果它们是有效选项），或 Z。' |
| '例 1:' |
| '问题: 图中最主要的物体是什么?\n选项: A. 泰迪熊 B. 兔子 C. 猫 D. 狗\n答案: 一只可爱的泰迪熊\n输出: A\n' |
| '例 2: \n' |
| '问题: 图中最主要的物体是什么?\n选项: A. 泰迪熊 B. 兔子 C. 猫 D. 狗\n答案: 蜘蛛\n输出: Z\n' |
| '例 3: \n' |
| '问题: {}?\n选项: {}\n答案: {}\n输出: ' |
| ) |
| return tmpl.format(question, options, prediction) |
|
|
|
|
| def build_choices(item): |
| ret = {} |
| for ch in string.ascii_uppercase: |
| if ch in item and (not pd.isna(item[ch])): |
| ret[ch] = item[ch] |
| return ret |
|
|
|
|
| def prefetch_answer(item): |
| choices = build_choices(item) |
| return can_infer(item['prediction'], choices) |
|
|
|
|
| def extract_answer_from_item(model, item, dataset_name=None): |
| logger = get_logger('Evaluation') |
| |
| choices = build_choices(item) |
| option_str = build_option_str(choices) |
|
|
| if dataset_name == 'BLINK': |
| prompt = build_prompt_blink(item['question'], option_str, item['prediction']) |
| elif dataset_name == 'WeMath': |
| prompt = build_prompt_wemath(item['question'], option_str, item['prediction']) |
| elif cn_string(item['question']): |
| prompt = build_prompt_cn(item['question'], option_str, item['prediction']) |
| else: |
| prompt = build_prompt(item['question'], option_str, item['prediction']) |
| retry = 3 |
|
|
| ret = can_infer(item['prediction'], choices) |
| if ret: |
| return dict(opt=ret, log=item['prediction']) |
| if model is None: |
| return dict(opt='Z', log='Failed in Prefetch, no GPT-based answer matching under `exact_matching` policy.') |
|
|
| while retry: |
| ans = model.generate(prompt) |
| if 'Failed to obtain answer via API' in ans: |
| logger.warning('GPT API failed to answer. ') |
| else: |
| ret = can_infer(ans, choices) |
| if ret: |
| return dict(opt=ret, log=ans) |
| else: |
| logger.warning(f'Output includes 0 / > 1 letter among candidates {set(choices)} and Z: {ans}') |
| retry -= 1 |
|
|
| if retry == 0: |
| options = list(choices) + ['Z'] if 'Z' not in choices else [] |
| return dict(opt=rd.choice(options), log='Failed to predict, thus randomly generate one. ') |
|
|
|
|
| |
| def prefetch_circular_group(sub_data, verbose=False): |
| lt = len(sub_data) |
| GT, PRED = [], [] |
| for i in range(lt): |
| item = sub_data.iloc[i] |
| GT.append(item['GT']) |
| PRED.append(prefetch_answer(item)) |
| if PRED[-1] and (GT[-1] != PRED[-1]): |
| log = ( |
| f'Failed in Prefetching Rolling {i}: Answer is {GT[-1]}, ' |
| f"Prediction is {item['prediction']}, Pre-fetched is {PRED[-1]}. " |
| ) |
| return dict(hit=0, log=log) |
| flag = True |
| for g, p in zip(GT, PRED): |
| if g != p: |
| flag = False |
| ret = (dict(hit=1, log='Succeed During Pre-fetching'), ) if flag else (None, ) |
| ret = ret + (GT, PRED) if verbose else ret |
| return ret if len(ret) > 1 else ret[0] |
|
|
|
|
| def eval_vanilla(model, item, dataset_name=None): |
| res = extract_answer_from_item(model, item, dataset_name=dataset_name) |
| opt, match_log = res['opt'], res['log'] |
| if opt == item['GT']: |
| return dict(hit=1, log=f'Match Log: {match_log}. ') |
| else: |
| return dict(hit=0, log=f'Match Log: {match_log}. ') |
|
|
|
|
| |
| def eval_circular_group(model, sub_data, dataset_name=None): |
| prefetched = prefetch_circular_group(sub_data, verbose=True) |
| if isinstance(prefetched, dict) and 'hit' in prefetched: |
| return prefetched |
| |
| res, GT, PRED = prefetch_circular_group(sub_data, verbose=True) |
| if res is not None: |
| return res |
|
|
| lt = len(sub_data) |
| log = '' |
| for i in range(lt): |
| if PRED[i]: |
| log += f'Rolling {i} Matched.\n' |
| else: |
| res = extract_answer_from_item(model, sub_data.iloc[i], dataset_name=dataset_name) |
| opt, match_log = res['opt'], res['log'] |
| PRED[i] = opt |
| if PRED[i] != GT[i]: |
| log += ( |
| f"Failed in Rolling {i}: Answer is {GT[i]}; Prediction is {sub_data.iloc[i]['prediction']}; " |
| f'Pre-fetched is {PRED[i]}; Match Log is {match_log}.\n' |
| ) |
| return dict(hit=0, log=log) |
| else: |
| log += ( |
| f"Rolling {i}: Answer is {GT[i]}, Prediction is {sub_data.iloc[i]['prediction']}, " |
| f'Pre-fetched is {PRED[i]}.\n' |
| ) |
|
|
| return dict(hit=1, log=log) |
|
|
|
|
| |
| def mcq_vanilla_eval(model, data, meta, nproc, result_file, dataset_name=None): |
| result = {} |
| if osp.exists(result_file): |
| result = load(result_file) |
| answer_map = {i: c for i, c in zip(meta['index'], meta['answer'])} |
|
|
| if 'MMMU' in dataset_name: |
| data = MMMU_preproc(data) |
| answer_map = {k: (v if v in list(string.ascii_uppercase) else 'A') for k, v in answer_map.items()} |
|
|
| data = data[data['index'].isin(answer_map)] |
| data['GT'] = [answer_map[idx] for idx in data['index']] |
| items = [] |
|
|
| for i in range(len(data)): |
| |
| item = data.iloc[i] |
| if item['index'] not in result: |
| items.append(item) |
|
|
| tups = [dict(model=model, item=x, dataset_name=dataset_name) for x in items] |
| keys = [x['index'] for x in items] |
| if len(tups): |
| res = track_progress_rich(eval_vanilla, tups, nproc=nproc, chunksize=nproc, save=result_file, keys=keys) |
| result = load(result_file) |
| for k, v in zip(keys, res): |
| if k not in result: |
| result[k] = v |
| data['hit'] = [result[i]['hit'] for i in data['index']] |
| data['log'] = [result[i]['log'] for i in data['index']] |
| if 'GT' in data: |
| data.pop('GT') |
| return data |
|
|
|
|
| |
| def mcq_circular_eval(model, data, meta, nproc, result_file, dataset_name=None): |
| result = {} |
| if osp.exists(result_file): |
| result = load(result_file) |
| |
| answer_map = {i: c for i, c in zip(meta['index'], meta['answer'])} |
|
|
| for idx in list(meta['index']) + list(data['index']): |
| assert istype(idx, int) |
| if 'g_index' not in data: |
| data['g_index'] = [int(x % 1e6) for x in data['index']] |
|
|
| |
| data = data[data['index'].isin(answer_map)] |
| data['GT'] = [answer_map[idx] for idx in data['index']] |
| |
| data['tmp_flag'] = [x == y for x, y in zip(data['index'], data['g_index'])] |
| data_main = data[data['tmp_flag']] |
| data_main.pop('tmp_flag') |
| |
| data_groups = [] |
| for i in range(len(data_main)): |
| |
| idx = data_main.iloc[i]['index'] |
| if idx not in result: |
| sub_data = data[data['g_index'] == idx] |
| data_groups.append(sub_data) |
|
|
| if len(data_groups): |
| prefetched = [prefetch_circular_group(g, verbose=False) for g in data_groups] |
| remain = [] |
| for dg, pf in zip(data_groups, prefetched): |
| if pf is not None: |
| result[dg.iloc[0]['g_index']] = pf |
| else: |
| remain.append(dg) |
| dump(result, result_file) |
|
|
| tups = [dict(model=model, sub_data=x, dataset_name=dataset_name) for x in remain] |
| keys = [x.iloc[0]['g_index'] for x in remain] |
|
|
| if len(tups) == 0: |
| pass |
| elif model is None: |
| logger = get_logger('Evaluation') |
| logger.warning('Exact Matching mode, will not do GPT-based answer matching. ') |
| for k in keys: |
| result[k] = dict( |
| hit=0, log='Failed in Prefetch, no GPT-based answer matching under `exact_matching` policy.') |
| else: |
| res = track_progress_rich( |
| eval_circular_group, |
| tups, |
| nproc=nproc, |
| chunksize=nproc, |
| save=result_file, |
| keys=keys) |
| result = load(result_file) |
| for k, v in zip(keys, res): |
| if k not in result: |
| result[k] = v |
|
|
| tmp_pth = f'/tmp/{timestr()}.xlsx' |
| dump(data_main, tmp_pth) |
| data_main = load(tmp_pth) |
| indices = data_main['index'] |
| data_main['hit'] = [result[i]['hit'] for i in indices] |
| data_main['log'] = [result[i]['log'] for i in indices] |
| if 'GT' in data_main: |
| data_main.pop('GT') |
|
|
| return data_main |
|
|
|
|
| def extract_characters_regex(s, choices=['(A)', '(B)', '(C)', '(D)', '(E)']): |
| if type(s) is dict: |
| s = '' |
| s = s.strip() |
| answer_prefixes = [ |
| 'The best answer is', |
| 'The correct answer is', |
| 'The answer is', |
| 'The answer', |
| 'The best option is' |
| 'The correct option is', |
| 'Best answer:' |
| 'Best option:', |
| ] |
| for answer_prefix in answer_prefixes: |
| s = s.replace(answer_prefix, '') |
|
|
| if len(s.split()) > 10 and not re.search('[ABCDE]', s): |
| return '' |
| matches = re.search(r'[ABCDE]', s) |
| if matches is None: |
| for choice in choices: |
| if s.lower() in choice.lower(): |
| return choice[1] |
| return '' |
| return matches[0] |
|
|
|
|
| def get_dimension_rating(data_path): |
| TASKS = [ |
| 'Reasoning', |
| 'Perception', |
| ] |
|
|
| SUBTASKS = [ |
| 'Monitoring', |
| 'Autonomous_Driving', |
| 'OCR with Complex Context', |
| 'Diagram and Table', |
| 'Remote Sensing', |
| ] |
| data = load(data_path) |
| results = {} |
| results['Overall'] = {} |
| for task in TASKS: |
| results[f'{task}'] = {} |
| for subtask in SUBTASKS: |
| results[f'{task}'][f'{subtask}'] = {} |
|
|
| for i in range(len(data)): |
| question = data.iloc[i] |
| Task = question['category'].split('/')[0] |
| Subtask = question['category'].split('/')[1] |
| Category = question['l2-category'].lower() |
| if 'attribute' in Category.lower(): |
| Category = Category.split('/')[0] + '/attribute' |
| if question['score'] >= 0: |
| cnt = question['score'] |
| if Category not in results[Task][Subtask].keys(): |
| results[Task][Subtask][f'{Category}'] = {'true': cnt, 'false': 1 - cnt} |
| else: |
| results[Task][Subtask][f'{Category}']['true'] += cnt |
| results[Task][Subtask][f'{Category}']['false'] += 1 - cnt |
|
|
| sum_all, succ_all = 0, 0 |
| for task, tasks_values in results.items(): |
| cnt_task, sum_task = 0, 0 |
| for substask, subtask_value in tasks_values.items(): |
| cnt_subtask, sum_subtask = 0, 0 |
| for category, category_dict in subtask_value.items(): |
| cnt_subtask += category_dict['true'] |
| sum_subtask += category_dict['false'] + category_dict['true'] |
| acc = category_dict['true'] / (category_dict['false'] + category_dict['true']) |
| results[task][substask][category] = acc |
| if sum_subtask == 0: |
| acc_subtasks = 0 |
| else: |
| acc_subtasks = cnt_subtask / sum_subtask |
| cnt_task += cnt_subtask |
| sum_task += sum_subtask |
| results[task][substask]['Avg'] = acc_subtasks |
| if sum_task == 0: |
| acc_task = 0 |
| else: |
| acc_task = cnt_task / sum_task |
| succ_all += cnt_task |
| sum_all += sum_task |
| results[task]['Avg'] = acc_task |
| results['Overall'] = succ_all / sum_all |
| return results |
|
|
