','',s)
+ # s = re.sub(r'',lambda x:f' ',s)
+ # s = re.sub(r' ',lambda x:f' ',s)
+ res = ''
+ res += '\n\n'
+ temp_item = ''
+ for c in s:
+ temp_item += c
+ if c == '>' and not re.search(r'\$',temp_item):
+ res += temp_item+'\n'
+ temp_item = ''
+ return res+'\n'
+def merge_table(md):
+ table_temp = ''
+ for line in md:
+ table_temp += line
+ return convert_table_str(table_temp)
+def find_md_table_mode(line):
+ if re.search(r'-*?:',line) or re.search(r'---',line) or re.search(r':-*?',line):
+ return True
+ return False
+def delete_table_and_body(input_list):
+ res = []
+ for line in input_list:
+ if not re.search(r'',line):
+ res.append(line)
+ return res
+def merge_tables(input_str):
+ # Delete HTML comments
+ input_str = re.sub(r'', '', input_str)
+
+ # Use regex to find each block
+ table_blocks = re.findall(r'', input_str)
+
+ # Process each block, replace with
+ output_lines = []
+ for block in table_blocks:
+ block_lines = block.split('\n')
+ for i, line in enumerate(block_lines):
+ if ' ' in line:
+ block_lines[i] = line.replace(' ', ' ').replace('', ' ')
+ final_tr = delete_table_and_body(block_lines)
+ if len(final_tr) > 2:
+ output_lines.extend(final_tr) # Ignore tags, keep only table content
+
+ # Rejoin the processed strings
+ merged_output = ''.format('\n'.join(output_lines))
+
+ return "\n\n" + merged_output + "\n\n"
+
+def replace_table_with_placeholder(input_string):
+ lines = input_string.split('\n')
+ output_lines = []
+
+ in_table_block = False
+ temp_block = ""
+ last_line = ""
+
+ org_table_list = []
+ in_org_table = False
+
+ for idx, line in enumerate(lines):
+ # if not in_org_table:
+ # if "" not in last_line and in_table_block == False and temp_block != "":
+ # output_lines.append(merge_tables(temp_block))
+ # temp_block = ""
+ if "" in line:
+ # if "" not in last_line:
+ temp_block += "\n" + last_line
+ if "
" in last_line:
+ if "" not in line:
+ in_table_block = False
+ output_lines.append(merge_tables(temp_block))
+ temp_block = ""
+ else:
+ output_lines.append(last_line)
+
+ last_line = line
+ # else:
+ # org_table_list.append(line)
+ # if "" in last_line:
+ temp_block += "\n" + last_line
+ output_lines.append(merge_tables(temp_block))
+ else:
+ output_lines.append(last_line)
+ # if "
" in last_line:
+ # output_lines.append(merge_tables(temp_block))
+
+ return '\n'.join(output_lines)
+
+def convert_table(input_str):
+ # Replace
+ output_str = input_str.replace("", "")
+
+ # Replace
+ output_str = output_str.replace(" ", " ")
+
+ return output_str
+
+def convert_markdown_to_html(markdown_content):
+ # Define a regex pattern to find Markdown tables with newlines
+ markdown_content = markdown_content.replace('\r', '')+'\n'
+ pattern = re.compile(r'\|\s*.*?\s*\|\n', re.DOTALL)
+
+ # Find all matches in the Markdown content
+ matches = pattern.findall(markdown_content)
+
+ for match in matches:
+ html_table = markdown_to_html(match)
+ markdown_content = markdown_content.replace(match, html_table, 1) # Only replace the first occurrence
+
+ res_html = convert_table(replace_table_with_placeholder(markdown_content))
+
+ return res_html
\ No newline at end of file
diff --git a/vlmeval/dataset/__init__.py b/vlmeval/dataset/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2d6532b812c45873cf02f15dfd958aa463f79c74
--- /dev/null
+++ b/vlmeval/dataset/__init__.py
@@ -0,0 +1,259 @@
+import warnings
+
+from .image_base import img_root_map, ImageBaseDataset
+from .image_caption import ImageCaptionDataset
+from .image_yorn import ImageYORNDataset
+from .image_mcq import (
+ ImageMCQDataset, MMMUDataset, CustomMCQDataset, MUIRDataset, GMAIMMBenchDataset, MMERealWorld, HRBenchDataset,
+ NaturalBenchDataset, WeMath, MMMUProDataset, VMCBenchDataset
+)
+from .image_mt import MMDUDataset
+from .image_vqa import (
+ ImageVQADataset, MathVision, OCRBench, MathVista, LLaVABench, MMVet, MTVQADataset, TableVQABench,
+ CustomVQADataset, CRPE, MathVerse, OlympiadBench, QSpatial, VizWiz, MMNIAH, LogicVista, MME_CoT
+)
+
+from .image_ccocr import CCOCRDataset
+from .image_shortqa import ImageShortQADataset
+from .text_mcq import CustomTextMCQDataset, TextMCQDataset
+
+from .vcr import VCRDataset
+from .mmlongbench import MMLongBench
+from .dude import DUDE
+from .slidevqa import SlideVQA
+from .vl_rewardbench import VLRewardBench
+from .vlm2bench import VLM2Bench
+
+from .mmdocbench import MMDocBench
+
+from .mmbench_video import MMBenchVideo
+from .videomme import VideoMME
+from .mvbench import MVBench, MVBench_MP4
+from .tamperbench import MVTamperBench
+from .miabench import MIABench
+from .mlvu import MLVU, MLVU_MCQ, MLVU_OpenEnded
+from .tempcompass import TempCompass, TempCompass_Captioning, TempCompass_MCQ, TempCompass_YorN
+from .longvideobench import LongVideoBench
+from .video_concat_dataset import ConcatVideoDataset
+from .mmgenbench import MMGenBench
+from .cgbench import CGBench_MCQ_Grounding_Mini, CGBench_OpenEnded_Mini, CGBench_MCQ_Grounding, CGBench_OpenEnded
+from .megabench import MEGABench
+from .moviechat1k import MovieChat1k
+from .vdc import VDC
+
+from .worldsense import WorldSense
+from .qbench_video import QBench_Video, QBench_Video_MCQ, QBench_Video_VQA
+
+from .miabench import MIABench
+from .cmmmu import CMMMU
+from .emma import EMMADataset
+from .wildvision import WildVision
+from .mmmath import MMMath
+from .dynamath import Dynamath
+from .creation import CreationMMBenchDataset
+from .mmalignbench import MMAlignBench
+from .utils import *
+from .video_dataset_config import *
+from ..smp import *
+from .Omnidocbench.omnidocbench import OmniDocBench
+from .moat import MOAT
+
+
+class ConcatDataset(ImageBaseDataset):
+ # This dataset takes multiple dataset names as input and aggregate them into a single dataset.
+ # Each single dataset should not have a field named `SUB_DATASET`
+
+ DATASET_SETS = {
+ 'MMMB': ['MMMB_ar', 'MMMB_cn', 'MMMB_en', 'MMMB_pt', 'MMMB_ru', 'MMMB_tr'],
+ 'MTL_MMBench_DEV': [
+ 'MMBench_dev_ar', 'MMBench_dev_cn', 'MMBench_dev_en',
+ 'MMBench_dev_pt', 'MMBench_dev_ru', 'MMBench_dev_tr'
+ ],
+ }
+
+ def __init__(self, dataset):
+ datasets = self.DATASET_SETS[dataset]
+ self.dataset_map = {}
+ # The name of the compliation
+ self.dataset_name = dataset
+ self.datasets = datasets
+ for dname in datasets:
+ dataset = build_dataset(dname)
+ assert dataset is not None, dataset
+ self.dataset_map[dname] = dataset
+ TYPES = [x.TYPE for x in self.dataset_map.values()]
+ MODALITIES = [x.MODALITY for x in self.dataset_map.values()]
+ assert np.all([x == TYPES[0] for x in TYPES]), (datasets, TYPES)
+ assert np.all([x == MODALITIES[0] for x in MODALITIES]), (datasets, MODALITIES)
+ self.TYPE = TYPES[0]
+ self.MODALITY = MODALITIES[0]
+ data_all = []
+ for dname in datasets:
+ data = self.dataset_map[dname].data
+ data['SUB_DATASET'] = [dname] * len(data)
+ data_new = localize_df(data, dname, nproc=16)
+ data_all.append(data_new)
+
+ data = pd.concat(data_all)
+ data['original_index'] = data.pop('index')
+ data['index'] = np.arange(len(data))
+ self.data = data
+
+ def build_prompt(self, line):
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+ idx = line['original_index']
+ dname = line['SUB_DATASET']
+ org_data = self.dataset_map[dname].data
+ org_line = cp.deepcopy(org_data[org_data['index'] == idx]).iloc[0]
+ return self.dataset_map[dname].build_prompt(org_line)
+
+ def dump_image(self, line):
+ # Assert all images are pre-dumped
+ assert 'image' not in line
+ assert 'image_path' in line
+ tgt_path = toliststr(line['image_path'])
+ return tgt_path
+
+ @classmethod
+ def supported_datasets(cls):
+ return list(cls.DATASET_SETS)
+
+ def evaluate(self, eval_file, **judge_kwargs):
+ suffix = eval_file.split('.')[-1]
+ # First, split the eval_file by dataset
+ data_all = load(eval_file)
+ for dname in self.datasets:
+ tgt = eval_file.replace(self.dataset_name, dname)
+ data_sub = data_all[data_all['SUB_DATASET'] == dname]
+ data_sub.pop('index')
+ data_sub['index'] = data_sub.pop('original_index')
+ data_sub.pop('SUB_DATASET')
+ dump(data_sub, tgt)
+ # Then, evaluate each dataset separately
+ results_all = []
+ for dname in self.datasets:
+ tgt = eval_file.replace(self.dataset_name, dname)
+ res = self.dataset_map[dname].evaluate(tgt, **judge_kwargs)
+ assert isinstance(res, pd.DataFrame)
+ res['DATASET'] = [dname] * len(res)
+ results_all.append(res)
+ result = pd.concat(results_all)
+ score_file = eval_file.replace(f'.{suffix}', '_acc.csv')
+ dump(result, score_file)
+ return result
+
+
+# Add new supported dataset class here
+IMAGE_DATASET = [
+ ImageCaptionDataset, ImageYORNDataset, ImageMCQDataset, ImageVQADataset,
+ MathVision, MMMUDataset, OCRBench, MathVista, LLaVABench, MMVet,
+ MTVQADataset, TableVQABench, MMLongBench, VCRDataset, MMDUDataset, DUDE,
+ SlideVQA, MUIRDataset, CCOCRDataset, GMAIMMBenchDataset, MMERealWorld,
+ HRBenchDataset, CRPE, MathVerse, NaturalBenchDataset, MIABench,
+ OlympiadBench, WildVision, MMMath, QSpatial, Dynamath, MMGenBench, VizWiz,
+ MMNIAH, CMMMU, VLRewardBench, WeMath, LogicVista, MMMUProDataset,
+ CreationMMBenchDataset, ImageShortQADataset, MMAlignBench, OmniDocBench,
+ VLM2Bench, VMCBenchDataset, EMMADataset, MME_CoT, MOAT, MMDocBench
+]
+
+
+VIDEO_DATASET = [
+ MMBenchVideo, VideoMME, MVBench, MVBench_MP4, MVTamperBench, LongVideoBench, WorldSense, VDC, MovieChat1k,
+ MLVU, MLVU_MCQ, MLVU_OpenEnded,
+ TempCompass, TempCompass_MCQ, TempCompass_Captioning, TempCompass_YorN,
+ CGBench_MCQ_Grounding_Mini, CGBench_OpenEnded_Mini, CGBench_MCQ_Grounding, CGBench_OpenEnded,
+ MEGABench, WorldSense, QBench_Video, QBench_Video_MCQ, QBench_Video_VQA
+]
+
+TEXT_DATASET = [
+ TextMCQDataset
+]
+
+CUSTOM_DATASET = [
+ CustomMCQDataset, CustomVQADataset, CustomTextMCQDataset
+]
+
+DATASET_COLLECTION = [ConcatDataset, ConcatVideoDataset]
+
+DATASET_CLASSES = IMAGE_DATASET + VIDEO_DATASET + TEXT_DATASET + CUSTOM_DATASET + DATASET_COLLECTION # noqa: E501
+SUPPORTED_DATASETS = []
+for DATASET_CLS in DATASET_CLASSES:
+ SUPPORTED_DATASETS.extend(DATASET_CLS.supported_datasets())
+
+
+def DATASET_TYPE(dataset, *, default: str = 'MCQ') -> str:
+ for cls in DATASET_CLASSES:
+ if dataset in cls.supported_datasets():
+ if hasattr(cls, 'TYPE'):
+ return cls.TYPE
+ # Have to add specific routine to handle ConcatDataset
+ if dataset in ConcatDataset.DATASET_SETS:
+ dataset_list = ConcatDataset.DATASET_SETS[dataset]
+ TYPES = [DATASET_TYPE(dname) for dname in dataset_list]
+ assert np.all([x == TYPES[0] for x in TYPES]), (dataset_list, TYPES)
+ return TYPES[0]
+
+ if 'openended' in dataset.lower():
+ return 'VQA'
+ warnings.warn(f'Dataset {dataset} is a custom one and not annotated as `openended`, will treat as {default}. ') # noqa: E501
+ return default
+
+
+def DATASET_MODALITY(dataset, *, default: str = 'IMAGE') -> str:
+ if dataset is None:
+ warnings.warn(f'Dataset is not specified, will treat modality as {default}. ')
+ return default
+ for cls in DATASET_CLASSES:
+ if dataset in cls.supported_datasets():
+ if hasattr(cls, 'MODALITY'):
+ return cls.MODALITY
+ # Have to add specific routine to handle ConcatDataset
+ if dataset in ConcatDataset.DATASET_SETS:
+ dataset_list = ConcatDataset.DATASET_SETS[dataset]
+ MODALITIES = [DATASET_MODALITY(dname) for dname in dataset_list]
+ assert np.all([x == MODALITIES[0] for x in MODALITIES]), (dataset_list, MODALITIES)
+ return MODALITIES[0]
+
+ if 'VIDEO' in dataset.lower():
+ return 'VIDEO'
+ elif 'IMAGE' in dataset.lower():
+ return 'IMAGE'
+ warnings.warn(f'Dataset {dataset} is a custom one, will treat modality as {default}. ')
+ return default
+
+
+def build_dataset(dataset_name, **kwargs):
+ for cls in DATASET_CLASSES:
+ if dataset_name in supported_video_datasets:
+ return supported_video_datasets[dataset_name](**kwargs)
+ elif dataset_name in cls.supported_datasets():
+ return cls(dataset=dataset_name, **kwargs)
+
+ warnings.warn(f'Dataset {dataset_name} is not officially supported. ')
+
+ data_file = osp.join(LMUDataRoot(), f'{dataset_name}.tsv')
+ if not osp.exists(data_file):
+ warnings.warn(f'Data file {data_file} does not exist. Dataset building failed. ')
+ return None
+
+ data = load(data_file)
+ if 'question' not in [x.lower() for x in data.columns]:
+ warnings.warn(f'Data file {data_file} does not have a `question` column. Dataset building failed. ')
+ return None
+
+ if 'A' in data and 'B' in data:
+ if 'image' in data or 'image_path' in data:
+ warnings.warn(f'Will assume unsupported dataset {dataset_name} as a Custom MCQ dataset. ')
+ return CustomMCQDataset(dataset=dataset_name, **kwargs)
+ else:
+ warnings.warn(f'Will assume unsupported dataset {dataset_name} as a Custom Text MCQ dataset. ')
+ return CustomTextMCQDataset(dataset=dataset_name, **kwargs)
+ else:
+ warnings.warn(f'Will assume unsupported dataset {dataset_name} as a Custom VQA dataset. ')
+ return CustomVQADataset(dataset=dataset_name, **kwargs)
+
+
+__all__ = [
+ 'build_dataset', 'img_root_map', 'build_judge', 'extract_answer_from_item', 'prefetch_answer', 'DEBUG_MESSAGE'
+] + [cls.__name__ for cls in DATASET_CLASSES]
diff --git a/vlmeval/dataset/cgbench.py b/vlmeval/dataset/cgbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..172cdbb3614a7a279cac73e533c3b72e47fca2f3
--- /dev/null
+++ b/vlmeval/dataset/cgbench.py
@@ -0,0 +1,1760 @@
+from huggingface_hub import snapshot_download
+from ..smp import *
+from .video_base import VideoBaseDataset
+from .utils import build_judge, DEBUG_MESSAGE
+from .utils.cgbench import *
+from ..utils import track_progress_rich
+
+
+class CGBench_MCQ_Grounding_Mini(VideoBaseDataset):
+
+ dataset = "CG-Bench_MCQ_Grounding_Mini"
+
+ TYPE = "Video-MCQ-Grounding"
+
+ MD5 = "54ed3e90a51a6fb375c92b319a715f72"
+
+ SYS = {
+ "long_acc": (
+ "You will be provided with sampled frames from a video, along with a "
+ "multiple-choice question that includes a question and several answer options.\n"
+ "Your task is to analyze the provided frames, infer the most plausible "
+ "answer based on the visual information.\n"
+ "If the video does not provide enough information, infer the answer based "
+ "on the options available and still provide a result. "
+ "Therefore, In all cases, an answer must be given.\n"
+ "Only output the answer in the following format:\n\n"
+ '```json\n{"result": "option"}\n```\n\n'
+ 'The "option" is the uppercase letter corresponding to your answer.\n\n'
+ ),
+ "clue_acc": (
+ "You will be provided with sampled frames from a video, along with a "
+ "multiple-choice question that includes a question and several answer options.\n"
+ "Your task is to analyze the provided frames, infer the most plausible "
+ "answer based on the visual information.\n"
+ "If the video does not provide enough information, infer the answer based "
+ "on the options available and still provide a result. "
+ "Therefore, In all cases, an answer must be given.\n"
+ "Only output the answer in the following format:\n\n"
+ '```json\n{"result": "option"}\n```\n\n'
+ "The 'option' is the uppercase letter corresponding to your answer.\n\n"
+ ),
+ "miou": (
+ "You will be provided with uniformly sampled frames from a video and their "
+ "timestamps, along with a multiple-choice question that includes a question "
+ "and several answer options.\n"
+ "Your task is to determine in which intervals the 'clue intervals' exist "
+ "that contain visual information needed to answer the question.\n"
+ "Only output the answer in the following format:\n\n"
+ '```json\n{"result": [[start1, end1], [start2, end2], ...]}\n```\n\n'
+ "In this output format, each 'start' and 'end' represents the beginning and "
+ "end of an interval in seconds where relevant clues can be found.\n"
+ "You must provide at least one interval and at most five intervals. "
+ "Intervals exceeding five will NOT be considered valid.\n"
+ ),
+ "miou_wo_frame_time": (
+ "You will be provided with uniformly sampled frames from a video, along "
+ "with a multiple-choice question that includes a question and several "
+ "answer options.\n"
+ "Your task is to determine in which intervals the 'clue intervals' exist "
+ "that contain visual information needed to answer the question.\n"
+ "Only output the answer in the following format:\n\n"
+ '```json\n{"result": [[start1, end1], [start2, end2], ...]}\n```\n\n'
+ 'In this output format, each "start" and "end" represents the start and '
+ "end of the video where the relevant clue can be found in the form of a "
+ "floating point number between 0 and 1, where 0 represents the start time "
+ "of the video and 1 represents the end time of the video.\n"
+ "You must provide at least one interval and at most five intervals. "
+ "Intervals exceeding five will NOT be considered valid.\n"
+ ),
+ }
+
+ def __init__(
+ self,
+ dataset="CG-Bench_MCQ_Grounding_Mini",
+ use_subtitle=False,
+ use_subtitle_time=False,
+ use_frame_time=False,
+ nframe=0,
+ fps=-1,
+ ):
+ super().__init__(dataset=dataset, nframe=nframe, fps=fps)
+ self.use_subtitle = use_subtitle
+ self.use_subtitle_time = use_subtitle_time
+ self.use_frame_time = use_frame_time
+ self.dataset_name = dataset
+ lmu_root = LMUDataRoot()
+ self.clue_frame_root = osp.join(lmu_root, "clue_images", dataset)
+
+ @classmethod
+ def supported_datasets(cls):
+ return ["CG-Bench_MCQ_Grounding_Mini"]
+
+ def clue_frame_paths(self, qid, num_frames=8):
+ frame_root = osp.join(self.clue_frame_root, qid)
+ os.makedirs(frame_root, exist_ok=True)
+ return [osp.join(frame_root, self.frame_tmpl.format(i, num_frames)) for i in range(1, num_frames + 1)]
+
+ def clue_frame_paths_fps(self, qid, num_frames=8, fps=-1):
+ frame_root = osp.join(self.clue_frame_root, qid)
+ os.makedirs(frame_root, exist_ok=True)
+ return [osp.join(frame_root, self.frame_tmpl_fps.format(i, num_frames, fps)) for i in range(1, num_frames + 1)]
+
+ def get_subtitles(self, subtitle_path, frame_indices=None, fps=None, sub_time=False):
+
+ subtitles = []
+
+ srt_path = osp.join(self.data_root, subtitle_path)
+ assert osp.exists(srt_path)
+ import pysubs2
+
+ subs = pysubs2.load(srt_path, encoding="utf-8")
+ if not frame_indices:
+ for sub in subs:
+ sub_text = sub.text.replace("\\N", " ")
+ if sub_time:
+ start_time = milliseconds_to_seconds(sub.start)
+ end_time = milliseconds_to_seconds(sub.end)
+ sub_text = f"[{start_time}, {end_time}] {sub_text}"
+ if sub_text.strip() and sub_text not in subtitles:
+ subtitles.append(sub_text)
+ else:
+ for selected_frame_id in frame_indices:
+ cur_time = pysubs2.make_time(fps=fps, frames=selected_frame_id)
+ for sub in subs:
+ if sub.start < cur_time and sub.end > cur_time:
+ sub_text = sub.text.replace("\\N", " ")
+ if sub_time:
+ start_time = milliseconds_to_seconds(sub.start)
+ end_time = milliseconds_to_seconds(sub.end)
+ sub_text = f"[{start_time}, {end_time}] {sub_text}"
+ if sub_text.strip() and sub_text not in subtitles:
+ subtitles.append(sub_text)
+
+ if subtitles:
+ subtitles_str = '\n'.join(subtitles)
+ return f"The subtitles of the video are as follows:\n\n{subtitles_str}\n\n"
+ else:
+ return ""
+
+ def prepare_dataset(self, dataset_name="CG-Bench_MCQ_Grounding_Mini", repo_id="CG-Bench/CG-Bench"):
+
+ def check_integrity(pth):
+ data_file = osp.join(pth, f"{dataset_name}.tsv")
+
+ if not os.path.exists(data_file):
+ return False
+
+ if md5(data_file) != self.MD5:
+ return False
+ data = load(data_file)
+ for video_pth in data["video"]:
+ if not osp.exists(osp.join(pth, video_pth)):
+ return False
+
+ return True
+
+ cache_path = get_cache_path(repo_id)
+
+ if cache_path is not None and check_integrity(cache_path):
+ dataset_path = cache_path
+ else:
+
+ def generate_tsv(pth):
+
+ tsv_file = osp.join(pth, f"{dataset_name}.tsv")
+
+ task_modes = ["long_acc", "clue_acc", "miou"]
+ all_data = []
+ for task_mode in task_modes:
+ with open(osp.join(pth, "cgbench_mini.json"), "r") as f:
+ data_file = pd.DataFrame(json.load(f))
+
+ data_file = data_file.assign(index=range(len(data_file)))
+ data_file["video"] = data_file["video_uid"].apply(lambda x: f"cg_videos_720p/{x}.mp4")
+ data_file["subtitle_path"] = data_file["video_uid"].apply(
+ lambda x: (
+ f"cg_subtitles/{x}.srt"
+ if osp.exists(osp.join(dataset_path, f"cg_subtitles/{x}.srt"))
+ else ""
+ )
+ )
+
+ data_file["clue_video_path"] = ""
+
+ if task_mode in ["clue_acc"]:
+ data_file["clue_video_path"] = data_file["clue_video_path"] = data_file.apply(
+ lambda row: f"cg_clue_videos/{row['qid']}.mp4", axis=1
+ )
+
+ data_file["task_mode"] = task_mode
+
+ if task_mode in ["clue_acc", "long_acc"]:
+ data_file["answer"] = data_file["right_answer"]
+
+ if task_mode == "miou":
+ data_file["answer"] = data_file["clue_intervals"]
+
+ if task_mode in ["long_acc", "miou"]:
+ data_file["clue_intervals"] = ""
+
+ data_file = data_file[
+ [
+ "index",
+ "video_uid",
+ "video",
+ "duration",
+ "domain",
+ "choices",
+ "sub_category",
+ "subtitle_path",
+ "question",
+ "answer",
+ "task_mode",
+ "clue_intervals",
+ "qid",
+ "clue_video_path",
+ ]
+ ]
+
+ all_data.append(data_file)
+
+ final_data = pd.concat(all_data, ignore_index=True)
+ final_data["index"] = range(len(final_data))
+ final_data.to_csv(tsv_file, sep="\t", index=False)
+
+ if modelscope_flag_set():
+ from modelscope import dataset_snapshot_download
+
+ dataset_path = dataset_snapshot_download(dataset_id=repo_id)
+ else:
+ dataset_path = snapshot_download(repo_id=repo_id, repo_type="dataset")
+
+ unzip_hf_zip(dataset_path)
+ generate_tsv(dataset_path)
+
+ tsv_file = osp.join(dataset_path, f"{dataset_name}.tsv")
+
+ return dict(data_file=tsv_file, root=dataset_path)
+
+ def build_prompt(self, line, video_llm):
+
+ if isinstance(line, int):
+ assert line < len(self)
+ line = self.data.iloc[line]
+
+ task_mode = line["task_mode"]
+
+ message = []
+
+ origin_use_subtitle_time = self.use_subtitle_time
+
+ try:
+ if task_mode in ["long_acc", "clue_acc"]:
+ system_prompt = self.SYS[task_mode]
+ elif task_mode == "miou":
+ if self.use_frame_time and not video_llm:
+ system_prompt = self.SYS[task_mode]
+ else:
+ system_prompt = self.SYS["miou_wo_frame_time"]
+ if self.use_subtitle_time is True:
+ self.use_subtitle_time = False
+
+ user_prompt = ""
+
+ if task_mode in ["long_acc", "miou"]:
+ video_path = line["video"]
+
+ if video_llm:
+ message.append(dict(type="video", value=osp.join(self.data_root, video_path)))
+
+ if self.use_subtitle and line["subtitle_path"] and not pd.isna(line["subtitle_path"]):
+ if self.nframe:
+ image_paths, frame_indices, vid_fps = self.save_video_frames(
+ video_path, uid=line["video_uid"], num_frames=self.nframe, fps=self.fps
+ )
+ user_prompt += self.get_subtitles(line["subtitle_path"], frame_indices=frame_indices,
+ fps=vid_fps, sub_time=self.use_subtitle_time)
+ else:
+ user_prompt += self.get_subtitles(line["subtitle_path"], sub_time=self.use_subtitle_time)
+ else:
+ image_paths, frame_indices, vid_fps = self.save_video_frames(
+ video_path, uid=line["video_uid"], num_frames=self.nframe, fps=self.fps
+ )
+ message.extend(dict(type="image", value=im) for im in image_paths)
+
+ if self.use_frame_time:
+ user_prompt += get_timestampes(frame_indices, vid_fps)
+
+ if self.use_subtitle and line["subtitle_path"] and not pd.isna(line["subtitle_path"]):
+ user_prompt += self.get_subtitles(
+ line["subtitle_path"], frame_indices=frame_indices, fps=vid_fps,
+ sub_time=self.use_subtitle_time
+ )
+
+ elif task_mode == "clue_acc":
+ clue_video_path = line["clue_video_path"]
+ video_path = line["video"]
+
+ if video_llm:
+ message.append(dict(type="video", value=osp.join(self.data_root, clue_video_path)))
+ print(message)
+
+ if self.use_subtitle and line["subtitle_path"] and not pd.isna(line["subtitle_path"]):
+ if self.nframe:
+ image_paths, frame_indices, vid_fps = self.save_video_frames(
+ video_path, uid=line["video_uid"], num_frames=self.nframe, fps=self.fps
+ )
+ user_prompt += self.get_subtitles(line["subtitle_path"], frame_indices=frame_indices,
+ fps=vid_fps, sub_time=self.use_subtitle_time)
+ else:
+ user_prompt += self.get_subtitles(line["subtitle_path"], sub_time=self.use_subtitle_time)
+ else:
+ if self.nframe > 32:
+ self.nframe = 32
+ print("The maximum number of frames is 32 when evaluating clue-based mcq in CG-Bench !")
+
+ clue_intervals = eval(line["clue_intervals"])
+
+ image_paths, frame_indices, vid_fps = self.save_video_frames(
+ video_path, uid=line["qid"], clue_intervals=clue_intervals, num_frames=self.nframe, fps=self.fps
+ )
+
+ message.extend(dict(type="image", value=im) for im in image_paths)
+
+ if self.use_frame_time:
+ user_prompt += get_timestampes(frame_indices, vid_fps)
+
+ if self.use_subtitle and line["subtitle_path"] and not pd.isna(line["subtitle_path"]):
+ user_prompt += self.get_subtitles(
+ line["subtitle_path"], frame_indices=frame_indices, fps=vid_fps,
+ sub_time=self.use_subtitle_time
+ )
+
+ question = line["question"]
+ user_prompt += f"Question: {question}\n\n"
+
+ choices = eval(line["choices"])
+ labels = [chr(ord("A") + i) for i in range(len(choices))]
+ user_prompt += "\n".join([f"{label}:{value}" for label, value in zip(labels, choices)]) + "\n\n"
+
+ message.append(dict(type="text", value=system_prompt + user_prompt))
+
+ return message
+
+ finally:
+ # Ensure that `use_subtitle_time` is always restored to its original value
+ self.use_subtitle_time = origin_use_subtitle_time
+
+ def save_video_frames(self, video, uid, clue_intervals=None, num_frames=8, fps=-1):
+
+ if type(uid) is not str:
+ uid = str(uid)
+
+ vid_path = osp.join(self.data_root, video)
+ vid = decord.VideoReader(vid_path)
+ vid_fps = vid.get_avg_fps()
+ n_frames = len(vid)
+
+ if clue_intervals is not None:
+ merged_intervals = merge_intervals(clue_intervals)
+
+ if num_frames > 0 and fps < 0:
+ indices = sample_frames_clue_average(merged_intervals, num_frames, vid_fps)
+ frame_paths = self.clue_frame_paths(uid, len(indices))
+
+ elif fps > 0:
+ frame_indices = []
+ for start, end in merged_intervals:
+ start_frame = int(start * vid_fps)
+ end_frame = int(end * vid_fps)
+ step = vid_fps / fps
+ interval_indices = [
+ int(start_frame + i * step) for i in range(int((end_frame - start_frame) / step))
+ ]
+ frame_indices.extend(interval_indices)
+
+ if len(frame_indices) < 32:
+ indices = sample_frames_clue_average(merged_intervals, 32, vid_fps)
+ else:
+ indices = frame_indices
+ frame_paths = self.clue_frame_paths_fps(uid, len(indices), fps)
+
+ else:
+ if num_frames > 0 and fps < 0:
+ step_size = len(vid) / (num_frames + 1)
+ indices = [int(i * step_size) for i in range(1, num_frames + 1)]
+
+ frame_paths = self.frame_paths(uid)
+ elif fps > 0:
+ total_duration = n_frames / vid_fps
+ required_frames = int(total_duration * fps)
+ step_size = vid_fps / fps
+ indices = [int(i * step_size) for i in range(required_frames)]
+ frame_paths = self.frame_paths_fps(uid, len(indices))
+
+ # Save and validate frames
+ valid_paths = []
+ valid_indices = []
+
+ if not np.all([osp.exists(p) for p in frame_paths]):
+ images = [vid[i].asnumpy() for i in indices]
+ for i, (img_array, path) in enumerate(zip(images, frame_paths)):
+ if osp.exists(path):
+ try:
+ with Image.open(path) as img:
+ img.verify()
+ valid_paths.append(path)
+ valid_indices.append(indices[i])
+ except Exception:
+ continue
+ else:
+ try:
+ img = Image.fromarray(img_array)
+ img.save(path)
+ img.verify()
+ valid_paths.append(path)
+ valid_indices.append(indices[i])
+ except Exception:
+ continue
+ else:
+ for i, path in enumerate(frame_paths):
+ try:
+ with Image.open(path) as img:
+ img.verify()
+ valid_paths.append(path)
+ valid_indices.append(indices[i])
+ except Exception:
+ continue
+
+ return valid_paths, valid_indices, vid_fps
+
+ def evaluate(self, eval_file, **judge_kwargs):
+
+ assert eval_file.endswith(".xlsx"), "data file should be an xlsx file"
+
+ tgt_file = eval_file.replace(".xlsx", "_rating.json")
+ score_file = eval_file.replace(".xlsx", "_score.xlsx")
+
+ data = load(eval_file)
+
+ data_un = data[~pd.isna(data["prediction"])]
+ data_pred_na = data[pd.isna(data["prediction"])]
+
+ data_pred_na["score"] = -1
+
+ data_un["score"] = data_un.apply(
+ lambda row: post_process(
+ response=row["prediction"],
+ right_answer=row["answer"],
+ task_mode=row["task_mode"],
+ duration=row["duration"],
+ ),
+ axis=1,
+ )
+
+ data = pd.concat([data_pred_na, data_un])
+
+ rejected_count = (data["score"] == -1).sum()
+
+ print(
+ f"Among {len(data)} questions, "
+ f"failed to obtain prediction for {len(data_pred_na)} questions, "
+ f"failed to obtain the score for {rejected_count - len(data_pred_na)} questions. "
+ f"Those questions will be counted as -1 score in ALL rating, and will not be counted in VALID rating."
+ )
+
+ dump(data, score_file)
+
+ rating = get_dimention_rating_mcq_grouding(score_file)
+
+ dump(rating, tgt_file)
+
+ return rating
+
+
+# 评估时，step_2 评估时，给出 [prompt] + image_paths 就行
+class CGBench_OpenEnded_Mini(VideoBaseDataset):
+
+ TYPE = "Video-OpenEnded"
+
+ dataset = "CG-Bench_OpenEnded_Mini"
+
+ MD5 = "9175791b11afdfa305fdb3e525b7a4ee"
+
+ SYS = (
+ "You will be provided with sampled frames from a video, along with a "
+ "question.\n"
+ "Your task is to analyze the provided frames and infer the most plausible "
+ "answer based on the visual information.\n"
+ "If the visual information is ambiguous or insufficient, use the available "
+ "context to reason your answer.\n"
+ "Only output the answer in the following format:\n\n"
+ '```json\n{"result": "answer"}\n```\n\n'
+ 'The "answer" can be a word, phrase, or sentence that directly responds to '
+ "the question.\n\n"
+ )
+
+ def __init__(
+ self,
+ dataset="CG-Bench_OpenEnded_Mini",
+ use_subtitle=False,
+ use_subtitle_time=False,
+ use_frame_time=False,
+ nframe=0,
+ fps=-1,
+ ):
+ super().__init__(dataset=dataset, nframe=nframe, fps=fps)
+ self.use_subtitle = use_subtitle
+ self.use_subtitle_time = use_subtitle_time
+ self.use_frame_time = use_frame_time
+ self.dataset_name = dataset
+ lmu_root = LMUDataRoot()
+ self.clue_frame_root = osp.join(lmu_root, "clue_images", dataset)
+
+ @classmethod
+ def supported_datasets(cls):
+ return ["CG-Bench_OpenEnded_Mini"]
+
+ def get_subtitles(self, subtitle_path, frame_indices=None, fps=None, sub_time=False):
+
+ subtitles = []
+
+ srt_path = osp.join(self.data_root, subtitle_path)
+ assert osp.exists(srt_path)
+ import pysubs2
+
+ subs = pysubs2.load(srt_path, encoding="utf-8")
+ if not frame_indices:
+ for sub in subs:
+ sub_text = sub.text.replace("\\N", " ")
+ if sub_time:
+ start_time = milliseconds_to_seconds(sub.start)
+ end_time = milliseconds_to_seconds(sub.end)
+ sub_text = f"[{start_time}, {end_time}] {sub_text}"
+ if sub_text.strip() and sub_text not in subtitles:
+ subtitles.append(sub_text)
+ else:
+ for selected_frame_id in frame_indices:
+ cur_time = pysubs2.make_time(fps=fps, frames=selected_frame_id)
+ for sub in subs:
+ if sub.start < cur_time and sub.end > cur_time:
+ sub_text = sub.text.replace("\\N", " ")
+ if sub_time:
+ start_time = milliseconds_to_seconds(sub.start)
+ end_time = milliseconds_to_seconds(sub.end)
+ sub_text = f"[{start_time}, {end_time}] {sub_text}"
+ if sub_text.strip() and sub_text not in subtitles:
+ subtitles.append(sub_text)
+
+ if subtitles:
+ subtitles_str = '\n'.join(subtitles)
+ return f"The subtitles of the video are as follows:\n\n{subtitles_str}\n\n"
+ else:
+ return ""
+
+ def prepare_dataset(self, dataset_name="CG-Bench_OpenEnded_Mini", repo_id="CG-Bench/CG-Bench"):
+
+ def check_integrity(pth):
+ data_file = osp.join(pth, f"{dataset_name}.tsv")
+
+ if not os.path.exists(data_file):
+ return False
+
+ if md5(data_file) != self.MD5:
+ return False
+ data = load(data_file)
+ for video_pth in data["video"]:
+ if not osp.exists(osp.join(pth, video_pth)):
+ return False
+
+ return True
+
+ cache_path = get_cache_path(repo_id)
+
+ if cache_path is not None and check_integrity(cache_path):
+ dataset_path = cache_path
+ else:
+
+ def generate_tsv(pth):
+
+ tsv_file = osp.join(pth, f"{dataset_name}.tsv")
+
+ with open(osp.join(pth, "cgbench_mini.json"), "r") as f:
+ data_file = pd.DataFrame(json.load(f))
+
+ data_file = data_file.assign(index=range(len(data_file)))
+ data_file["video"] = data_file["video_uid"].apply(lambda x: f"cg_videos_720p/{x}.mp4")
+ data_file["subtitle_path"] = data_file["video_uid"].apply(
+ lambda x: f"cg_subtitles/{x}.srt" if osp.exists(osp.join(pth, f"cg_subtitles/{x}.srt")) else ""
+ )
+
+ data_file = data_file[
+ [
+ "index",
+ "video_uid",
+ "video",
+ "duration",
+ "domain",
+ "sub_category",
+ "subtitle_path",
+ "question",
+ "answer",
+ "clue_intervals",
+ "qid",
+ ]
+ ]
+
+ data_file.to_csv(tsv_file, sep="\t", index=False)
+
+ if modelscope_flag_set():
+ from modelscope import dataset_snapshot_download
+
+ dataset_path = dataset_snapshot_download(dataset_id=repo_id)
+ else:
+ dataset_path = snapshot_download(repo_id=repo_id, repo_type="dataset")
+
+ unzip_hf_zip(dataset_path)
+ generate_tsv(dataset_path)
+
+ tsv_file = osp.join(dataset_path, f"{dataset_name}.tsv")
+
+ return dict(data_file=tsv_file, root=dataset_path)
+
+ def build_prompt(self, line, video_llm):
+
+ if isinstance(line, int):
+ assert line < len(self)
+ line = self.data.iloc[line]
+
+ message = []
+
+ sys_prompt = self.SYS
+
+ user_prompt = ""
+
+ video_path = line["video"]
+
+ if video_llm:
+ message.append(dict(type="video", value=osp.join(self.data_root, video_path)))
+ if self.use_subtitle and line["subtitle_path"] and not pd.isna(line["subtitle_path"]):
+ if self.nframe:
+ image_paths, frame_indices, vid_fps = self.save_video_frames(
+ video_path, uid=line["video_uid"], num_frames=self.nframe, fps=self.fps
+ )
+ user_prompt += self.get_subtitles(line["subtitle_path"], frame_indices=frame_indices,
+ fps=vid_fps, sub_time=self.use_subtitle_time)
+ else:
+ user_prompt += self.get_subtitles(line["subtitle_path"], sub_time=self.use_subtitle_time)
+ else:
+ image_paths, frame_indices, vid_fps = self.save_video_frames(
+ video_path, uid=line["video_uid"], num_frames=self.nframe, fps=self.fps
+ )
+ message.extend(dict(type="image", value=im) for im in image_paths)
+
+ if self.use_frame_time:
+ user_prompt += get_timestampes(frame_indices, vid_fps)
+
+ if self.use_subtitle and line["subtitle_path"] and not pd.isna(line["subtitle_path"]):
+ user_prompt += self.get_subtitles(
+ line["subtitle_path"], frame_indices=frame_indices, fps=vid_fps,
+ sub_time=self.use_subtitle_time
+ )
+
+ question = line["question"]
+ user_prompt += f"Question: {question}\n\n"
+
+ message.append(dict(type="text", value=sys_prompt + user_prompt))
+
+ return message
+
+ def clue_frame_paths(self, qid, num_frames=8):
+ frame_root = osp.join(self.clue_frame_root, qid)
+ os.makedirs(frame_root, exist_ok=True)
+ return [osp.join(frame_root, self.frame_tmpl.format(i, num_frames)) for i in range(1, num_frames + 1)]
+
+ def save_video_frames(self, video, uid, clue_intervals=None, num_frames=8, fps=-1):
+
+ if type(uid) is not str:
+ uid = str(uid)
+
+ vid_path = osp.join(self.data_root, video)
+ vid = decord.VideoReader(vid_path)
+ vid_fps = vid.get_avg_fps()
+ n_frames = len(vid)
+
+ if clue_intervals is not None:
+ merged_intervals = merge_intervals(clue_intervals)
+
+ if num_frames > 0 and fps < 0:
+ indices = sample_frames_clue_average(merged_intervals, num_frames, vid_fps)
+ frame_paths = self.clue_frame_paths(uid, len(indices))
+
+ elif fps > 0:
+ frame_indices = []
+ for start, end in merged_intervals:
+ start_frame = int(start * vid_fps)
+ end_frame = int(end * vid_fps)
+ step = vid_fps / fps
+ interval_indices = [
+ int(start_frame + i * step) for i in range(int((end_frame - start_frame) / step))
+ ]
+ frame_indices.extend(interval_indices)
+
+ if len(frame_indices) < 32:
+ indices = sample_frames_clue_average(merged_intervals, 32, vid_fps)
+ else:
+ indices = frame_indices
+ frame_paths = self.clue_frame_paths_fps(uid, len(indices), fps)
+
+ else:
+ if num_frames > 0 and fps < 0:
+ step_size = len(vid) / (num_frames + 1)
+ indices = [int(i * step_size) for i in range(1, num_frames + 1)]
+ frame_paths = self.frame_paths(uid)
+ elif fps > 0:
+ total_duration = n_frames / vid_fps
+ required_frames = int(total_duration * fps)
+ step_size = vid_fps / fps
+ indices = [int(i * step_size) for i in range(required_frames)]
+ frame_paths = self.frame_paths_fps(uid, len(indices))
+
+ valid_paths = []
+ valid_indices = []
+
+ if not np.all([osp.exists(p) for p in frame_paths]):
+ images = [vid[i].asnumpy() for i in indices]
+ for i, (img_array, path) in enumerate(zip(images, frame_paths)):
+ if osp.exists(path):
+ try:
+ with Image.open(path) as img:
+ img.verify()
+ valid_paths.append(path)
+ valid_indices.append(indices[i])
+ except Exception:
+ continue
+ else:
+ try:
+ img = Image.fromarray(img_array)
+ img.save(path)
+ img.verify()
+ valid_paths.append(path)
+ valid_indices.append(indices[i])
+ except Exception:
+ continue
+ else:
+ for i, path in enumerate(frame_paths):
+ try:
+ with Image.open(path) as img:
+ img.verify()
+ valid_paths.append(path)
+ valid_indices.append(indices[i])
+ except Exception:
+ continue
+
+ return valid_paths, valid_indices, vid_fps
+
+ def evaluate(self, eval_file, **judge_kwargs):
+
+ from .utils.cgbench import get_dimention_rating_open_ended, post_process_open
+
+ assert eval_file.endswith(".xlsx"), "data file should be an xlsx file"
+
+ tgt_file = eval_file.replace(".xlsx", "_rating.json")
+ score_file = eval_file.replace(".xlsx", "_score.xlsx")
+ step_1_tmp_file = eval_file.replace(".xlsx", "_step_1.pkl")
+ step_2_tmp_file = eval_file.replace(".xlsx", "_step_2.pkl")
+
+ data = load(eval_file)
+
+ data_pred_no_na = data[~pd.isna(data["prediction"])]
+ data_pred_na = data[pd.isna(data["prediction"])]
+
+ data_pred_na["model_result"] = -1
+ data_pred_na["step_1_result"] = -1
+ data_pred_na["step_2_result"] = -1
+ data_pred_na["score"] = -1
+
+ data_pred_no_na["model_result"] = data_pred_no_na.apply(
+ lambda row: post_process_open(
+ response=row["prediction"],
+ ),
+ axis=1,
+ )
+
+ data_no_model_result = data_pred_no_na[data_pred_no_na["model_result"] == -1]
+ data_step_1 = data_pred_no_na[data_pred_no_na["model_result"] != -1]
+
+ if judge_kwargs.get("model", None) != "gpt-4o-0806":
+ judge_kwargs["model"] = "gpt-4o-0806"
+ print("The judge model in cg-bench is gpt-4o-0806!")
+
+ model_step_1 = build_judge(system_prompt=sys_prompt_open_eval_step_1, **judge_kwargs)
+ nproc = judge_kwargs.pop("nproc", 32)
+
+ lines_step_1 = data_step_1.to_dict("records")
+ tups_step_1 = [(model_step_1, line) for line in lines_step_1]
+
+ keys_step_1 = {line["qid"] for line in lines_step_1}
+
+ ans = {}
+ if osp.exists(step_1_tmp_file):
+ ans = load(step_1_tmp_file)
+ tups_step_1 = [x for x, i in zip(tups_step_1, keys_step_1) if i not in ans]
+ keys_step_1 = [i for i in keys_step_1 if i not in ans]
+
+ _ = track_progress_rich(
+ eval_open_first,
+ tups_step_1,
+ nproc=nproc,
+ keys=keys_step_1,
+ save=step_1_tmp_file,
+ )
+
+ step_1_results = load(step_1_tmp_file)
+ data_step_1 = save_step_1_steps(data_step_1, step_1_results) # -1, 0, 1, 2
+
+ data_no_step_1_results = data_step_1[data_step_1["step_1_result"] == -1]
+ data_step_1_over = data_step_1[data_step_1["step_1_result"].isin([0, 1])]
+ data_step_2 = data_step_1[data_step_1["step_1_result"] == 2]
+
+ print(judge_kwargs)
+
+ model_step_2 = build_judge(system_prompt=sys_prompt_open_eval_step_2, **judge_kwargs)
+
+ lines_step_2 = data_step_2.to_dict("records")
+
+ tups_step_2 = []
+
+ for line in tqdm(lines_step_2):
+ clue_intervals = eval(line["clue_intervals"])
+ lmu_root = LMUDataRoot()
+ clue_frame_root = osp.join(lmu_root, "clue_images", self.dataset)
+ data_root = self.data_root
+ frame_paths, _, _ = save_clue_video_frames(
+ data_root,
+ clue_frame_root,
+ video=line["video"],
+ uid=line["qid"],
+ clue_intervals=clue_intervals,
+ num_frames=32,
+ )
+ tups_step_2.append((model_step_2, line, frame_paths))
+
+ keys_step_2 = {line["qid"] for line in lines_step_2}
+
+ ans = {}
+ if osp.exists(step_2_tmp_file):
+ ans = load(step_2_tmp_file)
+ tups_step_2 = [x for x, i in zip(tups_step_2, keys_step_2) if i not in ans]
+ keys_step_2 = [i for i in keys_step_2 if i not in ans]
+
+ _ = track_progress_rich(
+ eval_open_second,
+ tups_step_2,
+ nproc=nproc,
+ keys=keys_step_2,
+ save=step_2_tmp_file,
+ )
+
+ step_2_results = load(step_2_tmp_file)
+ data_step_2 = save_step_2_steps(data_step_2, step_2_results)
+
+ data_no_step_2_results = data_step_2[data_step_2["score"] == -1]
+ data_step_2_over = data_step_2[data_step_2["score"].isin([0, 1])]
+
+ data = pd.concat(
+ [
+ data_pred_na,
+ data_no_model_result,
+ data_no_step_1_results,
+ data_step_1_over,
+ data_no_step_2_results,
+ data_step_2_over,
+ ]
+ )
+
+ dump(data, score_file)
+
+ rating = get_dimention_rating_open_ended(score_file)
+
+ dump(rating, tgt_file)
+
+ return rating
+
+
+class CGBench_MCQ_Grounding(VideoBaseDataset):
+
+ TYPE = "Video-MCQ-Grounding"
+
+ MD5 = "eaead3d978a689269fefce4ae29c86df"
+
+ SYS = {
+ "long_acc": (
+ "You will be provided with sampled frames from a video, along with a "
+ "multiple-choice question that includes a question and several answer options.\n"
+ "Your task is to analyze the provided frames, infer the most plausible "
+ "answer based on the visual information.\n"
+ "If the video does not provide enough information, infer the answer based "
+ "on the options available and still provide a result. "
+ "Therefore, In all cases, an answer must be given.\n"
+ "Only output the answer in the following format:\n\n"
+ '```json\n{"result": "option"}\n```\n\n'
+ 'The "option" is the uppercase letter corresponding to your answer.\n\n'
+ ),
+ "clue_acc": (
+ "You will be provided with sampled frames from a video, along with a "
+ "multiple-choice question that includes a question and several answer options.\n"
+ "Your task is to analyze the provided frames, infer the most plausible "
+ "answer based on the visual information.\n"
+ "If the video does not provide enough information, infer the answer based "
+ "on the options available and still provide a result. "
+ "Therefore, In all cases, an answer must be given.\n"
+ "Only output the answer in the following format:\n\n"
+ '```json\n{"result": "option"}\n```\n\n'
+ "The 'option' is the uppercase letter corresponding to your answer.\n\n"
+ ),
+ "miou": (
+ "You will be provided with uniformly sampled frames from a video and their "
+ "timestamps, along with a multiple-choice question that includes a question "
+ "and several answer options.\n"
+ "Your task is to determine in which intervals the 'clue intervals' exist "
+ "that contain visual information needed to answer the question.\n"
+ "Only output the answer in the following format:\n\n"
+ '```json\n{"result": [[start1, end1], [start2, end2], ...]}\n```\n\n'
+ "In this output format, each 'start' and 'end' represents the beginning and "
+ "end of an interval in seconds where relevant clues can be found.\n"
+ "You must provide at least one interval and at most five intervals. "
+ "Intervals exceeding five will NOT be considered valid.\n"
+ ),
+ "miou_wo_frame_time": (
+ "You will be provided with uniformly sampled frames from a video, along "
+ "with a multiple-choice question that includes a question and several "
+ "answer options.\n"
+ "Your task is to determine in which intervals the 'clue intervals' exist "
+ "that contain visual information needed to answer the question.\n"
+ "Only output the answer in the following format:\n\n"
+ '```json\n{"result": [[start1, end1], [start2, end2], ...]}\n```\n\n'
+ 'In this output format, each "start" and "end" represents the start and '
+ "end of the video where the relevant clue can be found in the form of a "
+ "floating point number between 0 and 1, where 0 represents the start time "
+ "of the video and 1 represents the end time of the video.\n"
+ "You must provide at least one interval and at most five intervals. "
+ "Intervals exceeding five will NOT be considered valid.\n"
+ ),
+ }
+
+ def __init__(
+ self,
+ dataset="CG-Bench_MCQ_Grounding",
+ use_subtitle=False,
+ use_subtitle_time=False,
+ use_frame_time=False,
+ nframe=0,
+ fps=-1,
+ ):
+ super().__init__(dataset=dataset, nframe=nframe, fps=fps)
+ self.use_subtitle = use_subtitle
+ self.use_subtitle_time = use_subtitle_time
+ self.use_frame_time = use_frame_time
+ self.dataset_name = dataset
+ lmu_root = LMUDataRoot()
+ self.clue_frame_root = osp.join(lmu_root, "clue_images", dataset)
+
+ @classmethod
+ def supported_datasets(cls):
+ return ["CG-Bench_MCQ_Grounding"]
+
+ def clue_frame_paths(self, qid, num_frames=8):
+ frame_root = osp.join(self.clue_frame_root, qid)
+ os.makedirs(frame_root, exist_ok=True)
+ return [osp.join(frame_root, self.frame_tmpl.format(i, num_frames)) for i in range(1, num_frames + 1)]
+
+ def clue_frame_paths_fps(self, qid, num_frames=8, fps=-1):
+ frame_root = osp.join(self.clue_frame_root, qid)
+ os.makedirs(frame_root, exist_ok=True)
+ return [osp.join(frame_root, self.frame_tmpl_fps.format(i, num_frames, fps)) for i in range(1, num_frames + 1)]
+
+ def get_subtitles(self, subtitle_path, frame_indices=None, fps=None, sub_time=False):
+
+ subtitles = []
+
+ srt_path = osp.join(self.data_root, subtitle_path)
+ assert osp.exists(srt_path)
+ import pysubs2
+
+ subs = pysubs2.load(srt_path, encoding="utf-8")
+ if not frame_indices:
+ for sub in subs:
+ sub_text = sub.text.replace("\\N", " ")
+ if sub_time:
+ start_time = milliseconds_to_seconds(sub.start)
+ end_time = milliseconds_to_seconds(sub.end)
+ sub_text = f"[{start_time}, {end_time}] {sub_text}"
+ if sub_text.strip() and sub_text not in subtitles:
+ subtitles.append(sub_text)
+ else:
+ for selected_frame_id in frame_indices:
+ cur_time = pysubs2.make_time(fps=fps, frames=selected_frame_id)
+ for sub in subs:
+ if sub.start < cur_time and sub.end > cur_time:
+ sub_text = sub.text.replace("\\N", " ")
+ if sub_time:
+ start_time = milliseconds_to_seconds(sub.start)
+ end_time = milliseconds_to_seconds(sub.end)
+ sub_text = f"[{start_time}, {end_time}] {sub_text}"
+ if sub_text.strip() and sub_text not in subtitles:
+ subtitles.append(sub_text)
+
+ if subtitles:
+ subtitles_str = '\n'.join(subtitles)
+ return f"The subtitles of the video are as follows:\n\n{subtitles_str}\n\n"
+ else:
+ return ""
+
+ def prepare_dataset(self, dataset_name="CG-Bench_MCQ_Grounding", repo_id="CG-Bench/CG-Bench"):
+
+ def check_integrity(pth):
+ data_file = osp.join(pth, f"{dataset_name}.tsv")
+
+ if not os.path.exists(data_file):
+ return False
+
+ if md5(data_file) != self.MD5:
+ return False
+ data = load(data_file)
+ for video_pth in data["video"]:
+ if not osp.exists(osp.join(pth, video_pth)):
+ return False
+
+ for clue_video_pth in data["clue_video_path"]:
+ if clue_video_pth and not (isinstance(clue_video_pth, float) and np.isnan(clue_video_pth)):
+ if not osp.exists(osp.join(pth, clue_video_pth)):
+ return False
+
+ return True
+
+ cache_path = get_cache_path(repo_id)
+
+ if cache_path is not None and check_integrity(cache_path):
+ dataset_path = cache_path
+ else:
+
+ def generate_tsv(pth):
+
+ tsv_file = osp.join(pth, f"{dataset_name}.tsv")
+
+ task_modes = ["long_acc", "clue_acc", "miou"]
+ all_data = []
+ for task_mode in task_modes:
+ with open(osp.join(pth, "cgbench.json"), "r") as f:
+ data_file = pd.DataFrame(json.load(f))
+
+ data_file = data_file.assign(index=range(len(data_file)))
+ data_file["video"] = data_file["video_uid"].apply(lambda x: f"cg_videos_720p/{x}.mp4")
+ data_file["subtitle_path"] = data_file["video_uid"].apply(
+ lambda x: (
+ f"cg_subtitles/{x}.srt"
+ if osp.exists(osp.join(dataset_path, f"cg_subtitles/{x}.srt"))
+ else ""
+ )
+ )
+
+ data_file["clue_video_path"] = ""
+
+ if task_mode in ["clue_acc"]:
+ data_file["clue_video_path"] = data_file["clue_video_path"] = data_file.apply(
+ lambda row: f"cg_clue_videos/{row['qid']}.mp4", axis=1
+ )
+
+ data_file["task_mode"] = task_mode
+
+ if task_mode in ["clue_acc", "long_acc"]:
+ data_file["answer"] = data_file["right_answer"]
+
+ if task_mode == "miou":
+ data_file["answer"] = data_file["clue_intervals"]
+
+ if task_mode in ["long_acc", "miou"]:
+ data_file["clue_intervals"] = ""
+
+ data_file = data_file[
+ [
+ "index",
+ "video_uid",
+ "video",
+ "duration",
+ "domain",
+ "choices",
+ "sub_category",
+ "subtitle_path",
+ "question",
+ "answer",
+ "task_mode",
+ "clue_intervals",
+ "qid",
+ "clue_video_path",
+ ]
+ ]
+
+ all_data.append(data_file)
+
+ final_data = pd.concat(all_data, ignore_index=True)
+ final_data["index"] = range(len(final_data))
+ final_data.to_csv(tsv_file, sep="\t", index=False)
+
+ if modelscope_flag_set():
+ from modelscope import dataset_snapshot_download
+
+ dataset_path = dataset_snapshot_download(dataset_id=repo_id)
+ else:
+ dataset_path = snapshot_download(repo_id=repo_id, repo_type="dataset")
+
+ unzip_hf_zip(dataset_path)
+ generate_tsv(dataset_path)
+
+ tsv_file = osp.join(dataset_path, f"{dataset_name}.tsv")
+
+ return dict(data_file=tsv_file, root=dataset_path)
+
+ def build_prompt(self, line, video_llm):
+
+ if isinstance(line, int):
+ assert line < len(self)
+ line = self.data.iloc[line]
+
+ task_mode = line["task_mode"]
+
+ message = []
+
+ origin_use_subtitle_time = self.use_subtitle_time
+
+ try:
+ if task_mode in ["long_acc", "clue_acc"]:
+ system_prompt = self.SYS[task_mode]
+ elif task_mode == "miou":
+ if self.use_frame_time and not video_llm:
+ system_prompt = self.SYS[task_mode]
+ else:
+ system_prompt = self.SYS["miou_wo_frame_time"]
+ if self.use_subtitle_time is True:
+ self.use_subtitle_time = False
+
+ user_prompt = ""
+
+ if task_mode in ["long_acc", "miou"]:
+ video_path = line["video"]
+
+ if video_llm:
+ message.append(dict(type="video", value=osp.join(self.data_root, video_path)))
+
+ if self.use_subtitle and line["subtitle_path"] and not pd.isna(line["subtitle_path"]):
+ if self.nframe:
+ image_paths, frame_indices, vid_fps = self.save_video_frames(
+ video_path, uid=line["video_uid"], num_frames=self.nframe, fps=self.fps
+ )
+ user_prompt += self.get_subtitles(line["subtitle_path"], frame_indices=frame_indices,
+ fps=vid_fps, sub_time=self.use_subtitle_time)
+ else:
+ user_prompt += self.get_subtitles(line["subtitle_path"], sub_time=self.use_subtitle_time)
+ else:
+ image_paths, frame_indices, vid_fps = self.save_video_frames(
+ video_path, uid=line["video_uid"], num_frames=self.nframe, fps=self.fps
+ )
+ message.extend(dict(type="image", value=im) for im in image_paths)
+
+ if self.use_frame_time:
+ user_prompt += get_timestampes(frame_indices, vid_fps)
+
+ if self.use_subtitle and line["subtitle_path"] and not pd.isna(line["subtitle_path"]):
+ user_prompt += self.get_subtitles(
+ line["subtitle_path"], frame_indices=frame_indices, fps=vid_fps,
+ sub_time=self.use_subtitle_time
+ )
+
+ elif task_mode == "clue_acc":
+ clue_video_path = line["clue_video_path"]
+ video_path = line["video"]
+
+ if video_llm:
+ message.append(dict(type="video", value=osp.join(self.data_root, clue_video_path)))
+ print(message)
+
+ if self.use_subtitle and line["subtitle_path"] and not pd.isna(line["subtitle_path"]):
+ if self.nframe:
+ image_paths, frame_indices, vid_fps = self.save_video_frames(
+ video_path, uid=line["video_uid"], num_frames=self.nframe, fps=self.fps
+ )
+ user_prompt += self.get_subtitles(line["subtitle_path"], frame_indices=frame_indices,
+ fps=vid_fps, sub_time=self.use_subtitle_time)
+ else:
+ user_prompt += self.get_subtitles(line["subtitle_path"], sub_time=self.use_subtitle_time)
+ else:
+ if self.nframe > 32:
+ self.nframe = 32
+ print("The maximum number of frames is 32 when evaluating clue-based mcq in CG-Bench !")
+
+ clue_intervals = eval(line["clue_intervals"])
+
+ image_paths, frame_indices, vid_fps = self.save_video_frames(
+ video_path, uid=line["qid"], clue_intervals=clue_intervals, num_frames=self.nframe, fps=self.fps
+ )
+
+ message.extend(dict(type="image", value=im) for im in image_paths)
+
+ if self.use_frame_time:
+ user_prompt += get_timestampes(frame_indices, vid_fps)
+
+ if self.use_subtitle and line["subtitle_path"] and not pd.isna(line["subtitle_path"]):
+ user_prompt += self.get_subtitles(
+ line["subtitle_path"], frame_indices=frame_indices, fps=vid_fps,
+ sub_time=self.use_subtitle_time
+ )
+
+ question = line["question"]
+ user_prompt += f"Question: {question}\n\n"
+
+ choices = eval(line["choices"])
+ labels = [chr(ord("A") + i) for i in range(len(choices))]
+ user_prompt += "\n".join([f"{label}:{value}" for label, value in zip(labels, choices)]) + "\n\n"
+
+ message.append(dict(type="text", value=system_prompt + user_prompt))
+
+ return message
+
+ finally:
+ # Ensure that `use_subtitle_time` is always restored to its original value
+ self.use_subtitle_time = origin_use_subtitle_time
+
+ def save_video_frames(self, video, uid, clue_intervals=None, num_frames=8, fps=-1):
+
+ if type(uid) is not str:
+ uid = str(uid)
+
+ vid_path = osp.join(self.data_root, video)
+ vid = decord.VideoReader(vid_path)
+ vid_fps = vid.get_avg_fps()
+ n_frames = len(vid)
+
+ if clue_intervals is not None:
+ merged_intervals = merge_intervals(clue_intervals)
+
+ if num_frames > 0 and fps < 0:
+ indices = sample_frames_clue_average(merged_intervals, num_frames, vid_fps)
+ frame_paths = self.clue_frame_paths(uid, len(indices))
+
+ elif fps > 0:
+ frame_indices = []
+ for start, end in merged_intervals:
+ start_frame = int(start * vid_fps)
+ end_frame = int(end * vid_fps)
+ step = vid_fps / fps
+ interval_indices = [
+ int(start_frame + i * step) for i in range(int((end_frame - start_frame) / step))
+ ]
+ frame_indices.extend(interval_indices)
+
+ if len(frame_indices) < 32:
+ indices = sample_frames_clue_average(merged_intervals, 32, vid_fps)
+ else:
+ indices = frame_indices
+ frame_paths = self.clue_frame_paths_fps(uid, len(indices), fps)
+
+ else:
+ if num_frames > 0 and fps < 0:
+ step_size = len(vid) / (num_frames + 1)
+ indices = [int(i * step_size) for i in range(1, num_frames + 1)]
+
+ frame_paths = self.frame_paths(uid)
+ elif fps > 0:
+ total_duration = n_frames / vid_fps
+ required_frames = int(total_duration * fps)
+ step_size = vid_fps / fps
+ indices = [int(i * step_size) for i in range(required_frames)]
+ frame_paths = self.frame_paths_fps(uid, len(indices))
+
+ # Save and validate frames
+ valid_paths = []
+ valid_indices = []
+
+ if not np.all([osp.exists(p) for p in frame_paths]):
+ images = [vid[i].asnumpy() for i in indices]
+ for i, (img_array, path) in enumerate(zip(images, frame_paths)):
+ if osp.exists(path):
+ try:
+ with Image.open(path) as img:
+ img.verify()
+ valid_paths.append(path)
+ valid_indices.append(indices[i])
+ except Exception:
+ continue
+ else:
+ try:
+ img = Image.fromarray(img_array)
+ img.save(path)
+ img.verify()
+ valid_paths.append(path)
+ valid_indices.append(indices[i])
+ except Exception:
+ continue
+ else:
+ for i, path in enumerate(frame_paths):
+ try:
+ with Image.open(path) as img:
+ img.verify()
+ valid_paths.append(path)
+ valid_indices.append(indices[i])
+ except Exception:
+ continue
+
+ return valid_paths, valid_indices, vid_fps
+
+ def evaluate(self, eval_file, **judge_kwargs):
+
+ assert eval_file.endswith(".xlsx"), "data file should be an xlsx file"
+
+ tgt_file = eval_file.replace(".xlsx", "_rating.json")
+ score_file = eval_file.replace(".xlsx", "_score.xlsx")
+
+ data = load(eval_file)
+
+ data_un = data[~pd.isna(data["prediction"])]
+ data_pred_na = data[pd.isna(data["prediction"])]
+
+ data_pred_na["score"] = -1
+
+ data_un["score"] = data_un.apply(
+ lambda row: post_process(
+ response=row["prediction"],
+ right_answer=row["answer"],
+ task_mode=row["task_mode"],
+ duration=row["duration"],
+ ),
+ axis=1,
+ )
+
+ data = pd.concat([data_pred_na, data_un])
+
+ rejected_count = (data["score"] == -1).sum()
+
+ print(
+ f"Among {len(data)} questions, "
+ f"failed to obtain prediction for {len(data_pred_na)} questions, "
+ f"failed to obtain the score for {rejected_count - len(data_pred_na)} questions. "
+ f"Those questions will be counted as -1 score in ALL rating, and will not be counted in VALID rating."
+ )
+
+ dump(data, score_file)
+
+ rating = get_dimention_rating_mcq_grouding(score_file)
+
+ dump(rating, tgt_file)
+
+ return rating
+
+
+# 评估时，step_2 评估时，给出 [prompt] + image_paths 就行
+class CGBench_OpenEnded(VideoBaseDataset):
+
+ TYPE = "Video-OpenEnded"
+
+ dataset = "CG-Bench_OpenEnded"
+
+ MD5 = "796035eda0b1e916c517cdc1bc145cfc"
+
+ SYS = (
+ "You will be provided with sampled frames from a video, along with a "
+ "question.\n"
+ "Your task is to analyze the provided frames and infer the most plausible "
+ "answer based on the visual information.\n"
+ "If the visual information is ambiguous or insufficient, use the available "
+ "context to reason your answer.\n"
+ "Only output the answer in the following format:\n\n"
+ '```json\n{"result": "answer"}\n```\n\n'
+ 'The "answer" can be a word, phrase, or sentence that directly responds to '
+ "the question.\n\n"
+ )
+
+ def __init__(
+ self,
+ dataset="CG-Bench_OpenEnded",
+ use_subtitle=False,
+ use_subtitle_time=False,
+ use_frame_time=False,
+ nframe=0,
+ fps=-1,
+ ):
+ super().__init__(dataset=dataset, nframe=nframe, fps=fps)
+ self.use_subtitle = use_subtitle
+ self.use_subtitle_time = use_subtitle_time
+ self.use_frame_time = use_frame_time
+ self.dataset_name = dataset
+ lmu_root = LMUDataRoot()
+ self.clue_frame_root = osp.join(lmu_root, "clue_images", dataset)
+
+ @classmethod
+ def supported_datasets(cls):
+ return ["CG-Bench_OpenEnded"]
+
+ def get_subtitles(self, subtitle_path, frame_indices=None, fps=None, sub_time=False):
+
+ subtitles = []
+
+ srt_path = osp.join(self.data_root, subtitle_path)
+ assert osp.exists(srt_path)
+ import pysubs2
+
+ subs = pysubs2.load(srt_path, encoding="utf-8")
+ if not frame_indices:
+ for sub in subs:
+ sub_text = sub.text.replace("\\N", " ")
+ if sub_time:
+ start_time = milliseconds_to_seconds(sub.start)
+ end_time = milliseconds_to_seconds(sub.end)
+ sub_text = f"[{start_time}, {end_time}] {sub_text}"
+ if sub_text.strip() and sub_text not in subtitles:
+ subtitles.append(sub_text)
+ else:
+ for selected_frame_id in frame_indices:
+ cur_time = pysubs2.make_time(fps=fps, frames=selected_frame_id)
+ for sub in subs:
+ if sub.start < cur_time and sub.end > cur_time:
+ sub_text = sub.text.replace("\\N", " ")
+ if sub_time:
+ start_time = milliseconds_to_seconds(sub.start)
+ end_time = milliseconds_to_seconds(sub.end)
+ sub_text = f"[{start_time}, {end_time}] {sub_text}"
+ if sub_text.strip() and sub_text not in subtitles:
+ subtitles.append(sub_text)
+
+ if subtitles:
+ subtitles_str = '\n'.join(subtitles)
+ return f"The subtitles of the video are as follows:\n\n{subtitles_str}\n\n"
+ else:
+ return ""
+
+ def prepare_dataset(self, dataset_name="CG-Bench_OpenEnded", repo_id="CG-Bench/CG-Bench"):
+
+ def check_integrity(pth):
+ data_file = osp.join(pth, f"{dataset_name}.tsv")
+
+ if not os.path.exists(data_file):
+ return False
+
+ if md5(data_file) != self.MD5:
+ return False
+ data = load(data_file)
+ for video_pth in data["video"]:
+ if not osp.exists(osp.join(pth, video_pth)):
+ return False
+
+ return True
+
+ cache_path = get_cache_path(repo_id)
+
+ if cache_path is not None and check_integrity(cache_path):
+ dataset_path = cache_path
+ else:
+
+ def generate_tsv(pth):
+
+ tsv_file = osp.join(pth, f"{dataset_name}.tsv")
+
+ with open(osp.join(pth, "cgbench.json"), "r") as f:
+ data_file = pd.DataFrame(json.load(f))
+
+ data_file = data_file.assign(index=range(len(data_file)))
+ data_file["video"] = data_file["video_uid"].apply(lambda x: f"cg_videos_720p/{x}.mp4")
+ data_file["subtitle_path"] = data_file["video_uid"].apply(
+ lambda x: f"cg_subtitles/{x}.srt" if osp.exists(osp.join(pth, f"cg_subtitles/{x}.srt")) else ""
+ )
+
+ data_file = data_file[
+ [
+ "index",
+ "video_uid",
+ "video",
+ "duration",
+ "domain",
+ "sub_category",
+ "subtitle_path",
+ "question",
+ "answer",
+ "clue_intervals",
+ "qid",
+ ]
+ ]
+
+ data_file.to_csv(tsv_file, sep="\t", index=False)
+
+ if modelscope_flag_set():
+ from modelscope import dataset_snapshot_download
+ dataset_path = dataset_snapshot_download(dataset_id=repo_id)
+ else:
+ dataset_path = snapshot_download(repo_id=repo_id, repo_type="dataset")
+
+ unzip_hf_zip(dataset_path)
+ generate_tsv(dataset_path)
+
+ tsv_file = osp.join(dataset_path, f"{dataset_name}.tsv")
+
+ return dict(data_file=tsv_file, root=dataset_path)
+
+ def build_prompt(self, line, video_llm):
+
+ if isinstance(line, int):
+ assert line < len(self)
+ line = self.data.iloc[line]
+
+ message = []
+
+ sys_prompt = self.SYS
+
+ user_prompt = ""
+
+ video_path = line["video"]
+
+ if video_llm:
+ message.append(dict(type="video", value=osp.join(self.data_root, video_path)))
+ if self.use_subtitle and line["subtitle_path"] and not pd.isna(line["subtitle_path"]):
+ if self.nframe:
+ image_paths, frame_indices, vid_fps = self.save_video_frames(
+ video_path, uid=line["video_uid"], num_frames=self.nframe, fps=self.fps
+ )
+ user_prompt += self.get_subtitles(line["subtitle_path"], frame_indices=frame_indices,
+ fps=vid_fps, sub_time=self.use_subtitle_time)
+ else:
+ user_prompt += self.get_subtitles(line["subtitle_path"], sub_time=self.use_subtitle_time)
+ else:
+ image_paths, frame_indices, vid_fps = self.save_video_frames(
+ video_path, uid=line["video_uid"], num_frames=self.nframe, fps=self.fps
+ )
+ message.extend(dict(type="image", value=im) for im in image_paths)
+
+ if self.use_frame_time:
+ user_prompt += get_timestampes(frame_indices, vid_fps)
+
+ if self.use_subtitle and line["subtitle_path"] and not pd.isna(line["subtitle_path"]):
+ user_prompt += self.get_subtitles(
+ line["subtitle_path"], frame_indices=frame_indices, fps=vid_fps,
+ sub_time=self.use_subtitle_time
+ )
+
+ question = line["question"]
+ user_prompt += f"Question: {question}\n\n"
+
+ message.append(dict(type="text", value=sys_prompt + user_prompt))
+
+ return message
+
+ def clue_frame_paths(self, qid, num_frames=8):
+ frame_root = osp.join(self.clue_frame_root, qid)
+ os.makedirs(frame_root, exist_ok=True)
+ return [osp.join(frame_root, self.frame_tmpl.format(i, num_frames)) for i in range(1, num_frames + 1)]
+
+ def save_video_frames(self, video, uid, clue_intervals=None, num_frames=8, fps=-1):
+
+ if type(uid) is not str:
+ uid = str(uid)
+
+ vid_path = osp.join(self.data_root, video)
+ vid = decord.VideoReader(vid_path)
+ vid_fps = vid.get_avg_fps()
+ n_frames = len(vid)
+
+ if clue_intervals is not None:
+ merged_intervals = merge_intervals(clue_intervals)
+
+ if num_frames > 0 and fps < 0:
+ indices = sample_frames_clue_average(merged_intervals, num_frames, vid_fps)
+ frame_paths = self.clue_frame_paths(uid, len(indices))
+
+ elif fps > 0:
+ frame_indices = []
+ for start, end in merged_intervals:
+ start_frame = int(start * vid_fps)
+ end_frame = int(end * vid_fps)
+ step = vid_fps / fps
+ interval_indices = [
+ int(start_frame + i * step) for i in range(int((end_frame - start_frame) / step))
+ ]
+ frame_indices.extend(interval_indices)
+
+ if len(frame_indices) < 32:
+ indices = sample_frames_clue_average(merged_intervals, 32, vid_fps)
+ else:
+ indices = frame_indices
+ frame_paths = self.clue_frame_paths_fps(uid, len(indices), fps)
+
+ else:
+ if num_frames > 0 and fps < 0:
+ step_size = len(vid) / (num_frames + 1)
+ indices = [int(i * step_size) for i in range(1, num_frames + 1)]
+ frame_paths = self.frame_paths(uid)
+ elif fps > 0:
+ total_duration = n_frames / vid_fps
+ required_frames = int(total_duration * fps)
+ step_size = vid_fps / fps
+ indices = [int(i * step_size) for i in range(required_frames)]
+ frame_paths = self.frame_paths_fps(uid, len(indices))
+
+ valid_paths = []
+ valid_indices = []
+
+ if not np.all([osp.exists(p) for p in frame_paths]):
+ images = [vid[i].asnumpy() for i in indices]
+ for i, (img_array, path) in enumerate(zip(images, frame_paths)):
+ if osp.exists(path):
+ try:
+ with Image.open(path) as img:
+ img.verify()
+ valid_paths.append(path)
+ valid_indices.append(indices[i])
+ except Exception:
+ continue
+ else:
+ try:
+ img = Image.fromarray(img_array)
+ img.save(path)
+ img.verify()
+ valid_paths.append(path)
+ valid_indices.append(indices[i])
+ except Exception:
+ continue
+ else:
+ for i, path in enumerate(frame_paths):
+ try:
+ with Image.open(path) as img:
+ img.verify()
+ valid_paths.append(path)
+ valid_indices.append(indices[i])
+ except Exception:
+ continue
+
+ return valid_paths, valid_indices, vid_fps
+
+ def evaluate(self, eval_file, **judge_kwargs):
+
+ from .utils.cgbench import get_dimention_rating_open_ended, post_process_open
+
+ assert eval_file.endswith(".xlsx"), "data file should be an xlsx file"
+
+ tgt_file = eval_file.replace(".xlsx", "_rating.json")
+ score_file = eval_file.replace(".xlsx", "_score.xlsx")
+ step_1_tmp_file = eval_file.replace(".xlsx", "_step_1.pkl")
+ step_2_tmp_file = eval_file.replace(".xlsx", "_step_2.pkl")
+
+ data = load(eval_file)
+
+ data_pred_no_na = data[~pd.isna(data["prediction"])]
+ data_pred_na = data[pd.isna(data["prediction"])]
+
+ data_pred_na["model_result"] = -1
+ data_pred_na["step_1_result"] = -1
+ data_pred_na["step_2_result"] = -1
+ data_pred_na["score"] = -1
+
+ data_pred_no_na["model_result"] = data_pred_no_na.apply(
+ lambda row: post_process_open(
+ response=row["prediction"],
+ ),
+ axis=1,
+ )
+
+ if judge_kwargs.get("model", None) != "gpt-4o-0806":
+ judge_kwargs["model"] = "gpt-4o-0806"
+ print("The judge model in cg-bench is gpt-4o-0806!")
+
+ data_no_model_result = data_pred_no_na[data_pred_no_na["model_result"] == -1]
+ data_step_1 = data_pred_no_na[data_pred_no_na["model_result"] != -1]
+
+ model_step_1 = build_judge(system_prompt=sys_prompt_open_eval_step_1, **judge_kwargs)
+ nproc = judge_kwargs.pop('nproc', 32)
+
+ lines_step_1 = data_step_1.to_dict("records")
+ tups_step_1 = [(model_step_1, line) for line in lines_step_1]
+
+ keys_step_1 = {line["qid"] for line in lines_step_1}
+
+ ans = {}
+ if osp.exists(step_1_tmp_file):
+ ans = load(step_1_tmp_file)
+ tups_step_1 = [x for x, i in zip(tups_step_1, keys_step_1) if i not in ans]
+ keys_step_1 = [i for i in keys_step_1 if i not in ans]
+
+ _ = track_progress_rich(
+ eval_open_first,
+ tups_step_1,
+ nproc=nproc,
+ keys=keys_step_1,
+ save=step_1_tmp_file,
+ )
+
+ step_1_results = load(step_1_tmp_file)
+ data_step_1 = save_step_1_steps(data_step_1, step_1_results) # -1, 0, 1, 2
+
+ data_no_step_1_results = data_step_1[data_step_1["step_1_result"] == -1]
+ data_step_1_over = data_step_1[data_step_1["step_1_result"].isin([0, 1])]
+ data_step_2 = data_step_1[data_step_1["step_1_result"] == 2]
+
+ model_step_2 = build_judge(system_prompt=sys_prompt_open_eval_step_2, **judge_kwargs)
+
+ lines_step_2 = data_step_2.to_dict("records")
+
+ tups_step_2 = []
+
+ for line in tqdm(lines_step_2):
+ clue_intervals = eval(line["clue_intervals"])
+ lmu_root = LMUDataRoot()
+ clue_frame_root = osp.join(lmu_root, "clue_images", self.dataset)
+ data_root = self.data_root
+ frame_paths, _, _ = save_clue_video_frames(
+ data_root,
+ clue_frame_root,
+ video=line["video"],
+ uid=line["qid"],
+ clue_intervals=clue_intervals,
+ num_frames=32,
+ )
+ tups_step_2.append((model_step_2, line, frame_paths))
+
+ keys_step_2 = {line["qid"] for line in lines_step_2}
+
+ ans = {}
+ if osp.exists(step_2_tmp_file):
+ ans = load(step_2_tmp_file)
+ tups_step_2 = [x for x, i in zip(tups_step_2, keys_step_2) if i not in ans]
+ keys_step_2 = [i for i in keys_step_2 if i not in ans]
+
+ _ = track_progress_rich(
+ eval_open_second,
+ tups_step_2,
+ nproc=nproc,
+ keys=keys_step_2,
+ save=step_2_tmp_file,
+ )
+
+ step_2_results = load(step_2_tmp_file)
+ data_step_2 = save_step_2_steps(data_step_2, step_2_results)
+
+ data_no_step_2_results = data_step_2[data_step_2["score"] == -1]
+ data_step_2_over = data_step_2[data_step_2["score"].isin([0, 1])]
+
+ data = pd.concat(
+ [
+ data_pred_na,
+ data_no_model_result,
+ data_no_step_1_results,
+ data_step_1_over,
+ data_no_step_2_results,
+ data_step_2_over,
+ ]
+ )
+
+ dump(data, score_file)
+
+ rating = get_dimention_rating_open_ended(score_file)
+
+ dump(rating, tgt_file)
+
+ return rating
diff --git a/vlmeval/dataset/cmmmu.py b/vlmeval/dataset/cmmmu.py
new file mode 100644
index 0000000000000000000000000000000000000000..12c583f292103f32548621e39961e0282c275fbd
--- /dev/null
+++ b/vlmeval/dataset/cmmmu.py
@@ -0,0 +1,354 @@
+from .image_base import ImageBaseDataset
+import random
+from collections import Counter
+import os
+import re
+import tempfile
+from ..smp import *
+
+
+def get_multi_choice_prediction(response, all_choices, index2ans):
+ for char in [',', '.', '!', '?', ';', ':', "'"]:
+ response = response.strip(char)
+ response = " " + response + " " # add space to avoid partial match
+
+ candidates = []
+
+ for choice in all_choices: # (A) (B) (C) (D)
+ # Add the choice to candidates each time it appears in the response
+ candidates.extend([choice for _ in range(response.count(f'({choice})'))])
+
+ if len(candidates) == 0:
+ for choice in all_choices: # A B C D
+ # Similarly, add the choice for each occurrence
+ candidates.extend([choice for _ in range(response.count(f'{choice}'))])
+
+ if len(candidates) == 0 and len(response.split()) >= 1:
+ for index, ans in index2ans.items():
+ # Add index for each occurrence of ans in response
+ candidates.extend([index for _ in range(response.count(ans))])
+
+ # 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()) >= 1:
+ for index, ans in index2ans.items():
+ if ans in response:
+ candidates.append(index)
+ # index_ans = False # it's content ans.
+
+ if len(candidates) == 0: # still not get answer, randomly choose one.
+ return random.choice(all_choices)
+ # return ''
+ else:
+ # Count the occurrence of each candidate
+ candidate_counts = Counter(candidates)
+
+ # Select the most frequent candidates
+ max_count = max(candidate_counts.values())
+ most_frequent_candidates = [c for c in all_choices if candidate_counts.get(c, 0) == max_count]
+
+ # Combine the most frequent candidates in ABCD order
+ return ''.join(most_frequent_candidates)
+
+
+def extract_numbers(string):
+ # Pattern for numbers with Chinese commas
+ pattern_commas = r'-?\d{1,3}(?:，\d{3})+'
+ # Pattern for scientific notation
+ pattern_scientific = r'-?\d+(?:\.\d+)?[eE][+-]?\d+'
+ # Pattern for simple numbers without Chinese commas
+ pattern_simple = r'-?(?:\d+\.\d+|\.\d+|\d+)(?![eE][+-]?\d+)(?!，\d)'
+
+ # Extract numbers with Chinese 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 Chinese 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 check_is_number(string):
+ try:
+ float(string.replace(',', ''))
+ return True
+ except ValueError:
+ # check if there's comma inside
+ return False
+
+
+def count_letters(string):
+ return sum(c.isalpha() and 'a' <= c <= 'z' or 'A' <= c <= 'Z' for c in string)
+
+
+def normalize_str(string, answer):
+ # check if characters in the string
+
+ # if number, numerize it.
+ if string is None:
+ return [string]
+ 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
+ if len(string) > len(answer) + 20 or count_letters(string) > count_letters(answer) + 2:
+ return []
+ return [string]
+
+
+def get_fill_blank_prediction(response, answer):
+ """get the prediction from the generated response,
+ return a list of predicted strings or numbers"""
+
+ def get_key_subresponses(response):
+ response = response.strip("。").strip()
+ sub_responses = re.split(r'。|\n', response)
+ indicators_of_keys = ['是', '为', '所以', '等于', '方案', '选择',
+ '正确答案', '因此', '最后', '答案', '结果']
+ 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()
+
+ 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
+
+ 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], answer))
+ pred_list = tmp_pred_list
+
+ # remove duplicates
+ pred_list = list(set(pred_list))
+
+ return pred_list
+
+
+def get_TF_prediction(response):
+ """get the prediction from the generated response,
+ return a list of predicted strings or numbers"""
+
+ def get_key_subresponses(response):
+ response = response.strip("。").strip()
+ sub_responses = re.split(r'。|\n', response)
+ indicators_of_keys = ['是', '为', '所以', '判断',
+ '陈述', '说法', '表达', '答案', '结果']
+ key_responses = []
+ for index, resp in enumerate(sub_responses):
+ 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()
+
+ 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
+
+ key_responses = get_key_subresponses(response)
+
+ pred_list = key_responses.copy() # keep the original string response
+ # remove duplicates
+ pred_list = list(set(pred_list))
+
+ return pred_list
+
+
+class CMMMU(ImageBaseDataset):
+ TYPE = 'VQA'
+
+ DATASET_URL = {
+ 'CMMMU_VAL': 'https://opencompass.openxlab.space/utils/VLMEval/CMMMU_VAL.tsv'
+ }
+
+ DATASET_MD5 = {
+ 'CMMMU_VAL': 'b4727e2fce2415bf646379e60c11a726'
+ }
+
+ def dump_image(self, line):
+ os.makedirs(self.img_root, exist_ok=True)
+
+ tgt_path_z = []
+ if isinstance(line['image'], list):
+ for i in range(len(line['image'])):
+ tgt_path = osp.join(self.img_root, f"{line['index']}--{i + 1}.jpg")
+ if not read_ok(tgt_path):
+ decode_base64_to_image_file(line['image'][i], tgt_path)
+ tgt_path_z.append(tgt_path)
+ else:
+ tgt_path = osp.join(self.img_root, f"{line['index']}.jpg")
+ if not read_ok(tgt_path):
+ decode_base64_to_image_file(line['image'], tgt_path)
+ tgt_path_z.append(tgt_path)
+ return tgt_path_z
+
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+
+ suffix = eval_file.split('.')[-1]
+ result_file = eval_file.replace(f'.{suffix}', '_acc.csv')
+
+ if not osp.exists(result_file):
+ data = load(eval_file)
+ assert 'answer' in data and 'prediction' in data
+ data['prediction'] = [str(x) for x in data['prediction']]
+ data['answer'] = [str(x) for x in data['answer']]
+
+ correct_count = 0
+ correct_category = {
+ '技术与工程': [0, 0],
+ '科学': [0, 0],
+ '健康与医学': [0, 0],
+ '商业': [0, 0],
+ '艺术与设计': [0, 0],
+ '人文社会科学': [0, 0],
+ }
+
+ for i in tqdm(data.iterrows()):
+ line = i[1]
+ correct_category[line['category']][0] += 1
+
+ # Options
+ if line['type'] == '选择':
+ index2ans = {
+ 'A': line['option1'],
+ 'B': line['option2'],
+ 'C': line['option3'],
+ 'D': line['option4']
+ }
+ fact_option = get_multi_choice_prediction(line['prediction'], ['A', 'B', 'C', 'D'], index2ans)
+ if fact_option == line['answer']:
+ correct_count += 1
+ correct_category[line['category']][1] += 1
+
+ # Binary
+ elif line['type'] == '判断':
+ positive_keywords = ['正确', '对', '准确', '肯定', '对的']
+ negative_keywords = ['不对', '错误', '不正确', '不准确', '不合适', '否定', '错的', '错']
+ ambiguous_keywords = ['对错', '是否正确', '否正确', '或者', '是否', '正确性', '对不']
+
+ def judge_similarity(pred_list, positive_keywords, negative_keywords):
+ positive_count = 0
+ negative_count = 0
+
+ for pred in pred_list:
+ if any(pos_word in pred for pos_word in positive_keywords):
+ positive_count += 1
+ elif any(neg_word in pred for neg_word in negative_keywords):
+ negative_count += 1
+
+ if positive_count > negative_count:
+ return "对"
+ elif negative_count > positive_count:
+ return "错"
+ else:
+ return random.choice(['对', '错'])
+
+ answer = get_TF_prediction(line['prediction'])
+ answer = [word for word in answer if not any(ambiguous in word for ambiguous in ambiguous_keywords)]
+ fact_answer = judge_similarity(answer, positive_keywords, negative_keywords)
+ if fact_answer == line['answer']:
+ correct_count += 1
+ correct_category[line['category']][1] += 1
+
+ # Fill the Blank
+ else:
+ norm_answers = normalize_str(line['answer'], line['answer'])
+ predicted_answer = get_fill_blank_prediction(line['prediction'], line['answer'])
+
+ for pred in predicted_answer:
+ # already normalized
+ 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
+ # print(norm_ans, pred)
+ if isinstance(norm_ans, str) and norm_ans in pred:
+ correct_count += 1
+ correct_category[line['category']][1] += 1
+ else: # it's a number
+ if pred in norm_answers:
+ correct_count += 1
+ correct_category[line['category']][1] += 1
+
+ accuracyz = {}
+ accuracyz['总准确率'] = correct_count / len(data)
+ for i in correct_category.keys():
+ accuracyz[i] = correct_category[i][1] / correct_category[i][0]
+
+ accuracyz = d2df(accuracyz)
+ accuracyz.round(10)
+ dump(accuracyz, result_file)
+
+ result = pd.read_csv(result_file)
+ return result
+
+ def build_prompt(self, line):
+ if line['type'] == '选择':
+ tgt_path = self.dump_image(line)
+ question = line['question']
+ options_prompt = 'Options:\n'
+
+ for i in [['A', '1'], ['B', '2'], ['C', '3'], ['D', '4']]:
+ options_prompt += i[0] + '. ' + line['option' + i[1]] + '\n'
+
+ prompt = (f'问题: {question}\n' + options_prompt
+ + '请回答上述多项选择题，并选出正确选项。这些题目可能包括单选和多选题型。如果所提供的信息不足以确定一个明确的答案，那么请根据可用的数据和你的判断来选择最可能正确的选项。')
+
+ msgs = []
+ if isinstance(tgt_path, list):
+ msgs.extend([dict(type='image', value=p) for p in tgt_path])
+ else:
+ msgs = [dict(type='image', value=tgt_path)]
+ msgs.append(dict(type='text', value=prompt))
+
+ return msgs
+
+ elif line['type'] == '判断':
+ msgs = super().build_prompt(line)
+ assert msgs[-1]['type'] == 'text'
+ msgs[-1]['value'] += '\n请回答上述判断题，并根据题目描述和所给的信息来判断问题中陈述的对错。如果信息不完整或不足以作出绝对判断，请运用你的逻辑推理和现有信息来做出最可能的判断。'
+ return msgs
+
+ else:
+ msgs = super().build_prompt(line)
+ assert msgs[-1]['type'] == 'text'
+ msgs[-1]['value'] += '\n请回答上述填空题，并根据题目的要求和所提供的信息来给出最恰当的答案。如果信息不足以确切回答，那么请依据现有的数据和你的推理能力来填写最合理的答案。'
+ return msgs
diff --git a/vlmeval/dataset/creation.py b/vlmeval/dataset/creation.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ee49c9622efc21afa45504513a07f0d751bbb6d
--- /dev/null
+++ b/vlmeval/dataset/creation.py
@@ -0,0 +1,738 @@
+from .image_base import ImageBaseDataset
+import numpy as np
+import pandas as pd
+from ..smp import *
+from .utils import build_judge, DEBUG_MESSAGE
+from ..utils import track_progress_rich
+import re
+
+prompt_dict = {}
+prompt_dict['LiveMMBench_Creation'] = {
+ # Subjective Judge [GPT-4o reference]
+ 'subjective':"""
+Please act as an impartial judge and evaluate the quality of two responses provided by AI assistants to the user prompt.
+
+Your task is to carefully assess two responses based on provided instructions and evaluation criteria. After evaluating both responses, determine which response features better quality and better meets the criteria. If both responses are similar or nearly identical in quality, you should indicate a tie. Avoid position bias toward the first or second response.
+
+Suggested Steps for Evaluation:
+1. Review both responses independently and then carefully compare their strengths and weaknesses. A good response should feature good language quality, follow the user instruction and meet as many criteria as possible.
+2. After completing the first evaluation, swap the positions of response A and B and repeat Step 1 and get the 2nd evaluation outcome. This helps to mitigate the potential position bias.
+3. After completing both evaluations (in the original and reversed order), combine your analysis and provide a final conclusion based on the overall assessment. If both responses are relatively similar, or the differences are minimal and hard to distinguish, your conclusion should indicate a tie ([[A=B]]).
+
+Your **conclusion** should be one of the following options (A, B are of the original order):
+1. [[A>>B]]: Response A is clearly better than Response B.
+2. [[A>B]]: Response A is slightly better than Response B.
+3. [[A=B]]: Response A is nearly identical to Response B.
+4. [[B>A]]: Response B is slightly better than Response A.
+5. [[B>>A]]: Response B is clearly better than Response A.
+
+User Instruction:\n[INSTRUCTIONS]\n{instructions}\n[END INSTRUCTIONS]\n\n
+Repsonse A:\n[RESPONSE A]\n{reference_answer_by_gpt4o}\n[END RESPONSE A]\n\n
+Response B:\n[RESPONSE B]\n{prediction}\n[END RESPONSE B]\n\n
+Evaluation Criteria:\n[CRITERIA]\n{criteria}\n[END CRITERIA]\n\n
+
+Your output should include:
+1. Conclusion: Your final conclusion based on the overall assessment.
+2. Reasoning: Your reasoning process and analysis of the two responses.
+
+Your output should follow the following format (CONCLUSION should be one of the five options: A>>B, A>B, A=B, B>A, B>>A):
+
+Final Conclusion: [[CONCLUSION]]
+Reasoning Process: [REASONING]\n
+""",
+
+ # Criteria Alignment w/o GT
+ 'objective_without_gt':"""
+Please act as an impartial judge and evaluate the **Criteria Alignment** of the two responses provided by AI assistants to the user prompt. The responses were generated based on the provided instructions and visual input from images.
+
+Suggested Steps for Evaluation:
+1. Evaluate **Criteria Alignment** of both responses based on the criteria.
+ • If a criterion consist of **X aspects**, each aspect is worth **10 / X points**.
+ • For each aspect, there may be multiple sub-criteria. If there are **Y sub-criteria for the aspect**, each sub-criterion worths **10 / (X * Y) points**.
+2. Assign a total score out of 10 for each response.
+
+User Instruction:\n[INSTRUCTIONS]\n{instructions}\n[END INSTRUCTIONS]\n\n
+Repsonse A:\n[RESPONSE A]\n{reference_answer_by_gpt4o}\n[END RESPONSE A]\n\n
+Response B:\n[RESPONSE B]\n{prediction}\n[END RESPONSE B]\n\n
+Criteria:\n[CRITERIA]\n{criteria}\n[END CRITERIA]\n\n
+
+Your output should evaluate alignment scores of each response and end with a conclusion in the following format (The full score is 10. X, Y are alignment scores for Response A and B):
+
+Response A Alignment Score: X/10
+Response B Alignment Score: Y/10\n
+""",
+
+ # Criteria Alignment w. GT
+ 'objective_with_gt':"""
+Please act as an impartial judge and evaluate the **Criteria Alignment** of the two responses provided by AI assistants to the user prompt. The responses were generated based on the provided instructions and visual input from images. There is also a ground truth corresponding to the instructions provided for reference.
+Take this context into account when making your judgment.
+
+Steps for Evaluation:
+1. Evaluate **Criteria Alignment** of both responses based on the criteria and the ground truth.
+ • If a criterion consist of **X aspects**, each aspect is worth **10 / X points**.
+ • For each aspect, there may be multiple sub-criteria. If there are **Y sub-criteria for the aspect**, each sub-criterion worths **10 / (X * Y) points**.
+2. Assign a total score out of 10 for each response.
+
+User Instruction:\n[INSTRUCTIONS]\n{instructions}\n[END INSTRUCTIONS]\n\n
+Ground Truth:\n[GROUND TRUTH]\n{groundtruth}\n[END GROUND TRUTH]\n\n
+Repsonse A:\n[RESPONSE A]\n{reference_answer_by_gpt4o}\n[END RESPONSE A]\n\n
+Response B:\n[RESPONSE B]\n{prediction}\n[END RESPONSE B]\n\n
+Criteria:\n[CRITERIA]\n{criteria}\n[END CRITERIA]\n\n
+
+Your output should evaluate alignment scores of each response and end with a conclusion in the following format (The full score is 10. X, Y are alignment scores for Response A and B):
+
+Response A Alignment Score: X/10
+Response B Alignment Score: Y/10\n
+""",
+}
+
+prompt_dict['Creation_MMBench'] = {
+ # Subjective Judge [GPT-4o reference, with image]
+ 'subjective':"""
+Please act as an impartial judge and evaluate the quality of the responses provided by two AI assistants to the user prompt below, considering both the provided criteria and the image.
+
+Your task is to carefully assess each response based on how well it meets the evaluation criteria, incorporating the visual context from the image. The criteria should be the primary basis for your judgment, with the image serving to complement and inform your analysis.
+
+Steps for Evaluation:
+ 1. Review Both Responses Independently:
+ Carefully analyze Assistant A’s and Assistant B’s responses with the criteria and the image. Do not assume any response is better just because it is listed first. Each response should be independently assessed based on the criteria and aided by images to help understand the context.
+
+ 2. Compare the Strengths and Weaknesses:
+ After evaluating each response independently, compare the two. Consider both the quality of the content and how closely it aligns with the criteria and image. Identify the strengths and weaknesses of each response, and highlight the key differences.
+
+ 3. Ensure Fairness:
+ To avoid positional bias, swap the positions of Assistant A and Assistant B after the first evaluation (i.e., make Assistant A become Assistant B and vice versa) and repeat the analysis and comparison. This ensures that each response is evaluated impartially under the same criteria.
+
+ 4. Provide a Conclusion Based on Both Evaluations:
+ After completing both evaluations (original and swapped positions), combine your analysis to provide a final verdict. If the responses are similar, with only minimal differences, your judgment should reflect that and indicate a tie.
+
+Possible Verdict Options:
+
+• If Assistant A is clearly better in both evaluations: [[A>>B]]
+• If Assistant A is slightly better in both evaluations: [[A>B]]
+• If both responses are nearly identical, showing minimal differences and no clear advantage: [[A=B]]
+• If Assistant B is slightly better in both evaluations: [[B>A]]
+• If Assistant B is clearly better in both evaluations: [[B>>A]]
+
+Instructions to the AI Assistants:
+
+[INSTRUCTIONS]
+{instructions}
+[END INSTRUCTIONS]
+
+Assistant A Response:
+
+[ASSISTANT A]
+{reference_answer_by_gpt4o}
+[END ASSISTANT A]
+
+Evaluation Criteria:
+
+[CRITERIA]
+{criteria}
+[END CRITERIA]
+
+Assistant B Response:
+
+[ASSISTANT B]
+{prediction}
+[END ASSISTANT B]
+
+Output Format:
+
+Your output should include:
+ 1. Evaluation of Assistant A’s Response: Provide a detailed qualitative evaluation, focusing on how well Assistant A’s response aligns with the criteria and the image.
+ 2. Evaluation of Assistant B’s Response: Provide a detailed qualitative evaluation, focusing on how well Assistant B’s response aligns with the criteria and the image.
+ 3. Final Verdict: After considering both evaluations, select one of the following verdicts and justify it based on your analysis:
+
+Your output format should end like this:
+Assistant A Evaluation: [qualitative comment]
+Assistant B Evaluation: [qualitative comment]
+Final Verdict is: [[VERDICT]]
+""",
+
+##### For Visual Factuality
+ 'objective_without_gt':"""
+Please act as an impartial judge and evaluate the **Visual Factuality** of the responses provided by two AI assistants to the user prompt displayed below.
+
+The responses were generated based on the provided instructions and visual input from images. Take this context into account when making your judgment.
+
+Steps for Evaluation:
+1. Evaluate visual factuality for both responses based on the visual factuality criteria.
+ • If the visual factuality criteria consist of **X aspects**, each aspect is worth **10/X points**.
+ • For each aspect, there may be multiple small criteria. If there are **Y small criteria in one aspect**, each small criterion is worth **10/X/Y points**.
+2. Assign a total score out of 10 for each response.
+
+Instructions to the AI assistants:
+[INSTRUCTIONS]
+{instructions}
+[END INSTRUCTIONS]
+
+Assistant A response:
+[ASSISTANT A]
+{reference_answer_by_gpt4o}
+[END ASSISTANT A]
+
+Visual Factuality Criteria:
+[VISUAL FACTUALITY CRITERIA]
+{criteria}
+[END CRITERIA]
+
+Assistant B response:
+[ASSISTANT B]
+{prediction}
+[END ASSISTANT B]
+
+Your output should evaluate visual factuality scores for each assistant and end like this:
+
+Response A Visual Factuality Score: X/10
+Response B Visual Factuality Score: Y/10
+""",
+
+ 'objective_with_gt':"""
+Please act as an impartial judge and evaluate the **Visual Factuality** of the responses provided by two AI assistants to the user prompt displayed below.
+
+The responses were generated based on the provided instructions and visual input from images.
+There is a provided ground truth for the instructions, but the ground truth was not given to the AI assistants when generating their responses.
+Take this context into account when making your judgment.
+
+Steps for Evaluation:
+1. Evaluate visual factuality for both responses based on the provided ground truth and visual factuality criteria.
+ • If the visual factuality criteria consist of **X aspects**, each aspect is worth **10/X points**.
+ • For each aspect, there may be multiple small criteria. If there are **Y small criteria in one aspect**, each small criterion is worth **10/X/Y points**.
+2. Assign a total score out of 10 for each response.
+
+Instructions to the AI assistants:
+[INSTRUCTIONS]
+{instructions}
+[END INSTRUCTIONS]
+
+Assistant A response:
+[ASSISTANT A]
+{reference_answer_by_gpt4o}
+[END ASSISTANT A]
+
+Visual Factuality Criteria:
+[VISUAL FACTUALITY CRITERIA]
+{criteria}
+[END CRITERIA]
+
+Assistant B response:
+[ASSISTANT B]
+{prediction}
+[END ASSISTANT B]
+
+Ground truth:
+[GROUND TRUTH]
+{groundtruth}
+[END GROUND TRUTH]
+
+Your output should evaluate visual factuality scores for each assistant and end like this:
+
+Response A Visual Factuality Score: X/10
+Response B Visual Factuality Score: Y/10
+""",
+}
+
+creation_mmbench_category_dict = {
+ 'CATEGORY_Literary_Writing': [
+ 'story_continue',
+ 'landscape_to_poem',
+ 'historical_story_creation',
+ 'story_novel_creation',
+ 'prose_writing_scenery',
+ 'art_inspired_prose',
+ 'daily_conversation_creation',
+ 'children_book_illustration_dialogue_creation'
+ ],
+ 'CATEGORY_Common_Functionality_Writing':[
+ 'ins_simple_daily_copywriter',
+ 'travel_journal',
+ 'short_video_scripts_for_social_media',
+ 'social_media_travel_content',
+ 'daily_achievement_show_off',
+ 'scientific_research_simple_promotion',
+ 'twitter_comment_on_daily_news',
+ 'personal_event_summaries',
+ 'daily_affairs_inquiries',
+ 'business_collaborative_email_writing',
+ 'daily_emotional_email_writing',
+ 'letter_of_complaint',
+ 'daily_invitation_email_writing',
+ 'holiday_card_writing',
+ 'letter_of_application',
+ 'product_usage_experience_review',
+ 'store_experience_review',
+ 'public_welfare_activity_participation_initiative'
+ ],
+ 'CATEGORY_Professional_Functionality_Writing': [
+ 'museum_guide_word_creation',
+ 'recipe_infer_and_guide',
+ 'landscape_introduction',
+ 'drafting_announcements_for_public_spaces',
+ 'floor_plan_renovation_design',
+ 'teaching_plan',
+ 'nutritional_formulation_of_recipe',
+ 'clothing_match_design',
+ 'software_engineering_diagram_explanation',
+ 'event_planning_and_venue_arrangement',
+ 'ui_design_analysis_and_optimization',
+ 'attraction_promotional_words',
+ 'product_marketing_strategy',
+ 'script_writing_for_product_advertisement_promotional_video',
+ 'residence_reasoning',
+ 'scientific_diagram_understanding',
+ 'pulitzer_prize_judge',
+ 'architecture_appreciation',
+ 'company_team_amuse_broadcast'
+ ],
+ 'CATEGORY_Creative_Multimodal_Understanding': [
+ 'travel_itinerary_planning_and_recommendations',
+ 'photography_appreciation',
+ 'meme_explanation',
+ 'advertisement_explanation',
+ 'document_understanding',
+ 'snapshot_analysis'
+ ]
+
+}
+
+def is_criteria_valid(criteria):
+ import re
+ for value in criteria.values():
+ if value == '\\' or value == '' or not re.search('[a-zA-Z]', value):
+ return False
+ return True
+
+key_mapping = {
+ "sub_parse_ok": "preference_parse_ok",
+ "sub_dist": "preference_dist",
+ "win_rate": "win_rate",
+ "sub_reward": "reward",
+ "obj_parse_ok": "visual_factuality_parse_ok",
+ "obj_score": "visual_factuality_score",
+ "obj_ref_score": "visual_factuality_ref_score"
+}
+
+def rename_keys(data, key_mapping):
+ if isinstance(data, dict):
+ new_data = {}
+ for key, value in data.items():
+ new_key = key_mapping.get(key, key)
+ new_data[new_key] = rename_keys(value, key_mapping)
+ return new_data
+ elif isinstance(data, list):
+ return [rename_keys(item, key_mapping) for item in data]
+ else:
+ return data
+
+
+def build_prompt(line, dataset_name):
+ try:
+ criteria = eval(line['criteria'])
+ except:
+ criteria = line['criteria']
+
+ if isinstance(criteria, dict):
+ new_criteria = {}
+ for k in criteria:
+ if 'subjective' in k.lower():
+ new_criteria['subjective'] = criteria[k]
+ else:
+ new_criteria['objective'] = criteria[k]
+ else:
+ assert isinstance(criteria, str)
+ new_criteria = {'subjective': criteria}
+ criteria = new_criteria
+ assert 'subjective' in criteria, 'No subjective criteria found in the criteria dict'
+
+ prompts = {}
+ if listinstr(['Creation_MMBench'], dataset_name):
+ dataset_name = 'Creation_MMBench'
+ prompts['subjective'] = prompt_dict[dataset_name]['subjective'].format(
+ instructions=line['question'],
+ criteria=criteria['subjective'],
+ reference_answer_by_gpt4o=line['reference_answer_by_gpt4o'],
+ prediction=line['prediction']
+ )
+ if 'objective' in criteria:
+ if 'ground_truth' in line and (not pd.isna(line['ground_truth'])) and line['ground_truth'] != '':
+ prompts['objective'] = prompt_dict[dataset_name]['objective_with_gt'].format(
+ instructions=line['question'],
+ criteria=criteria['objective'],
+ groundtruth=line['ground_truth'],
+ reference_answer_by_gpt4o=line['reference_answer_by_gpt4o'],
+ prediction=line['prediction'])
+ else:
+ prompts['objective'] = prompt_dict[dataset_name]['objective_without_gt'].format(
+ instructions=line['question'],
+ criteria=criteria['objective'],
+ reference_answer_by_gpt4o=line['reference_answer_by_gpt4o'],
+ prediction=line['prediction'])
+ return prompts
+
+
+def Generate_Creation_MMBench_judge(model, image_list, prompt):
+ assert isinstance(prompt, dict)
+ response = {}
+ for key in prompt.keys():
+ if image_list and key == 'subjective':
+ input_msg = []
+ for img_path in image_list:
+ if read_ok(img_path):
+ input_msg.append({'type': 'image', 'value': img_path})
+ else:
+ raise ValueError(f"Image not found: {img_path}")
+ input_msg.append({'type': 'text', 'value': prompt[key]})
+ # print(f'using image {image_list} and text')
+ response[key] = model.generate(input_msg)
+ else:
+ response[key] = model.generate(prompt[key])
+ return response
+
+
+def extract_subjective(inp, dataset_name):
+ mapping_dict = {
+ 'LiveMMBench_Creation': 'FINAL CONCLUSION:',
+ 'Creation_MMBench': 'FINAL VERDICT IS:'
+ }
+ lines = inp.split('\n')
+ for line in lines:
+ line = line.upper()
+ if line.startswith(mapping_dict[dataset_name]):
+ rem = line.split(mapping_dict[dataset_name])[1].strip()
+ rem = rem.split('[[')[1].split(']]')[0].strip()
+ cands = [
+ 'A>>B', 'A>B', 'A=B', 'B>A', 'B>>A',
+ 'B<>A' in text:
+ return 2
+ elif 'AA' in text:
+ return 1
+ elif 'A=B' in text or 'B=A' in text:
+ return 0
+ elif 'A>B' in text or 'B>B' in text or 'B< 0 and not self.is_api:
+ concatenated_images = concat_images(tgt_path, max_concat=self.concat_num, column_num=self.column_num)
+
+ old_tgt_path = tgt_path
+ assert isinstance(old_tgt_path, list)
+ if self.column_num != -1:
+ tgt_path = [
+ '_'.join(old_tgt_path[0].split('_')[:-1]) + '_concat{}_{}.jpg'.format(self.concat_num, i)
+ for i in range(len(concatenated_images))
+ ]
+ else:
+ tgt_path = ['_'.join(old_tgt_path[0].split('_')[:-1]) + '_concat_all.jpg']
+
+ for path, concatenated_image in zip(tgt_path, concatenated_images):
+ if not read_ok(path):
+ decode_base64_to_image_file(encode_image_to_base64(concatenated_image), path)
+ num_images, image_size = len(old_tgt_path), concatenated_image.size
+ print('concat {} images to a new one with size {}. save at {}'.format(num_images, image_size, path))
+ return tgt_path
+
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ logger = get_logger('Evaluation')
+ model = judge_kwargs['model']
+
+ suffix = eval_file.split('.')[-1]
+ storage = eval_file.replace(f'.{suffix}', f'_{model}.xlsx')
+ tmp_file = eval_file.replace(f'.{suffix}', f'_{model}.pkl')
+
+ if osp.exists(storage):
+ logger.warning(f'GPT scoring file {storage} already exists, will reuse it in DUDE_eval. ')
+ else:
+ data = load(eval_file)
+ model = build_judge(max_tokens=128, **judge_kwargs)
+ lt = len(data)
+ lines = [data.iloc[i] for i in range(lt)]
+ tups = [(model, line) for line in lines]
+ indices = [line['index'] for line in lines]
+
+ ans = {}
+ if osp.exists(tmp_file):
+ ans = load(tmp_file)
+ tups = [x for x, i in zip(tups, indices) if i not in ans]
+ indices = [i for i in indices if i not in ans]
+
+ if len(indices):
+ new_results = list()
+ for model, line in tqdm(tups):
+ res = MMLongBench_auxeval(model, line)
+ new_results.append(res)
+
+ log_map, res_map, pred_map = {}, {}, {}
+ all_inds = [line['index'] for line in lines]
+ for k, v in zip(all_inds, new_results):
+ log_map[k] = v['log']
+ res_map[k] = v['res']
+ pred_map[k] = v['pred']
+ data['res'] = [res_map[idx] for idx in data['index']]
+ data['log'] = [log_map[idx] for idx in data['index']]
+ data['pred'] = [pred_map[idx] for idx in data['index']]
+ dump(data, storage)
+
+ score = DUDE_acc(storage)
+ score_pth = storage.replace('.xlsx', '_score.csv')
+
+ dump(score, score_pth)
+ logger.info(f'DUDE successfully finished evaluating {eval_file}, results saved in {score_pth}')
+ logger.info('Score: ')
+ logger.info(score)
diff --git a/vlmeval/dataset/dynamath.py b/vlmeval/dataset/dynamath.py
new file mode 100644
index 0000000000000000000000000000000000000000..cf6979716c6eb3bd8d391bb1830f5416ae16bf75
--- /dev/null
+++ b/vlmeval/dataset/dynamath.py
@@ -0,0 +1,259 @@
+import re
+import json
+import numpy as np
+import pandas as pd
+import sys
+import math
+import os
+import os.path as osp
+import argparse
+
+from .image_base import ImageBaseDataset
+from .utils import build_judge
+from ..utils import track_progress_rich
+from ..smp import load, dump, d2df, toliststr
+
+
+def preprocess(str1):
+ str1 = str(str1)
+ if 0 <= str1.find("{") < str1.rfind("}"):
+ str1 = str1[str1.find("{"): str1.rfind("}") + 1]
+ str2 = str1.replace("\\", "")
+ str2 = str2.replace("\\n", "\n")
+ return str2
+
+
+def transfer(str1):
+ if "\u03c0" in str1:
+ strs = str1.split('\u03c0')
+ str1 = strs[0]
+ return float(str1) * np.pi
+ else:
+ return float(str1)
+
+def extract_options(text):
+ pattern = r'\((\w)\)\s([^()]+)'
+ try:
+ text = str(text)
+ matches = re.findall(pattern, text)
+ options_dict = {option: description.strip() for option, description in matches}
+ return options_dict
+ except:
+ return {}
+
+def parse_answer(answer, answer_type="multiple choice", question=None):
+ if answer_type == "float":
+ if answer.isdigit():
+ return True, float(answer)
+ else:
+ parts = answer.split(' ')
+ answer = parts[0]
+ try:
+ answer = transfer(answer)
+ return True, answer
+ except:
+ return False, None
+ elif answer_type == "multiple choice":
+ if len(answer) == 1 and answer.upper() in 'ABCDE':
+ return True, answer.upper()
+ else:
+ options = extract_options(question)
+ options = {v: k for k, v in options.items()}
+ if answer.strip().lower() in options:
+ return True, options[answer.strip().lower()]
+ return False, None
+ else:
+ return True, answer
+
+
+def DynaMath_auxeval(model, line):
+ pred = line['prediction']
+ pred = preprocess(pred)
+
+ succeed, short_answer = None, None
+ try:
+ dj = json.loads(pred, strict=False)
+ short_answer = dj.get("short answer")
+ assert short_answer is not None
+ succeed, short_answer = parse_answer(short_answer, answer_type=line['answer_type'])
+ assert succeed
+ except:
+ # Failed to parse the JSON, use an auxiliary LLM to get the short answer
+ if line['answer_type'] == 'multiple choice':
+ inst = "Output the corresponing choice option, such as 'A', 'B', 'C', 'D', in a single line. Output 'Z' if the answer is not in the options."
+ elif line['answer_type'] == 'float':
+ inst = "Output a three-digit floating-point number in a single line."
+ else:
+ inst = (
+ "Output a short answer in a single line. Any float numbers in the answer "
+ "should be formatted as three-digit floating-point numbers."
+ )
+ if line['answer_type'] == 'multiple choice':
+ options = extract_options(line['question'])
+ opt = ""
+ for k, v in options.items():
+ opt += f"({k}) {v} "
+ prompt = f"Free-form answer: {pred}\nOptions:{opt}\nInstruction: {inst}"
+ else:
+ prompt = f"Free-form answer: {pred}\nInstruction: {inst}"
+ response = pred
+ succeed, short_answer = parse_answer(response, line['answer_type'], line['question'])
+ if not succeed:
+ response = model.generate(prompt)
+ succeed, short_answer = parse_answer(response, line['answer_type'])
+
+ if line['answer_type'] == 'float':
+ if succeed:
+ diff = float(short_answer) - float(line['answer'])
+ if abs(diff) <= 0.001:
+ return dict(parse=True, extracted=short_answer, correct=True)
+ else:
+ return dict(parse=True, extracted=short_answer, correct=False)
+ else:
+ return dict(parse=False, extracted=None, correct=False)
+ elif line['answer_type'] == 'multiple choice':
+ if succeed:
+ return dict(parse=True, extracted=short_answer, correct=(short_answer == line['answer']))
+ else:
+ if line['answer'] in pred[:3].upper():
+ return dict(parse=False, extracted=None, correct=True)
+ else:
+ return dict(parse=False, extracted=None, correct=False)
+ else:
+ if succeed:
+ return dict(parse=True, extracted=short_answer, correct=(short_answer.lower() in line['answer'].lower()))
+ else:
+ return dict(parse=False, extracted=None, correct=(short_answer.lower() in line['answer'].lower()))
+
+
+class Dynamath(ImageBaseDataset):
+
+ TYPE = 'VQA'
+ DATASET_URL = {
+ 'DynaMath': 'https://opencompass.openxlab.space/utils/VLMEval/DynaMath.tsv',
+ 'DynaMath_noprompt': 'https://opencompass.openxlab.space/utils/VLMEval/DynaMath.tsv',
+ }
+ DATASET_MD5 = {
+ 'DynaMath': 'b8425ad9a7114571fc9366e013699494',
+ 'DynaMath_noprompt': 'b8425ad9a7114571fc9366e013699494',
+ }
+ GUIDE = """
+## Answer Instruction Please provide an answer to the question outlined above. Your response should adhere \
+to the following JSON format, which includes two keys: 'solution' and 'short answer'. The 'solution' key can contain \
+detailed steps needed to solve the question, and the 'short answer' key should provide a concise response. {INST}
+
+Example of expected JSON response format:
+
+"""
+ EXAMPLE = {
+ "solution": "[Detailed step-by-step explanation]",
+ "short answer": "[Concise Answer]"
+ }
+ TEXT_EXAMPLE = json.dumps(EXAMPLE, indent=4)
+
+ # Given one data record, return the built prompt (a multi-modal message), can override
+ def build_prompt(self, line):
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ if self.meta_only:
+ tgt_path = toliststr(line['image_path'])
+ else:
+ tgt_path = self.dump_image(line)
+
+ prompt = f"## Question\n {line['question']}"
+ if line['answer_type'] == 'multiple choice':
+ inst = "Provide the corresponing choice option in the 'short answer' key, such as 'A', 'B', 'C', or 'D'."
+ elif line['answer_type'] == 'float':
+ inst = "Format the answer as a three-digit floating-point number and provide it in the 'short answer' key."
+ else:
+ inst = "Float numbers in the answer should be formatted as three-digit floating-point numbers."
+
+ if 'noprompt' not in self.dataset_name:
+ prompt = prompt + self.GUIDE.format(INST=inst) + self.TEXT_EXAMPLE
+
+ msgs = []
+ if isinstance(tgt_path, list):
+ msgs.extend([dict(type='image', value=p) for p in tgt_path])
+ else:
+ msgs = [dict(type='image', value=tgt_path)]
+ msgs.append(dict(type='text', value=prompt))
+ return msgs
+
+ def evaluate(self, eval_file, **judge_kwargs):
+ judge_name = judge_kwargs.pop('model', 'gpt-4o-mini')
+
+ model = build_judge(model=judge_name, **judge_kwargs)
+ suffix = eval_file.split('.')[-1]
+
+ storage = eval_file.replace(f'.{suffix}', f'_{judge_name}.xlsx') # noqa: F841
+ score_file = eval_file.replace(f'.{suffix}', f'_{judge_name}_score.csv') # noqa: F841
+ tmp_file = eval_file.replace(f'.{suffix}', f'_{judge_name}.pkl') # noqa: F841
+ nproc = judge_kwargs.pop('nproc', 6) # noqa: F841
+
+ res = load(tmp_file) if os.path.exists(tmp_file) else {}
+ res = {k: v for k, v in res.items() if v is not None}
+
+ model.system_prompt = """\
+You are a helpful assistant that helps me to format free-form answers into a short answer according to the instruction.
+"""
+ if not osp.exists(storage):
+ data = load(eval_file)
+ lt = len(data)
+ payloads = [dict(model=model, line=data.iloc[i]) for i in range(lt) if data.iloc[i]['index'] not in res]
+ keys = [idx for idx in data['index'] if idx not in res]
+
+ if len(keys):
+ results = track_progress_rich(DynaMath_auxeval, payloads, nproc=nproc, save=tmp_file, keys=keys)
+ for k, r in zip(keys, results):
+ res[k] = r
+
+ data['parse'] = [res[idx]['parse'] for idx in data['index']]
+ data['extracted'] = [res[idx]['extracted'] for idx in data['index']]
+ data['correct'] = [res[idx]['correct'] for idx in data['index']]
+ dump(data, storage)
+
+ data = load(storage)
+ # Calculate Average Accuracy
+ score_avg = {}
+ score_avg['Overall'] = np.mean(data['correct'])
+
+ subs = set(data['subject'])
+ for sub in subs:
+ data_sub = data[data['subject'] == sub]
+ score_avg[f'Subject-{sub}'] = np.mean(data_sub['correct'])
+
+ lvls = set(data['knowledge_level'])
+ for lvl in lvls:
+ data_lvl = data[data['knowledge_level'] == lvl]
+ score_avg[f'Level-{lvl}'] = np.mean(data_lvl['correct'])
+
+ # Calculate the Worst Case Accuracy
+ score_worst = {}
+ data_worst = data[data['varid'] == 1]
+ qid2corr = {idx: True for idx in data_worst['index']}
+ lt = len(data)
+ for i in range(lt):
+ item = data.iloc[i]
+ qid2corr[item['qid']] *= item['correct']
+ data_worst['correct'] = [qid2corr[idx] for idx in data_worst['qid']]
+ score_worst['Overall'] = np.mean(data_worst['correct'])
+
+ subs = set(data_worst['subject'])
+ for sub in subs:
+ data_sub = data_worst[data_worst['subject'] == sub]
+ score_worst[f'Subject-{sub}'] = np.mean(data_sub['correct'])
+
+ lvls = set(data_worst['knowledge_level'])
+ for lvl in lvls:
+ data_lvl = data_worst[data_worst['knowledge_level'] == lvl]
+ score_worst[f'Level-{lvl}'] = np.mean(data_lvl['correct'])
+
+ d1 = {'Setting': 'Average'}
+ d1.update(score_avg)
+ d2 = {'Setting': 'Worst Case'}
+ d2.update(score_worst)
+ score = pd.concat([d2df(d1), d2df(d2)], ignore_index=True)
+
+ dump(score, score_file)
+ return score
diff --git a/vlmeval/dataset/emma.py b/vlmeval/dataset/emma.py
new file mode 100644
index 0000000000000000000000000000000000000000..2aa3eb763bfde82f51b727348a33c894e21909b2
--- /dev/null
+++ b/vlmeval/dataset/emma.py
@@ -0,0 +1,55 @@
+from vlmeval import *
+from .image_shortqa import ImageShortQADataset
+from .image_mcq import MMMUDataset
+
+class EMMADataset(ImageShortQADataset):
+
+ COT_INST = "Please solve the problem step by step. "
+ DIRECT_INST = "Please ensure that your output only contains the final answer without any additional content (such as intermediate reasoning steps)."
+ MCQ_FMT = "{context}\n\n{question}\n\n{options}\n\nAnswer with the option's letter from the given choices. "
+ OPEN_FMT = "{context}\n\n{question}\n\nAnswer the question using a single word or phrase. "
+
+ DATASET_URL = {
+ 'EMMA': 'https://opencompass.openxlab.space/utils/VLMEval/EMMA.tsv',
+ 'EMMA_COT': 'https://opencompass.openxlab.space/utils/VLMEval/EMMA.tsv'
+ }
+
+ def build_prompt(self, line):
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ if self.meta_only:
+ tgt_path = toliststr(line['image_path'])
+ else:
+ tgt_path = self.dump_image(line)
+
+ context = line['context']
+ question = line['question']
+ example = ""
+ res_dict = {}
+ if line['type'] == 'MCQ':
+ for ch in string.ascii_uppercase:
+ if ch in line and not pd.isna(line[ch]):
+ example += f"{ch}: {line[ch]}\n"
+
+ prompt_tmpl = EMMADataset.MCQ_FMT
+ if not pd.isna(context) and context is not None:
+ prompt = prompt_tmpl.format(context=context, question=question, options=example)
+ else:
+ prompt = prompt_tmpl.split('{context}\n\n')[1].format(question=question, options=example)
+ prompt += EMMADataset.COT_INST if 'COT' in self.dataset_name else EMMADataset.DIRECT_INST
+ else:
+ prompt_tmpl = EMMADataset.OPEN_FMT
+ if not pd.isna(context) and context is not None:
+ prompt = prompt_tmpl.format(context=context, question=question)
+ else:
+ prompt = prompt_tmpl.split('{context}\n\n')[1].format(question=question)
+ prompt += EMMADataset.COT_INST if 'COT' in self.dataset_name else EMMADataset.DIRECT_INST
+
+ msgs = []
+ if isinstance(tgt_path, list):
+ msgs.extend([dict(type='image', value=p) for p in tgt_path])
+ else:
+ msgs = [dict(type='image', value=tgt_path)]
+ msgs.append(dict(type='text', value=prompt))
+ return MMMUDataset.split_MMMU(msgs)
diff --git a/vlmeval/dataset/image_base.py b/vlmeval/dataset/image_base.py
new file mode 100644
index 0000000000000000000000000000000000000000..e13d136dd5ec723ea5f9838c172ea16c7704d3dc
--- /dev/null
+++ b/vlmeval/dataset/image_base.py
@@ -0,0 +1,175 @@
+import pandas as pd
+from abc import abstractmethod
+from ..smp import *
+
+
+def img_root_map(dataset):
+ if 'MM_NIAH' in dataset:
+ return 'MMNIAH'
+ if 'CRPE' in dataset:
+ return 'CRPE'
+ if 'OCRVQA' in dataset:
+ return 'OCRVQA'
+ if 'COCO_VAL' == dataset:
+ return 'COCO'
+ if 'MMMU' in dataset:
+ return 'MMMU'
+ if "QSpatial" in dataset:
+ return "QSpatial"
+
+ mmbench_root_map = {
+ 'MMBench_DEV_EN': 'MMBench', 'MMBench_TEST_EN': 'MMBench',
+ 'MMBench_DEV_CN': 'MMBench', 'MMBench_TEST_CN': 'MMBench',
+ 'MMBench': 'MMBench', 'MMBench_CN': 'MMBench',
+ 'MMBench_DEV_EN_V11': 'MMBench_V11', 'MMBench_TEST_EN_V11': 'MMBench_V11',
+ 'MMBench_DEV_CN_V11': 'MMBench_V11', 'MMBench_TEST_CN_V11': 'MMBench_V11',
+ 'MMBench_V11': 'MMBench', 'MMBench_CN_V11': 'MMBench',
+ }
+ if dataset in mmbench_root_map:
+ return mmbench_root_map[dataset]
+ return dataset
+
+
+class ImageBaseDataset:
+
+ MODALITY = 'IMAGE'
+ DATASET_URL = {}
+ DATASET_MD5 = {}
+
+ def __init__(self, dataset='MMBench', skip_noimg=True):
+ ROOT = LMUDataRoot()
+ # You can override this variable to save image files to a different directory
+ self.dataset_name = dataset
+ self.img_root = osp.join(ROOT, 'images', img_root_map(dataset))
+
+ data = self.load_data(dataset)
+ self.skip_noimg = skip_noimg
+ if skip_noimg and 'image' in data:
+ data = data[~pd.isna(data['image'])]
+
+ data['index'] = [str(x) for x in data['index']]
+
+ self.meta_only = True
+
+ # The image field can store the base64 encoded image or another question index (for saving space)
+ if 'image' in data:
+ data['image'] = [str(x) for x in data['image']]
+ image_map = {x: y for x, y in zip(data['index'], data['image'])}
+ for k in image_map:
+ if len(image_map[k]) <= 64:
+ idx = image_map[k]
+ assert idx in image_map and len(image_map[idx]) > 64
+ image_map[k] = image_map[idx]
+
+ images = [toliststr(image_map[k]) for k in data['index']]
+ data['image'] = [x[0] if len(x) == 1 else x for x in images]
+ self.meta_only = False
+
+ if 'image_path' in data:
+ paths = [toliststr(x) for x in data['image_path']]
+ data['image_path'] = [x[0] if len(x) == 1 else x for x in paths]
+
+ if np.all([istype(x, int) for x in data['index']]):
+ data['index'] = [int(x) for x in data['index']]
+
+ self.data = data
+ self.post_build(dataset)
+
+ def __len__(self):
+ return len(self.data)
+
+ def __getitem__(self, idx):
+ return dict(self.data.iloc[idx])
+
+ def prepare_tsv(self, url, file_md5=None):
+ data_root = LMUDataRoot()
+ os.makedirs(data_root, exist_ok=True)
+ update_flag = False
+ file_name = url.split('/')[-1]
+ data_path = osp.join(data_root, file_name)
+ self.data_path=data_path
+ if osp.exists(data_path) and (file_md5 is None or md5(data_path) == file_md5):
+ pass
+ else:
+ warnings.warn('The dataset tsv is not downloaded')
+ download_file(url, data_path)
+ update_flag = True
+
+ if file_size(data_path, 'GB') > 1:
+ local_path = data_path.replace('.tsv', '_local.tsv')
+ if not osp.exists(local_path) or os.environ.get('FORCE_LOCAL', None) or update_flag:
+ from ..tools import LOCALIZE
+ LOCALIZE(data_path, local_path)
+ data_path = local_path
+ return load(data_path)
+
+ def dump_image(self, line):
+ os.makedirs(self.img_root, exist_ok=True)
+
+ if 'image' in line:
+ if isinstance(line['image'], list):
+ tgt_path = []
+ assert 'image_path' in line
+ for img, im_name in zip(line['image'], line['image_path']):
+ path = osp.join(self.img_root, im_name)
+ if not read_ok(path):
+ decode_base64_to_image_file(img, path)
+ tgt_path.append(path)
+ else:
+ tgt_path = osp.join(self.img_root, f"{line['index']}.jpg")
+ if not read_ok(tgt_path):
+ decode_base64_to_image_file(line['image'], tgt_path)
+ tgt_path = [tgt_path]
+ else:
+ assert 'image_path' in line
+ tgt_path = toliststr(line['image_path'])
+
+ return tgt_path
+
+ def display(self, line):
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+ assert isinstance(line, pd.Series) or isinstance(line, dict)
+ mmqa_display(line)
+
+ # Return a list of dataset names that are supported by this class, can override
+ @classmethod
+ def supported_datasets(cls):
+ return list(cls.DATASET_URL)
+
+ # Given the dataset name, return the dataset as a pandas dataframe, can override
+ def load_data(self, dataset):
+ url = self.DATASET_URL.get(dataset, None)
+ if url is None or url == '':
+ url = dataset + '.tsv'
+ file_md5 = self.DATASET_MD5[dataset] if dataset in self.DATASET_MD5 else None
+ return self.prepare_tsv(url, file_md5)
+
+ # Post built hook, will be called after the dataset is built, can override
+ def post_build(self, dataset):
+ pass
+
+ # Given one data record, return the built prompt (a multi-modal message), can override
+ def build_prompt(self, line):
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ if self.meta_only:
+ tgt_path = toliststr(line['image_path'])
+ else:
+ tgt_path = self.dump_image(line)
+
+ question = line['question']
+
+ msgs = []
+ if isinstance(tgt_path, list):
+ msgs.extend([dict(type='image', value=p) for p in tgt_path])
+ else:
+ msgs = [dict(type='image', value=tgt_path)]
+ msgs.append(dict(type='text', value=question))
+ return msgs
+
+ # Given the prediction file, return the evaluation results in the format of a dictionary or pandas dataframe
+ @abstractmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ pass
diff --git a/vlmeval/dataset/image_caption.py b/vlmeval/dataset/image_caption.py
new file mode 100644
index 0000000000000000000000000000000000000000..23282805c8d63047c57d02266cec21b48e191196
--- /dev/null
+++ b/vlmeval/dataset/image_caption.py
@@ -0,0 +1,75 @@
+from .image_base import ImageBaseDataset
+from ..smp import *
+
+
+class COCO_Caption_Scorer():
+ def __init__(self, ref, gt):
+ from pycocoevalcap.bleu.bleu import Bleu
+ from pycocoevalcap.rouge.rouge import Rouge
+ from pycocoevalcap.cider.cider import Cider
+
+ self.ref = ref
+ self.gt = gt
+ print('setting up scorers...')
+ self.scorers = [
+ (Bleu(4), ['Bleu_1', 'Bleu_2', 'Bleu_3', 'Bleu_4']),
+ (Rouge(), 'ROUGE_L'),
+ (Cider(), 'CIDEr'),
+ ]
+
+ def compute_scores(self):
+ total_scores = {}
+ for scorer, method in self.scorers:
+ print('computing %s score...' % (scorer.method()))
+ score, scores = scorer.compute_score(self.gt, self.ref)
+ if isinstance(method, list):
+ for sc, scs, m in zip(score, scores, method):
+ print('%s: %0.3f' % (m, sc * 100))
+ total_scores['Bleu'] = [x * 100 for x in score]
+ else:
+ print('%s: %0.3f' % (method, score * 100))
+ total_scores[method] = score * 100
+
+ print('*****DONE*****')
+ for key, value in total_scores.items():
+ print('{}:{}'.format(key, value))
+ return total_scores
+
+
+class ImageCaptionDataset(ImageBaseDataset):
+
+ TYPE = 'Caption'
+
+ DATASET_URL = {
+ 'COCO_VAL': 'https://opencompass.openxlab.space/utils/VLMEval/COCO_VAL.tsv',
+ }
+
+ DATASET_MD5 = {
+ 'COCO_VAL': '72a5079dead060269ac222c5aa5128af',
+ }
+
+ def load_data(self, dataset):
+ data = super().load_data(dataset)
+ if 'question' not in data:
+ data['question'] = [(
+ 'Please describe this image in general. Directly provide the description, '
+ 'do not include prefix like "This image depicts". '
+ )] * len(data)
+ return data
+
+ # It returns a dictionary of scores
+ @classmethod
+ def evaluate(self, eval_file, **kwargs):
+ data = load(eval_file)
+ lt = len(data)
+ lines = [data.iloc[i] for i in range(lt)]
+ ref, gt = {}, {}
+ for i, line in enumerate(lines):
+ ref[str(i)] = [str(line['prediction'])]
+ gt[str(i)] = eval(line['answer'])
+
+ scorer = COCO_Caption_Scorer(ref, gt)
+ coco_caption_score_dict = scorer.compute_scores()
+ score_pth = eval_file.replace('.xlsx', '_score.json')
+ dump(coco_caption_score_dict, score_pth)
+ return coco_caption_score_dict
diff --git a/vlmeval/dataset/image_ccocr.py b/vlmeval/dataset/image_ccocr.py
new file mode 100644
index 0000000000000000000000000000000000000000..aa1d7e26edcf77fd216fa13ce41d6c8ba00f4106
--- /dev/null
+++ b/vlmeval/dataset/image_ccocr.py
@@ -0,0 +1,197 @@
+# flake8: noqa
+
+import os
+import re
+import tempfile
+from functools import partial
+import pandas as pd
+
+from .image_base import ImageBaseDataset
+from ..smp import *
+
+# should be the same as FAIL_MSG definded in vlmeval/inference.py
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+class CCOCRDataset(ImageBaseDataset):
+ TYPE = 'VQA'
+ DATASET_URL_MODELSCOPE = {
+ "CCOCR_DocParsing_DocPhotoChn": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/doc_parsing/doc/doc_photo_chn_75.tsv",
+ "CCOCR_DocParsing_DocPhotoEng": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/doc_parsing/doc/doc_photo_eng_75.tsv",
+ "CCOCR_DocParsing_DocScanChn": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/doc_parsing/doc/doc_scan_chn_75.tsv",
+ "CCOCR_DocParsing_DocScanEng": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/doc_parsing/doc/doc_scan_eng_75.tsv",
+ "CCOCR_DocParsing_TablePhotoChn": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/doc_parsing/table/table_photo_chn_75.tsv",
+ "CCOCR_DocParsing_TablePhotoEng": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/doc_parsing/table/table_photo_eng_75.tsv",
+ "CCOCR_DocParsing_TableScanChn": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/doc_parsing/table/table_scan_chn_75.tsv",
+ "CCOCR_DocParsing_TableScanEng": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/doc_parsing/table/table_scan_eng_75.tsv",
+ "CCOCR_DocParsing_MolecularHandwriting": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/doc_parsing/molecular/molecular_handwriting_100.tsv",
+ "CCOCR_DocParsing_FormulaHandwriting": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/doc_parsing/formula/formula_handwriting_100.tsv",
+ "CCOCR_Kie_Sroie2019Word": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/kie/constrained_category/sroie2019_word_347.tsv",
+ "CCOCR_Kie_Cord": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/kie/constrained_category/CORD_100.tsv",
+ "CCOCR_Kie_EphoieScut": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/kie/constrained_category/EPHOIE_SCUT_311.tsv",
+ "CCOCR_Kie_Poie": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/kie/constrained_category/POIE_250.tsv",
+ "CCOCR_Kie_ColdSibr": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/kie/open_category/COLD_SIBR_400.tsv",
+ "CCOCR_Kie_ColdCell": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/kie/open_category/COLD_CELL_600.tsv",
+ "CCOCR_MultiLanOcr_Arabic": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/multi_lan_ocr/Arabic/Arabic_150.tsv",
+ "CCOCR_MultiLanOcr_French": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/multi_lan_ocr/French/French_150.tsv",
+ "CCOCR_MultiLanOcr_German": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/multi_lan_ocr/German/German_150.tsv",
+ "CCOCR_MultiLanOcr_Italian": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/multi_lan_ocr/Italian/Italian_150.tsv",
+ "CCOCR_MultiLanOcr_Japanese": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/multi_lan_ocr/Japanese/Japanese_150.tsv",
+ "CCOCR_MultiLanOcr_Korean": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/multi_lan_ocr/Korean/Korean_150.tsv",
+ "CCOCR_MultiLanOcr_Portuguese": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/multi_lan_ocr/Portuguese/Portuguese_150.tsv",
+ "CCOCR_MultiLanOcr_Russian": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/multi_lan_ocr/Russian/Russian_150.tsv",
+ "CCOCR_MultiLanOcr_Spanish": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/multi_lan_ocr/Spanish/Spanish_150.tsv",
+ "CCOCR_MultiLanOcr_Vietnamese": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/multi_lan_ocr/Vietnamese/Vietnamese_150.tsv",
+ "CCOCR_MultiSceneOcr_Cord": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/multi_scene_ocr/document_text/CORD_100.tsv",
+ "CCOCR_MultiSceneOcr_Funsd": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/multi_scene_ocr/document_text/FUNSD_50.tsv",
+ "CCOCR_MultiSceneOcr_Iam": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/multi_scene_ocr/document_text/IAM_50.tsv",
+ "CCOCR_MultiSceneOcr_ZhDoc": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/multi_scene_ocr/document_text/zh_doc_100.tsv",
+ "CCOCR_MultiSceneOcr_ZhHandwriting": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/multi_scene_ocr/document_text/zh_handwriting_50.tsv",
+ "CCOCR_MultiSceneOcr_Hieragent": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/multi_scene_ocr/scene_text/Hieragent_100.tsv",
+ "CCOCR_MultiSceneOcr_Ic15": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/multi_scene_ocr/scene_text/IC15_500.tsv",
+ "CCOCR_MultiSceneOcr_Inversetext": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/multi_scene_ocr/scene_text/InverseText_500.tsv",
+ "CCOCR_MultiSceneOcr_Totaltext": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/multi_scene_ocr/scene_text/TotalText_300.tsv",
+ "CCOCR_MultiSceneOcr_ZhScene": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/multi_scene_ocr/scene_text/zh_scene_450.tsv",
+ "CCOCR_MultiSceneOcr_UgcLaion": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/multi_scene_ocr/ugc_text/ugc_laion_400.tsv",
+ "CCOCR_MultiSceneOcr_ZhDense": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/multi_scene_ocr/ugc_text/zh_dense_50.tsv",
+ "CCOCR_MultiSceneOcr_ZhVertical": "https://www.modelscope.cn/datasets/Qwen/CC-OCR/resolve/master/multi_scene_ocr/ugc_text/zh_vertical_100.tsv"
+ }
+
+ DATASET_URL_HUGGINGFACE = {
+ "CCOCR_DocParsing_DocPhotoChn": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/doc_parsing/doc/doc_photo_chn_75.tsv",
+ "CCOCR_DocParsing_DocPhotoEng": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/doc_parsing/doc/doc_photo_eng_75.tsv",
+ "CCOCR_DocParsing_DocScanChn": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/doc_parsing/doc/doc_scan_chn_75.tsv",
+ "CCOCR_DocParsing_DocScanEng": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/doc_parsing/doc/doc_scan_eng_75.tsv",
+ "CCOCR_DocParsing_TablePhotoChn": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/doc_parsing/table/table_photo_chn_75.tsv",
+ "CCOCR_DocParsing_TablePhotoEng": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/doc_parsing/table/table_photo_eng_75.tsv",
+ "CCOCR_DocParsing_TableScanChn": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/doc_parsing/table/table_scan_chn_75.tsv",
+ "CCOCR_DocParsing_TableScanEng": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/doc_parsing/table/table_scan_eng_75.tsv",
+ "CCOCR_DocParsing_MolecularHandwriting": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/doc_parsing/molecular/molecular_handwriting_100.tsv",
+ "CCOCR_DocParsing_FormulaHandwriting": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/doc_parsing/formula/formula_handwriting_100.tsv",
+ "CCOCR_Kie_Sroie2019Word": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/kie/constrained_category/sroie2019_word_347.tsv",
+ "CCOCR_Kie_Cord": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/kie/constrained_category/CORD_100.tsv",
+ "CCOCR_Kie_EphoieScut": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/kie/constrained_category/EPHOIE_SCUT_311.tsv",
+ "CCOCR_Kie_Poie": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/kie/constrained_category/POIE_250.tsv",
+ "CCOCR_Kie_ColdSibr": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/kie/open_category/COLD_SIBR_400.tsv",
+ "CCOCR_Kie_ColdCell": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/kie/open_category/COLD_CELL_600.tsv",
+ "CCOCR_MultiLanOcr_Arabic": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/multi_lan_ocr/Arabic/Arabic_150.tsv",
+ "CCOCR_MultiLanOcr_French": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/multi_lan_ocr/French/French_150.tsv",
+ "CCOCR_MultiLanOcr_German": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/multi_lan_ocr/German/German_150.tsv",
+ "CCOCR_MultiLanOcr_Italian": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/multi_lan_ocr/Italian/Italian_150.tsv",
+ "CCOCR_MultiLanOcr_Japanese": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/multi_lan_ocr/Japanese/Japanese_150.tsv",
+ "CCOCR_MultiLanOcr_Korean": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/multi_lan_ocr/Korean/Korean_150.tsv",
+ "CCOCR_MultiLanOcr_Portuguese": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/multi_lan_ocr/Portuguese/Portuguese_150.tsv",
+ "CCOCR_MultiLanOcr_Russian": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/multi_lan_ocr/Russian/Russian_150.tsv",
+ "CCOCR_MultiLanOcr_Spanish": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/multi_lan_ocr/Spanish/Spanish_150.tsv",
+ "CCOCR_MultiLanOcr_Vietnamese": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/multi_lan_ocr/Vietnamese/Vietnamese_150.tsv",
+ "CCOCR_MultiSceneOcr_Cord": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/multi_scene_ocr/document_text/CORD_100.tsv",
+ "CCOCR_MultiSceneOcr_Funsd": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/multi_scene_ocr/document_text/FUNSD_50.tsv",
+ "CCOCR_MultiSceneOcr_Iam": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/multi_scene_ocr/document_text/IAM_50.tsv",
+ "CCOCR_MultiSceneOcr_ZhDoc": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/multi_scene_ocr/document_text/zh_doc_100.tsv",
+ "CCOCR_MultiSceneOcr_ZhHandwriting": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/multi_scene_ocr/document_text/zh_handwriting_50.tsv",
+ "CCOCR_MultiSceneOcr_Hieragent": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/multi_scene_ocr/scene_text/Hieragent_100.tsv",
+ "CCOCR_MultiSceneOcr_Ic15": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/multi_scene_ocr/scene_text/IC15_500.tsv",
+ "CCOCR_MultiSceneOcr_Inversetext": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/multi_scene_ocr/scene_text/InverseText_500.tsv",
+ "CCOCR_MultiSceneOcr_Totaltext": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/multi_scene_ocr/scene_text/TotalText_300.tsv",
+ "CCOCR_MultiSceneOcr_ZhScene": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/multi_scene_ocr/scene_text/zh_scene_450.tsv",
+ "CCOCR_MultiSceneOcr_UgcLaion": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/multi_scene_ocr/ugc_text/ugc_laion_400.tsv",
+ "CCOCR_MultiSceneOcr_ZhDense": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/multi_scene_ocr/ugc_text/zh_dense_50.tsv",
+ "CCOCR_MultiSceneOcr_ZhVertical": "https://huggingface.co/datasets/wulipc/CC-OCR/resolve/main/multi_scene_ocr/ugc_text/zh_vertical_100.tsv"
+ }
+
+ # define data path
+ DATASET_URL = DATASET_URL_MODELSCOPE
+ DATASET_MD5 = {
+ "CCOCR_DocParsing_DocPhotoChn": "9039dcbb31830d413261a95cfa29d97f",
+ "CCOCR_DocParsing_DocPhotoEng": "2ca0824881e1d7317626f2a19d902989",
+ "CCOCR_DocParsing_DocScanChn": "9e265c8aa760ebdf5c3bf9e892d55492",
+ "CCOCR_DocParsing_DocScanEng": "77d04637be3def86dbc2ce37ba64a704",
+ "CCOCR_DocParsing_TablePhotoChn": "c4dc85252ddad2b43a03a67b1d1ae983",
+ "CCOCR_DocParsing_TablePhotoEng": "02ab75d6169da0cd2ece9ce0ae14a479",
+ "CCOCR_DocParsing_TableScanChn": "f1f79959fdd01127df7377c9d46722f2",
+ "CCOCR_DocParsing_TableScanEng": "794903c7acf52bfe956eefba2166d14b",
+ "CCOCR_DocParsing_MolecularHandwriting": "30b7f7679b713ce000a939eca7b4078f",
+ "CCOCR_DocParsing_FormulaHandwriting": "e03047776ce5e79a61ae1c057e2a348e",
+ "CCOCR_Kie_Sroie2019Word": "3287d99a8e86a99b74171fa5a70f9acb",
+ "CCOCR_Kie_Cord": "ab297cadcbc7158884a301c366f3330a",
+ "CCOCR_Kie_EphoieScut": "bb8fa3ba7ea91cbf17be0904956ad3f3",
+ "CCOCR_Kie_Poie": "882b64317989ecbfed6518051cdffb14",
+ "CCOCR_Kie_ColdSibr": "109d5dad8b7081fb6a2f088e963196d4",
+ "CCOCR_Kie_ColdCell": "7b44c45b4d7d768d1dbdc08872fe7d3a",
+ "CCOCR_MultiLanOcr_Arabic": "e9a3f2bb9298d0b882ebc7a98980c3f3",
+ "CCOCR_MultiLanOcr_French": "729407ed2036c22e602eff645eddd40c",
+ "CCOCR_MultiLanOcr_German": "96fc2edae747f0ec95b0a6f9bf723022",
+ "CCOCR_MultiLanOcr_Italian": "29a508fa5d5a5e767497dd69e2430ebb",
+ "CCOCR_MultiLanOcr_Japanese": "bbcca96ccf25fff63597c2ab4f3ebb1f",
+ "CCOCR_MultiLanOcr_Korean": "0f55dbd24eba5edc189c91e124411641",
+ "CCOCR_MultiLanOcr_Portuguese": "a6fcf8831775a61aa631c0cf1c422ae7",
+ "CCOCR_MultiLanOcr_Russian": "19d2f84062a1699d3e9333912bd6b303",
+ "CCOCR_MultiLanOcr_Spanish": "f5a0cfa9f2ae4115c91c7b362034e591",
+ "CCOCR_MultiLanOcr_Vietnamese": "bf1cd4e83d91767f4906f81550cec8b9",
+ "CCOCR_MultiSceneOcr_Cord": "92943f0ccb4c5a196c574222e76759a0",
+ "CCOCR_MultiSceneOcr_Funsd": "229cc38d193edd00f4383610e98ee873",
+ "CCOCR_MultiSceneOcr_Iam": "d897a6d6c3880c65e752ec11b211204c",
+ "CCOCR_MultiSceneOcr_ZhDoc": "303682cc16c8bb51b2b896f8ceb8bd38",
+ "CCOCR_MultiSceneOcr_ZhHandwriting": "faa298d366bc05e5cfb39e334afb8eff",
+ "CCOCR_MultiSceneOcr_Hieragent": "6f132cdd0473d7cc145c3e3a08957dd6",
+ "CCOCR_MultiSceneOcr_Ic15": "3d94869f312a41d53d0578a06a2fb1f2",
+ "CCOCR_MultiSceneOcr_Inversetext": "e141d424a0c4cf9579064428a270f13d",
+ "CCOCR_MultiSceneOcr_Totaltext": "ca1daf81d49eeb57ef844b72a23c2e62",
+ "CCOCR_MultiSceneOcr_ZhScene": "9295152a66e6f117db8bfbb20a9013e6",
+ "CCOCR_MultiSceneOcr_UgcLaion": "8e9ea1fbf9d56532157e807eabf39b21",
+ "CCOCR_MultiSceneOcr_ZhDense": "de8f48ee0c8a2cf8ed7f2b3a81e6322d",
+ "CCOCR_MultiSceneOcr_ZhVertical": "4892b4aec6e7fd11e39aaea23712709b"
+ }
+
+ # It returns a DataFrame
+ def evaluate(self, eval_file, **judge_kwargs):
+ """
+ """
+ df = load(eval_file)
+ dict_list = df.to_dict(orient='records')
+
+ required_colume_list = ['answer', 'prediction', "category", "image_name", "l2-category", "split"]
+ for required_colume in required_colume_list:
+ assert required_colume in df, "required_colume: {} NOT found".format(required_colume)
+
+ gt_info, ptd_info = {}, {}
+ for data_info in dict_list:
+ image_name = data_info['image_name']
+ gt_info[image_name] = data_info['answer']
+
+ # warning the FAIL samples
+ if data_info['prediction'] != FAIL_MSG:
+ ptd_info[image_name] = data_info['prediction']
+
+ # assert eval_file is a single dataset
+ group_name = set([str(x) for x in df['category']]).pop()
+ op_name = set([str(x) for x in df['l2-category']]).pop()
+ data_name = set([str(x) for x in df['split']]).pop()
+
+ data_info = {"op": op_name, "group": group_name, "dataset": data_name, "num": len(gt_info)}
+ try:
+ from .utils.ccocr_evaluator import evaluator_map_info as ccocr_evaluator_map
+ except ImportError as err:
+ import warnings
+ warnings.warn('The dependency of CCOCR evaluator is not properly installed')
+ warnings.warn(f'{type(err)}: {err}')
+ eval_func = ccocr_evaluator_map.get(group_name, None)
+ if eval_func is None:
+ raise ValueError("error: evaluator not defined for: {}".format(group_name))
+ meta_info, eval_info = eval_func(ptd_info, gt_info, **data_info)
+
+ output_info = {"meta": meta_info, "evaluation": eval_info, "config": data_info}
+ result_file = os.path.splitext(os.path.abspath(eval_file))[0] + "_eval.json"
+ dump(output_info, result_file)
+
+ # update global status for summary
+ # warning: the evaluate function should NOT run in parallel
+ all_status_info = {}
+ global_status_path = os.path.join(os.path.dirname(eval_file), "status.json")
+ if os.path.exists(global_status_path):
+ with open(global_status_path, "r") as f:
+ all_status_info = json.load(f)
+ all_status_info[data_name] = output_info
+ with open(global_status_path, "w") as f:
+ json.dump(all_status_info, f, ensure_ascii=False, indent=4)
+ return eval_info.get("summary")
diff --git a/vlmeval/dataset/image_mcq.py b/vlmeval/dataset/image_mcq.py
new file mode 100644
index 0000000000000000000000000000000000000000..95f08a3b2544789696509310f932c7e78a2efb30
--- /dev/null
+++ b/vlmeval/dataset/image_mcq.py
@@ -0,0 +1,1185 @@
+import warnings
+
+from .image_base import ImageBaseDataset
+from .utils import build_judge, DEBUG_MESSAGE
+from ..smp import *
+import pandas as pd
+
+MMMB_URLS = {
+ 'MMMB_ar': 'https://huggingface.co/datasets/AIDC-AI/Parrot-dataset/resolve/main/mmmb/mmmb_ar.tsv',
+ 'MMMB_cn': 'https://huggingface.co/datasets/AIDC-AI/Parrot-dataset/resolve/main/mmmb/mmmb_cn.tsv',
+ 'MMMB_en': 'https://huggingface.co/datasets/AIDC-AI/Parrot-dataset/resolve/main/mmmb/mmmb_en.tsv',
+ 'MMMB_pt': 'https://huggingface.co/datasets/AIDC-AI/Parrot-dataset/resolve/main/mmmb/mmmb_pt.tsv',
+ 'MMMB_ru': 'https://huggingface.co/datasets/AIDC-AI/Parrot-dataset/resolve/main/mmmb/mmmb_ru.tsv',
+ 'MMMB_tr': 'https://huggingface.co/datasets/AIDC-AI/Parrot-dataset/resolve/main/mmmb/mmmb_tr.tsv',
+}
+
+MTL_MMBench_URLS = {
+ 'MMBench_dev_ar': 'https://huggingface.co/datasets/AIDC-AI/Parrot-dataset/resolve/main/mmbench/mmbench_dev_ar.tsv',
+ 'MMBench_dev_cn': 'https://huggingface.co/datasets/AIDC-AI/Parrot-dataset/resolve/main/mmbench/mmbench_dev_cn.tsv',
+ 'MMBench_dev_en': 'https://huggingface.co/datasets/AIDC-AI/Parrot-dataset/resolve/main/mmbench/mmbench_dev_en.tsv',
+ 'MMBench_dev_pt': 'https://huggingface.co/datasets/AIDC-AI/Parrot-dataset/resolve/main/mmbench/mmbench_dev_pt.tsv',
+ 'MMBench_dev_tr': 'https://huggingface.co/datasets/AIDC-AI/Parrot-dataset/resolve/main/mmbench/mmbench_dev_tr.tsv',
+ 'MMBench_dev_ru': 'https://huggingface.co/datasets/AIDC-AI/Parrot-dataset/resolve/main/mmbench/mmbench_dev_ru.tsv',
+}
+
+MMMB_MD5 = {
+ 'MMMB_ar': 'f3a18b6385f1d9701840aa42de27aead', 'MMMB_cn': '13ed82fa89730037292fcaa27f08f430',
+ 'MMMB_en': '1cd781a71ec5a2983c090b84105d6a01', 'MMMB_pt': '548ea2b3bb2da991790386f0015d30d1',
+ 'MMMB_ru': 'ce1cc8a0533425ab0d86b326ebfc2984', 'MMMB_tr': '0733739d43090327975294292bc5cd67'
+}
+
+MTL_MMBench_MD5 = {
+ 'MMBench_dev_ar': '4271b4a0d0200e1a86380a878e0d64a4', 'MMBench_dev_cn': '2ed5135326fed02c8e51ea50dda8222f',
+ 'MMBench_dev_en': 'd9ab776fc018b3d45785e9a5c23431c2', 'MMBench_dev_pt': '4ddfbcd27ef12444b908c03831cd0295',
+ 'MMBench_dev_tr': '4fab39d501389d3d6cc90264bb708f11', 'MMBench_dev_ru': '5ba1171ff2e68f80637bf78349e402a5'
+}
+
+
+class ImageMCQDataset(ImageBaseDataset):
+
+ TYPE = 'MCQ'
+
+ DATASET_URL = {
+ # MMBench v1.0
+ 'MMBench_DEV_EN': 'https://opencompass.openxlab.space/utils/benchmarks/MMBench/MMBench_DEV_EN.tsv',
+ 'MMBench_TEST_EN': 'https://opencompass.openxlab.space/utils/benchmarks/MMBench/MMBench_TEST_EN.tsv',
+ 'MMBench_DEV_CN': 'https://opencompass.openxlab.space/utils/benchmarks/MMBench/MMBench_DEV_CN.tsv',
+ 'MMBench_TEST_CN': 'https://opencompass.openxlab.space/utils/benchmarks/MMBench/MMBench_TEST_CN.tsv',
+ 'MMBench': 'https://opencompass.openxlab.space/utils/benchmarks/MMBench/MMBench.tsv', # Internal
+ 'MMBench_CN': 'https://opencompass.openxlab.space/utils/benchmarks/MMBench/MMBench_CN.tsv', # Internal
+ # MMBench v1.1
+ 'MMBench_DEV_EN_V11': 'https://opencompass.openxlab.space/utils/benchmarks/MMBench/MMBench_DEV_EN_V11.tsv',
+ 'MMBench_TEST_EN_V11': 'https://opencompass.openxlab.space/utils/benchmarks/MMBench/MMBench_TEST_EN_V11.tsv',
+ 'MMBench_DEV_CN_V11': 'https://opencompass.openxlab.space/utils/benchmarks/MMBench/MMBench_DEV_CN_V11.tsv',
+ 'MMBench_TEST_CN_V11': 'https://opencompass.openxlab.space/utils/benchmarks/MMBench/MMBench_TEST_CN_V11.tsv',
+ 'MMBench_V11': 'https://opencompass.openxlab.space/utils/benchmarks/MMBench/MMBench_V11.tsv', # Internal
+ 'MMBench_CN_V11': 'https://opencompass.openxlab.space/utils/benchmarks/MMBench/MMBench_CN_V11.tsv', # Internal
+ # SEEDBench Series
+ 'SEEDBench_IMG': 'https://opencompass.openxlab.space/utils/benchmarks/SEEDBench/SEEDBench_IMG.tsv',
+ 'SEEDBench2': 'https://huggingface.co/datasets/VLMEval/SEEDBench2/resolve/main/SEEDBench2.tsv',
+ 'SEEDBench2_Plus': 'https://opencompass.openxlab.space/utils/benchmarks/SEEDBench/SEEDBench2_Plus.tsv',
+ # ScienceQA Series
+ 'ScienceQA_VAL': 'https://opencompass.openxlab.space/utils/benchmarks/ScienceQA/ScienceQA_VAL.tsv',
+ 'ScienceQA_TEST': 'https://opencompass.openxlab.space/utils/benchmarks/ScienceQA/ScienceQA_TEST.tsv',
+ # MMT-Bench
+ 'MMT-Bench_ALL_MI': 'https://opencompass.openxlab.space/utils/benchmarks/MMT-Bench/MMT-Bench_ALL_MI.tsv',
+ 'MMT-Bench_ALL': 'https://opencompass.openxlab.space/utils/benchmarks/MMT-Bench/MMT-Bench_ALL.tsv',
+ 'MMT-Bench_VAL_MI': 'https://opencompass.openxlab.space/utils/benchmarks/MMT-Bench/MMT-Bench_VAL_MI.tsv',
+ 'MMT-Bench_VAL': 'https://opencompass.openxlab.space/utils/benchmarks/MMT-Bench/MMT-Bench_VAL.tsv',
+ # AesBench
+ 'AesBench_VAL': 'https://huggingface.co/datasets/VLMEval/AesBench/resolve/main/AesBench_VAL.tsv',
+ 'AesBench_TEST': 'https://huggingface.co/datasets/VLMEval/AesBench/resolve/main/AesBench_TEST.tsv',
+ # Q-Bench1
+ 'Q-Bench1_VAL': 'https://huggingface.co/datasets/zhangzicheng/qbench_tsv/resolve/main/Q-Bench1_VAL.tsv',
+ 'Q-Bench1_TEST': 'https://huggingface.co/datasets/zhangzicheng/qbench_tsv/resolve/main/Q-Bench1_TEST.tsv',
+ # A-Bench
+ 'A-Bench_VAL': 'https://huggingface.co/datasets/zhangzicheng/abench_tsv/resolve/main/A-bench_VAL.tsv',
+ 'A-Bench_TEST': 'https://huggingface.co/datasets/zhangzicheng/abench_tsv/resolve/main/A-bench_TEST.tsv',
+ # R-Bench
+ 'R-Bench-Dis': 'https://huggingface.co/datasets/lcysyzxdxc/R-Bench/blob/main/R-bench-dis.tsv',
+ 'R-Bench-Ref': 'https://huggingface.co/datasets/lcysyzxdxc/R-Bench/blob/main/R-bench-ref.tsv',
+ # Other Benchmarks
+ 'CCBench': 'https://opencompass.openxlab.space/utils/VLMEval/CCBench.tsv',
+ 'AI2D_TEST': 'https://opencompass.openxlab.space/utils/VLMEval/AI2D_TEST.tsv',
+ 'AI2D_TEST_NO_MASK': 'https://opencompass.openxlab.space/utils/VLMEval/AI2D_TEST_NO_MASK.tsv',
+ 'MMStar': 'https://opencompass.openxlab.space/utils/VLMEval/MMStar.tsv',
+ 'RealWorldQA': 'https://opencompass.openxlab.space/utils/VLMEval/RealWorldQA.tsv',
+ 'MLLMGuard_DS': 'https://opencompass.openxlab.space/utils/VLMEval/MLLMGuard_DS.tsv',
+ 'BLINK': 'https://opencompass.openxlab.space/utils/VLMEval/BLINK.tsv',
+ 'TaskMeAnything_v1_imageqa_random': (
+ 'https://huggingface.co/datasets/weikaih/TaskMeAnything-v1-imageqa-random/'
+ 'resolve/main/TaskMeAnything-v1-imageqa-random.tsv'
+ ),
+ 'A-OKVQA': 'https://huggingface.co/datasets/Allen8/A-OKVQA/resolve/main/a-okvqa.tsv',
+ 'WorldMedQA-V': 'https://opencompass.openxlab.space/utils/VLMEval/WorldMedQA-V.tsv',
+ 'VisOnlyQA-VLMEvalKit': (
+ 'https://huggingface.co/datasets/ryokamoi/VisOnlyQA_Eval_Real/'
+ 'resolve/main/visonlyqa_vlmevalkit.tsv'
+ ),
+ '3DSRBench': (
+ 'https://huggingface.co/datasets/ccvl/3DSRBench/'
+ 'resolve/main/3dsrbench_v1_vlmevalkit_circular.tsv'
+ ),
+ # For Internal Use Only
+ 'MMBench_V11_MINI': 'https://opencompass.openxlab.space/utils/TEST/MMBench_V11_MINI.tsv',
+ 'MMStar_MINI': 'https://opencompass.openxlab.space/utils/TEST/MMStar_MINI.tsv',
+ 'AI2D_MINI': 'https://opencompass.openxlab.space/utils/TEST/AI2D_MINI.tsv',
+ }
+
+ DATASET_MD5 = {
+ # MMBench v1.0
+ 'MMBench_DEV_EN': 'b6caf1133a01c6bb705cf753bb527ed8',
+ 'MMBench_TEST_EN': '6939fadb0ce626fefc0bdc9c64efc528',
+ 'MMBench_DEV_CN': '08b8fc3324a5ed74155350f57be69fbd',
+ 'MMBench_TEST_CN': '7e1239baf0ee4c8b513e19705a0f317e',
+ 'MMBench': '4115aea3383f3dd0083be6a633e0f820', # Internal Only
+ 'MMBench_CN': '2e053ffc90ea598b1feae13c36dc13ee', # Internal Only
+ # MMBench v1.1
+ 'MMBench_DEV_EN_V11': '30c05be8f2f347a50be25aa067248184',
+ 'MMBench_TEST_EN_V11': '26f0f15381a21720255091d3e0316ce6',
+ 'MMBench_DEV_CN_V11': '593f9b5f6bea453d870a798b34ae4f37',
+ 'MMBench_TEST_CN_V11': '74bbe4556dac745613c7cbe5ad787050',
+ 'MMBench_V11': 'b9276414f57af1308dcc4d0cd9b42e7c', # Internal Only
+ 'MMBench_CN_V11': '95f6980dd1b4de38e3cbffe0305a3f25', # Internal Only
+ # SEEDBench
+ 'SEEDBench_IMG': '68017231464752261a2526d6ca3a10c0',
+ 'SEEDBench2': '4ec15cf864c4f16274112284f531813e',
+ 'SEEDBench2_Plus': '7cb2323950d71f049df70e5162062af3',
+ # ScienceQA
+ 'ScienceQA_VAL': '96320d05e142e585e7204e72affd29f3',
+ 'ScienceQA_TEST': 'e42e9e00f9c59a80d8a5db35bc32b71f',
+ # MMT-Bench
+ 'MMT-Bench_ALL_MI': '5272157097e19cdd7cb41e412ab3b7c7',
+ 'MMT-Bench_ALL': 'b273a2f4c596fe4f2605de0494cd632f',
+ 'MMT-Bench_VAL_MI': 'c7d7b998eb5cd9aa36c7d4f721472462',
+ 'MMT-Bench_VAL': '8dd4b730f53dbf9c3aed90ca31c928e0',
+ # AesBench
+ 'AesBench_VAL': '3edb0c319e9187aa0b97fe7a11700a8c',
+ 'AesBench_TEST': '58b1f7ba2cc32e1d68896d6ee716bbf8',
+ # Q-Bench1
+ 'Q-Bench1_VAL': '837bdb6cd2da571713543462815187b7',
+ 'Q-Bench1_TEST': '15e759bfd58c9d5f30b23a317d347153',
+ # A-Bench
+ 'A-Bench_VAL': '218563ec50d34bb336c814143a5bb9c1',
+ 'A-Bench_TEST': '567013fb033a20cf23f51d8e865bd16c',
+ # R-Bench
+ 'R-Bench-Dis': 'd6e961dbfc43350688af2560226830b4',
+ 'R-Bench-Ref': '270c1cb555acb523f3fdb178ed57021d',
+ # Other Benchmarks
+ 'CCBench': 'f5dde47f24dc5a6fb6e595b409b466ac',
+ 'AI2D_TEST': '0f593e0d1c7df9a3d69bf1f947e71975',
+ 'AI2D_TEST_NO_MASK': 'fd8f463634d4fe9fbd23b876e8eea5be',
+ 'MMStar': 'e1ecd2140806c1b1bbf54b43372efb9e',
+ 'RealWorldQA': '4de008f55dc4fd008ca9e15321dc44b7',
+ 'MLLMGuard_DS': '975fc0dd7119386e198c37d71e274b3f',
+ 'BLINK': '3b6649b6a662184ea046908e5506260e',
+ 'TaskMeAnything_v1_imageqa_random': '023fef69e2ca21827afb77c5ec3bc889',
+ 'WorldMedQA-V': '441e63875e30c87f5750528b57b41285',
+ "VisOnlyQA-VLMEvalKit": 'cf460a31d2acb8d3a7cecd0e69298bfa',
+ '3DSRBench': '13a99f33164dc1b9faf0e8b8b01fd6f2',
+ }
+
+ DATASET_URL.update(MMMB_URLS)
+ DATASET_URL.update(MTL_MMBench_URLS)
+ DATASET_MD5.update(MMMB_MD5)
+ DATASET_MD5.update(MTL_MMBench_MD5)
+
+ def build_prompt(self, line):
+
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ if self.meta_only:
+ tgt_path = toliststr(line['image_path'])
+ else:
+ tgt_path = self.dump_image(line)
+
+ question = line['question']
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ options_prompt = 'Options:\n'
+ for key, item in options.items():
+ options_prompt += f'{key}. {item}\n'
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ prompt = ''
+ if hint is not None:
+ prompt += f'Hint: {hint}\n'
+ prompt += f'Question: {question}\n'
+ if len(options):
+ prompt += options_prompt
+ prompt += 'Please select the correct answer from the options above. \n'
+
+ msgs = []
+ if isinstance(tgt_path, list):
+ msgs.extend([dict(type='image', value=p) for p in tgt_path])
+ else:
+ msgs = [dict(type='image', value=tgt_path)]
+ msgs.append(dict(type='text', value=prompt))
+
+ return msgs
+
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.multiple_choice import report_acc, report_acc_MMT, mcq_circular_eval, mcq_vanilla_eval
+ # assert dataset is not None
+ dataset_map = {
+ 'MMBench_TEST_EN': 'MMBench', 'MMBench_TEST_EN_V11': 'MMBench_V11',
+ 'MMBench_TEST_CN': 'MMBench_CN', 'MMBench_TEST_CN_V11': 'MMBench_CN_V11'
+ }
+ dataset = self.dataset_name
+ if dataset in dataset_map:
+ dataset = dataset_map[dataset]
+ nproc = judge_kwargs.pop('nproc', 4)
+
+ circular = False
+ if listinstr(['mmbench', 'ccbench', 'circular'], dataset.lower()):
+ data = load(eval_file)
+ data['index'] = [int(x) for x in data['index']]
+ dump(data, eval_file)
+ circular = True
+
+ suffix = eval_file.split('.')[-1]
+ model = judge_kwargs.get('model', 'exact_matching')
+ assert model in ['chatgpt-0125', 'exact_matching', 'gpt-4-0125']
+ name_str_map = {'chatgpt-0125': 'openai', 'gpt-4-0125': 'gpt4'}
+ name_str = name_str_map[model] if model in name_str_map else model
+
+ if model == 'exact_matching':
+ model = None
+ elif gpt_key_set():
+ model = build_judge(**judge_kwargs)
+ if not model.working():
+ warnings.warn('OPENAI API is not working properly, will use exact matching for evaluation')
+ warnings.warn(DEBUG_MESSAGE)
+ model = None
+ else:
+ warnings.warn('OPENAI_API_KEY is not set properly, will use exact matching for evaluation')
+ model = None
+
+ result_file = eval_file.replace(f'.{suffix}', f'_{name_str}_result.pkl')
+
+ data = load(eval_file)
+ data = data.sort_values(by='index')
+ data['prediction'] = [str(x) for x in data['prediction']]
+ # If not choice label, then use lower case
+ for k in data.keys():
+ data[k.lower() if k not in list(string.ascii_uppercase) else k] = data.pop(k)
+
+ meta = self.data
+ meta_q_map = {x: y for x, y in zip(meta['index'], meta['question'])}
+ data_map = {x: y for x, y in zip(data['index'], data['question'])}
+ for k in data_map:
+ assert k in meta_q_map, (
+ f'eval_file should be the same as or a subset of dataset {self.dataset_name}'
+ )
+
+ if circular:
+ data = mcq_circular_eval(model, data, meta, nproc, result_file, self.dataset_name)
+ else:
+ data = mcq_vanilla_eval(model, data, meta, nproc, result_file, self.dataset_name)
+
+ # load split
+ dump(data, eval_file.replace(f'.{suffix}', f'_{name_str}_result.{suffix}'))
+ data = load(eval_file.replace(f'.{suffix}', f'_{name_str}_result.{suffix}'))
+
+ # May have different report acc functions for different datasets
+ if 'MMT' in dataset:
+ acc = report_acc_MMT(data)
+ else:
+ acc = report_acc(data)
+
+ score_file = eval_file.replace(f'.{suffix}', '_acc.csv')
+ dump(acc, score_file)
+
+ if dataset == 'AesBench_VAL':
+ warnings.warn('Note that AesBench VAL is just a toy version of AesBench TEST. For full results, \
+ please evaluate on AesBench TEST. The AesBench TEST dataset is more than 20 times \
+ larger than the VAL dataset and the leaderboard results are based on AesBench TEST.')
+ if dataset == 'VisOnlyQA-VLMEvalKit':
+ warnings.warn('Note that the results on VisOnlyQA-VLMEvalKit are different from the results on \
+ the original VisOnlyQA. VisOnlyQA-VLMEvalKit does not include the \
+ chemistry__shape_multi split and uses a different evaluation prompt. Please \
+ explicitly specify the version of the dataset when you report results.')
+
+ return acc
+
+
+class MMMUDataset(ImageMCQDataset):
+
+ DATASET_URL = {
+ 'MMMU_DEV_VAL': 'https://opencompass.openxlab.space/utils/VLMEval/MMMU_DEV_VAL.tsv',
+ 'MMMU_TEST': 'https://opencompass.openxlab.space/utils/VLMEval/MMMU_TEST.tsv',
+ }
+
+ DATASET_MD5 = {
+ 'MMMU_DEV_VAL': '585e8ad75e73f75dcad265dfd0417d64',
+ 'MMMU_TEST': 'c19875d11a2d348d07e5eb4bdf33166d',
+ }
+
+ @staticmethod
+ def split_MMMU(msgs):
+ text, images = None, []
+ for s in msgs:
+ if s['type'] == 'image':
+ images.append(s['value'])
+ elif s['type'] == 'text':
+ assert text is None
+ text = s['value']
+ text_segs = text.split(''
+ image_idx = int(seg[0]) - 1
+ segs.append(dict(type='image', value=images[image_idx]))
+ segs.append(dict(type='text', value=seg[2:]))
+ return segs
+
+ def build_prompt(self, line):
+ msgs = super().build_prompt(line)
+ msgs = self.split_MMMU(msgs)
+ return msgs
+
+
+class MMMUProDataset(MMMUDataset):
+
+ TYPE = 'MCQ_MMMU_Pro'
+
+ def __init__(self, **kwargs):
+ super().__init__(**kwargs)
+ if 'MMMU_Pro_V' in self.dataset_name:
+ self.data['question'] = ['placeholder'] * len(self.data)
+
+ DATASET_URL = {
+ 'MMMU_Pro_10c': 'https://opencompass.openxlab.space/utils/VLMEval/MMMU_Pro_10c.tsv',
+ 'MMMU_Pro_10c_COT': 'https://opencompass.openxlab.space/utils/VLMEval/MMMU_Pro_10c.tsv',
+ 'MMMU_Pro_V': 'https://opencompass.openxlab.space/utils/VLMEval/MMMU_Pro_V.tsv',
+ 'MMMU_Pro_V_COT': 'https://opencompass.openxlab.space/utils/VLMEval/MMMU_Pro_V.tsv',
+ }
+
+ DATASET_MD5 = {
+ 'MMMU_Pro_10c': '22cee868fe6b680d14b99bfff6db8172',
+ 'MMMU_Pro_10c_COT': '22cee868fe6b680d14b99bfff6db8172',
+ 'MMMU_Pro_V': 'd01441a87b3dbe721b5a04652ae38009',
+ 'MMMU_Pro_V_COT': 'd01441a87b3dbe721b5a04652ae38009',
+ }
+
+ def build_prompt(self, line):
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ if self.meta_only:
+ tgt_path = toliststr(line['image_path'])
+ else:
+ tgt_path = self.dump_image(line)
+
+ if 'MMMU_Pro_V' in self.dataset_name:
+ question = 'Answer the following multiple-choice question in the image. '
+ if 'COT' in self.dataset_name:
+ question += (
+ "The last line of your response should be of the following format: 'Answer: $LETTER' "
+ "(without quotes) where LETTER is one of the options. Think step by step before answering. "
+ )
+ else:
+ question += "Answer directly with the option letter from the given choices. "
+ if isinstance(tgt_path, list):
+ assert len(tgt_path) == 1
+ tgt_path = tgt_path[0]
+ return [dict(type='image', value=tgt_path), dict(type='text', value=question)]
+ else:
+ question = line['question']
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ options_prompt = 'Options:\n'
+ for key, item in options.items():
+ options_prompt += f'{key}. {item}\n'
+ prompt = ''
+ prompt += f'Question: {question}\n'
+ if len(options):
+ prompt += options_prompt
+ if 'COT' in self.dataset_name:
+ prompt += (
+ "Answer the following multiple-choice question. The last line of your response should be of "
+ "the following format: 'Answer: $LETTER' (without quotes) where LETTER is one of the options. "
+ "Think step by step before answering. "
+ )
+ else:
+ prompt += "Answer directly with the option letter from the given choices. "
+
+ msgs = []
+ if isinstance(tgt_path, list):
+ msgs.extend([dict(type='image', value=p) for p in tgt_path])
+ else:
+ msgs = [dict(type='image', value=tgt_path)]
+ msgs.append(dict(type='text', value=prompt))
+ msgs = self.split_MMMU(msgs)
+ return msgs
+
+ def cot_postproc(self, response):
+ lines = response.strip().split('\n')
+ lines = [x.strip() for x in lines]
+ cands = [x for x in lines if x.startswith('Answer:')]
+ if len(cands) == 1:
+ counter = defaultdict(lambda: 0)
+ for ch in cands[0]:
+ if ch in string.ascii_uppercase:
+ counter[ch] += 1
+ if len(counter) == 1:
+ return list(counter.keys())[0]
+ else:
+ return cands[0][7:]
+ return response
+
+ def evaluate(self, eval_file, **judge_kwargs):
+ if 'COT' in self.dataset_name:
+ data = load(eval_file)
+ data['prediction'] = [self.cot_postproc(x) for x in data['prediction']]
+ tgt = eval_file.replace('.xlsx', '_cotpost.xlsx')
+ dump(data, tgt)
+ res = super().evaluate(tgt, **judge_kwargs)
+ acc_org = eval_file.replace('.xlsx', '_acc.csv')
+ acc_now = eval_file.replace('.xlsx', '_cotpost_acc.csv')
+ shutil.copy(acc_now, acc_org)
+ return res
+ else:
+ return super().evaluate(eval_file, **judge_kwargs)
+
+
+class MUIRDataset(ImageMCQDataset):
+
+ DATASET_URL = {
+ 'MUIRBench': 'http://opencompass.openxxlab.com/utils/VLMEval/MUIRBench.tsv'
+ }
+
+ DATASET_MD5 = {
+ 'MUIRBench': '2e5e6fd7699761b08a7cb3ab8c0c2ec8'
+ }
+
+ @staticmethod
+ def split_MUIR(msgs):
+ text, images = None, []
+
+ # Separate images and text from msgs
+ for s in msgs:
+ if s['type'] == 'image':
+ images.append(s['value'])
+ elif s['type'] == 'text':
+ assert text is None # Ensure only one text entry is expected
+ text = s['value']
+
+ # Split text by tags
+ text_segs = text.split('')
+
+ # Initialize the segments list
+ segs = []
+
+ # Iterate through the text segments and images
+ for i, seg in enumerate(text_segs):
+ # Append the image if this is not the first segment and there are still images left
+ if i > 0 and i - 1 < len(images):
+ segs.append(dict(type='image', value=images[i - 1]))
+ # Append the text segment (if it's non-empty)
+ if len(seg) > 0:
+ segs.append(dict(type='text', value=seg))
+
+ return segs
+
+ def build_prompt(self, line):
+
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ if self.meta_only:
+ tgt_path = toliststr(line['image_path'])
+ else:
+ tgt_path = self.dump_image(line)
+
+ question = line['question']
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ # options_prompt = ''
+ options_prompt = '\n'.join([f'{key}. {item}' for key, item in options.items()])
+ # for key, item in options.items():
+ # options_prompt += f'{key}. {item}\n'
+
+ prompt = ''
+
+ prompt += f'{question}\n'
+ if len(options):
+ prompt += options_prompt
+ prompt += "\nAnswer with the option's letter from the given choices directly."
+
+ msgs = []
+ if isinstance(tgt_path, list):
+ msgs.extend([dict(type='image', value=p) for p in tgt_path])
+ else:
+ msgs = [dict(type='image', value=tgt_path)]
+ msgs.append(dict(type='text', value=prompt))
+
+ msgs = self.split_MUIR(msgs)
+ return msgs
+
+
+class GMAIMMBenchDataset(ImageMCQDataset):
+
+ DATASET_URL = {
+ 'GMAI-MMBench_VAL': 'https://huggingface.co/datasets/VLMEval/GMAI-MMBench/resolve/main/GMAI-MMBench_VAL.tsv',
+ 'GMAI_mm_bench_TEST_part_1': 'https://huggingface.co/datasets/OpenGVLab/GMAI-MMBench/resolve/main/GMAI_mm_bench_TEST_part_1.tsv', # noqa: E501
+ 'GMAI_mm_bench_TEST_part_2': 'https://huggingface.co/datasets/OpenGVLab/GMAI-MMBench/resolve/main/GMAI_mm_bench_TEST_part_2.tsv', # noqa: E501
+ 'GMAI_mm_bench_TEST_part_3': 'https://huggingface.co/datasets/OpenGVLab/GMAI-MMBench/resolve/main/GMAI_mm_bench_TEST_part_3.tsv', # noqa: E501
+ 'GMAI_mm_bench_TEST_part_4': 'https://huggingface.co/datasets/OpenGVLab/GMAI-MMBench/resolve/main/GMAI_mm_bench_TEST_part_4.tsv', # noqa: E501
+ 'GMAI_mm_bench_TEST_part_5': 'https://huggingface.co/datasets/OpenGVLab/GMAI-MMBench/resolve/main/GMAI_mm_bench_TEST_part_5.tsv', # noqa: E501
+ 'GMAI_mm_bench_TEST_part_6': 'https://huggingface.co/datasets/OpenGVLab/GMAI-MMBench/resolve/main/GMAI_mm_bench_TEST_part_6.tsv', # noqa: E501
+ 'GMAI_mm_bench_TEST_part_7': 'https://huggingface.co/datasets/OpenGVLab/GMAI-MMBench/resolve/main/GMAI_mm_bench_TEST_part_7.tsv', # noqa: E501
+ 'GMAI_mm_bench_TEST_part_8': 'https://huggingface.co/datasets/OpenGVLab/GMAI-MMBench/resolve/main/GMAI_mm_bench_TEST_part_8.tsv', # noqa: E501
+ 'GMAI_mm_bench_TEST_part_9': 'https://huggingface.co/datasets/OpenGVLab/GMAI-MMBench/resolve/main/GMAI_mm_bench_TEST_part_9.tsv', # noqa: E501
+ 'GMAI_mm_bench_TEST_part_10': 'https://huggingface.co/datasets/OpenGVLab/GMAI-MMBench/resolve/main/GMAI_mm_bench_TEST_part_10.tsv', # noqa: E501
+ 'GMAI_mm_bench_TEST_part_11': 'https://huggingface.co/datasets/OpenGVLab/GMAI-MMBench/resolve/main/GMAI_mm_bench_TEST_part_11.tsv', # noqa: E501
+ }
+
+ DATASET_MD5 = {
+ 'GMAI-MMBench_VAL': '254bd581627866f1c499d3d6b4422324',
+ 'GMAI_mm_bench_TEST_part_1': '900d735231230a63f4ed45665c078ef4',
+ 'GMAI_mm_bench_TEST_part_2': '1b27ab621386945d7e4a765ad2d22b0e',
+ 'GMAI_mm_bench_TEST_part_3': '44bdc2b6267dd505d529b8cad06f0fb2',
+ 'GMAI_mm_bench_TEST_part_4': '5a04a04fcac9f1466709f242fdb80acb',
+ 'GMAI_mm_bench_TEST_part_5': 'c70baf8909eda9af0ddeab275c721336',
+ 'GMAI_mm_bench_TEST_part_6': '825abc39596b644dead9350d0cfa3b96',
+ 'GMAI_mm_bench_TEST_part_7': 'defb8aed2fb77365a76b6b9abd6a2701',
+ 'GMAI_mm_bench_TEST_part_8': 'ff490d60b85f2bb0abb67a435b298c65',
+ 'GMAI_mm_bench_TEST_part_9': 'ff67c86f40da93b09139ac1d1ba5dc6b',
+ 'GMAI_mm_bench_TEST_part_10': '3dae94627b9ac0fe00180d4780fbf6dc',
+ 'GMAI_mm_bench_TEST_part_11': 'd08dc813f0eb6bbab63cae2a9d113c4b',
+ }
+
+ @classmethod
+ def supported_datasets(cls):
+ return ['GMAI-MMBench_VAL', 'GMAI-MMBench_TEST']
+
+ def load_data(self, dataset):
+ if dataset == 'GMAI-MMBench_VAL':
+ data_path = osp.join(LMUDataRoot(), f'{dataset}.tsv')
+ if file_size(data_path, 'GB') > 1:
+ local_path = data_path.replace('.tsv', '_local.tsv')
+ if not osp.exists(local_path) or os.environ.get('FORCE_LOCAL'):
+ from ..tools import LOCALIZE
+ LOCALIZE(data_path, local_path)
+ data_path = local_path
+ return load(data_path)
+ elif dataset == 'GMAI-MMBench_TEST':
+ dfs = []
+ for part_num in range(1, 12):
+ part_name = f'GMAI_mm_bench_TEST_part_{part_num}'
+ url = self.DATASET_URL[part_name]
+ file_md5 = self.DATASET_MD5.get(part_name)
+ tsv_path = osp.join(LMUDataRoot(), f'{part_name}.tsv')
+ if not osp.exists(tsv_path) or (file_md5 and md5(tsv_path) != file_md5):
+ download_file(url, filename=tsv_path)
+ local_path = tsv_path.replace('.tsv', '_local.tsv')
+ if not osp.exists(local_path) or os.environ.get('FORCE_LOCAL'):
+ from ..tools import LOCALIZE
+ LOCALIZE(tsv_path, local_path)
+ tsv_path = local_path
+ # 加载数据
+ df = load(tsv_path)
+ dfs.append(df)
+ # 合并所有数据
+ data = pd.concat(dfs, ignore_index=True)
+ return data
+ else:
+ raise ValueError(f"未知的数据集：{dataset}")
+
+ def report_acc_by_groups(self, df, group_column):
+ res = defaultdict(list)
+
+ # Check for the 'split' column
+ if 'split' in df:
+ splits = list(set(df['split']))
+ res['split'] = splits
+ else:
+ df['split'] = ['none'] * len(df)
+ res['split'] = ['none']
+
+ res['Overall'] = [np.mean(df[df['split'] == sp]['hit']) for sp in res['split']]
+
+ if group_column not in df:
+ raise ValueError(f"Column '{group_column}' not found in dataframe.") # noqa: E713
+
+ abilities = list(set(df[group_column]))
+ abilities = ['None' if isinstance(ab, float) and pd.isna(ab) else ab for ab in abilities]
+ abilities.sort()
+
+ for ab in abilities:
+ ab_name = ab
+ sub_df = df[df[group_column] == ab]
+ res[ab_name] = [np.mean(sub_df[sub_df['split'] == sp]['hit']) for sp in res['split']]
+
+ return pd.DataFrame(res)
+
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.multiple_choice import report_acc, mcq_vanilla_eval
+ nproc = judge_kwargs.pop('nproc', 4)
+
+ suffix = eval_file.split('.')[-1]
+ model = judge_kwargs.get('model', 'exact_matching')
+ assert model in ['chatgpt-0125', 'exact_matching', 'gpt-4-0125']
+ name_str_map = {'chatgpt-0125': 'openai', 'gpt-4-0125': 'gpt4'}
+ name_str = name_str_map[model] if model in name_str_map else model
+
+ if model == 'exact_matching':
+ model = None
+ elif gpt_key_set():
+ model = build_judge(**judge_kwargs)
+ if not model.working():
+ warnings.warn('OPENAI API is not working properly, will use exact matching for evaluation')
+ warnings.warn(DEBUG_MESSAGE)
+ model = None
+ else:
+ warnings.warn('OPENAI_API_KEY is not set properly, will use exact matching for evaluation')
+ model = None
+
+ result_file = eval_file.replace(f'.{suffix}', f'_{name_str}_result.pkl')
+
+ data = load(eval_file)
+ data = data.sort_values(by='index')
+ data['prediction'] = [str(x) for x in data['prediction']]
+ # If not choice label, then use lower case
+ for k in data.keys():
+ data[k.lower() if k not in list(string.ascii_uppercase) else k] = data.pop(k)
+
+ meta = self.data
+ meta_q_map = {x: y for x, y in zip(meta['index'], meta['question'])}
+ data_map = {x: y for x, y in zip(data['index'], data['question'])}
+ for k in data_map:
+ assert k in meta_q_map, (
+ f'eval_file should be the same as or a subset of dataset {self.dataset_name}'
+ )
+
+ data = mcq_vanilla_eval(model, data, meta, nproc, result_file, self.dataset_name)
+
+ # load split
+ dump(data, eval_file.replace(f'.{suffix}', f'_{name_str}_result.{suffix}'))
+ data = load(eval_file.replace(f'.{suffix}', f'_{name_str}_result.{suffix}'))
+
+ acc = report_acc(data)
+
+ for group_col in ['clinical vqa task', 'department', 'perceptual granularity']:
+ acc_grouped = self.report_acc_by_groups(data, group_col)
+ score_file_grouped = eval_file.replace(f'.{suffix}', f'_{group_col}_acc.csv')
+ dump(acc_grouped, score_file_grouped)
+
+ return acc
+
+
+class MMERealWorld(ImageMCQDataset):
+
+ TYPE = 'MMERealWorld'
+
+ DATASET_MD5 = {
+ 'MME-RealWorld': '271c33ec814c39533c467ec6fb8a6f36',
+ 'MME-RealWorld-Lite': '4c17057d7d3b6c4a0d4397c3dae0881c',
+ 'MME-RealWorld-CN': 'daaa763d52a760a38606d5dedb3fe444',
+ }
+ SYS = {
+ 'MME-RealWorld': (
+ 'Select the best answer to the above multiple-choice question based on the image. '
+ 'Respond with only the letter (A, B, C, D, or E) of the correct option. \n'
+ 'The best answer is:'
+ ),
+ 'MME-RealWorld-Lite': (
+ 'Select the best answer to the above multiple-choice question based on the image. '
+ 'Respond with only the letter (A, B, C, D, or E) of the correct option. \n'
+ 'The best answer is:'
+ ),
+ 'MME-RealWorld-CN': (
+ '根据图像选择上述多项选择题的最佳答案。只需回答正确选项的字母（A, B, C, D 或 E）。\n'
+ '最佳答案为：'
+ ),
+ }
+
+ @classmethod
+ def supported_datasets(cls):
+ return ['MME-RealWorld', 'MME-RealWorld-CN', 'MME-RealWorld-Lite',]
+
+ def load_data(
+ self, dataset="MME-RealWorld", repo_id="yifanzhang114/MME-RealWorld-Base64"
+ ):
+
+ def check_integrity(pth):
+ data_file = osp.join(pth, f"{dataset}.tsv")
+
+ if not os.path.exists(data_file):
+ return False
+
+ if md5(data_file) != self.DATASET_MD5[dataset]:
+ return False
+ return True
+
+ def generate_tsv(pth):
+ tsv_file = os.path.join(pth, f"{dataset}.tsv")
+
+ if os.path.exists(tsv_file):
+ print(f"{tsv_file} already exists.")
+ return
+
+ json_dir = os.path.join(pth, dataset)
+ json_files = [f for f in os.listdir(json_dir) if f.endswith(".json")]
+
+ data_list = []
+ for json_file in json_files:
+ with open(os.path.join(json_dir, json_file), "r") as f:
+ data = json.load(f)
+ for item in tqdm(data):
+ choice_prompt = (
+ "The choices are listed below:\n"
+ if dataset in ["MME-RealWorld", "MME-RealWorld-Lite"]
+ else "选项如下所示:\n"
+ )
+ data_list.append(
+ {
+ "index": item["index"],
+ "image": item["image"],
+ "question": item["question"],
+ "multi-choice options": choice_prompt
+ + "\n".join(item["multi-choice options"]),
+ "A": item["multi-choice options"][0][4:],
+ "B": item["multi-choice options"][1][4:],
+ "C": item["multi-choice options"][2][4:],
+ "D": item["multi-choice options"][3][4:],
+ "E": item["multi-choice options"][4][4:],
+ "answer": item["answer"],
+ "category": item["category"],
+ "l2-category": item["l2-category"],
+ }
+ )
+ df = pd.DataFrame(data_list)
+ df.to_csv(tsv_file, sep="\t", index=False)
+ print(f"TSV file saved to {tsv_file}")
+
+ # Check if dataset is cached and has integrity
+ if dataset == "MME-RealWorld-Lite":
+ url = 'https://huggingface.co/datasets/yifanzhang114/MME-RealWorld-Base64/resolve/main/mme_realworld_lite.tsv' # noqa: E501
+ file_md5 = (
+ self.DATASET_MD5[dataset] if dataset in self.DATASET_MD5 else None
+ )
+ datas = self.prepare_tsv(url, file_md5)
+ choice_prompt = "The choices are listed below:\n"
+ for index, item in datas.iterrows():
+ options = eval(item["multi-choice options"])
+ datas.loc[index, "multi-choice options"] = choice_prompt + "\n".join(
+ options
+ )
+ datas.loc[index, "A"] = options[0][4:]
+ datas.loc[index, "B"] = options[1][4:]
+ datas.loc[index, "C"] = options[2][4:]
+ datas.loc[index, "D"] = options[3][4:]
+ datas.loc[index, "E"] = options[4][4:]
+ return datas
+
+ update_flag = False
+ cache_path = get_cache_path(repo_id)
+ if cache_path is not None and check_integrity(cache_path):
+ dataset_path = cache_path
+ print(f"Using cached dataset from {cache_path}")
+ else:
+ from huggingface_hub import snapshot_download
+
+ # Download or find the dataset path
+ dataset_path = snapshot_download(repo_id=repo_id, repo_type="dataset")
+ generate_tsv(dataset_path)
+ update_flag = True
+
+ data_path = os.path.join(dataset_path, f"{dataset}.tsv")
+ if file_size(data_path, "GB") > 1:
+ local_path = data_path.replace(".tsv", "_local.tsv")
+ if (
+ not osp.exists(local_path)
+ or os.environ.get("FORCE_LOCAL", None)
+ or update_flag
+ ):
+ from vlmeval.tools import LOCALIZE
+
+ LOCALIZE(data_path, local_path)
+ data_path = local_path
+ return load(data_path)
+
+ def post_build(self, dataset):
+ self.TYPE = 'MMERealWorld'
+
+ # Given one data record, return the built prompt (a multi-modal message), can override
+ def build_prompt(self, line):
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ if self.meta_only:
+ tgt_path = toliststr(line['image_path'])
+ else:
+ tgt_path = self.dump_image(line)
+
+ question = line['question']
+
+ choice_prompt = line['multi-choice options'] + '\n'
+ question += ' ' + choice_prompt + self.SYS[self.dataset_name]
+
+ msgs = []
+ if isinstance(tgt_path, list):
+ msgs.extend([dict(type='image', value=p) for p in tgt_path])
+ else:
+ msgs = [dict(type='image', value=tgt_path)]
+ msgs.append(dict(type='text', value=question))
+ return msgs
+
+ # It returns a dictionary
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.multiple_choice import extract_characters_regex, get_dimension_rating
+ assert eval_file.endswith('.xlsx'), 'data file should be an xlsx file'
+ FAIL_MSG = 'Failed to obtain answer via API.'
+ tmp_file = eval_file.replace('.xlsx', '_tmp.pkl')
+ tgt_file = eval_file.replace('.xlsx', '_rating.json')
+ score_file = eval_file.replace('.xlsx', '_score.xlsx')
+
+ if not osp.exists(score_file):
+
+ res = {} if not osp.exists(tmp_file) else load(tmp_file)
+ res = {k: v for k, v in res.items() if FAIL_MSG not in v}
+
+ data = load(eval_file)
+ cnt_rejected = 0
+ data_un = data[~pd.isna(data['prediction'])]
+
+ for idx in data['index']:
+ ans = data.loc[data['index'] == idx, 'answer'].values[0]
+ pred = data.loc[data['index'] == idx, 'prediction'].values[0]
+
+ extract_pred = extract_characters_regex(pred)
+ if extract_pred == '':
+ cnt_rejected += 1
+ data.loc[data['index'] == idx, 'score'] = 0
+ else:
+ data.loc[data['index'] == idx, 'score'] = int(extract_pred == ans)
+
+ print(
+ f'Among {len(data)} questions, failed to obtain prediction for {len(data) - len(data_un)} questions, '
+ f'failed to obtain the score for another {cnt_rejected} questions. '
+ f'Those questions will be counted as 0 score in ALL rating.'
+ )
+
+ dump(data, score_file)
+
+ rating = get_dimension_rating(score_file)
+ dump(rating, tgt_file)
+ return rating
+
+
+class HRBenchDataset(ImageMCQDataset):
+
+ DATASET_URL = {
+ 'HRBench4K': 'https://huggingface.co/datasets/DreamMr/HR-Bench/resolve/main/hr_bench_4k.tsv',
+ 'HRBench8K': 'https://huggingface.co/datasets/DreamMr/HR-Bench/resolve/main/hr_bench_8k.tsv',
+ }
+
+ DATASET_MD5 = {
+ 'HRBench4K': 'f6b041b03d49543494b8a56d2e35be65',
+ 'HRBench8K': '274c9c7f89329b804a4723178a00219c',
+ }
+
+ def evaluate(self, eval_file, **judge_kwargs):
+ assert os.path.exists(eval_file), '{} does not exist!'.format(eval_file)
+ from .utils.multiple_choice import mcq_vanilla_eval
+ from .utils.hrbench import report_acc_hrbench
+ nproc = judge_kwargs.pop('nproc', 4)
+
+ suffix = eval_file.split('.')[-1]
+ model = judge_kwargs.get('model', 'extract_matching')
+ assert model in ['chatgpt-0125', 'exact_matching', 'gpt-4-0125']
+ name_str_map = {'chatgpt-0125': 'openai', 'gpt-4-0125': 'gpt4'}
+ name_str = name_str_map[model] if model in name_str_map else model
+
+ if model == 'exact_matching':
+ model = None
+ elif gpt_key_set():
+ model = build_judge(**judge_kwargs)
+ if not model.working():
+ warnings.warn('OPENAI API is not working properly, will use exact matching for evaluation')
+ warnings.warn(DEBUG_MESSAGE)
+ model = None
+ else:
+ warnings.warn('OPENAI_API_KEY is not set properly, will use exact matching for evaluation')
+ model = None
+
+ result_file = eval_file.replace(f'.{suffix}', f'_{name_str}_result.pkl')
+
+ data = load(eval_file)
+ data = data.sort_values(by='index')
+ data['prediction'] = [str(x) for x in data['prediction']]
+ # If not choice label, then use lower case
+ for k in data.keys():
+ data[k.lower() if k not in list(string.ascii_uppercase) else k] = data.pop(k)
+
+ meta = self.data
+ meta_q_map = {x: y for x, y in zip(meta['index'], meta['question'])}
+ data_map = {x: y for x, y in zip(data['index'], data['question'])}
+ for k in data_map:
+ assert k in meta_q_map, (
+ f'eval_file should be the same as or a subset of dataset {self.dataset_name}'
+ )
+
+ score_file = eval_file.replace(f'.{suffix}', '_acc.csv')
+
+ if osp.exists(score_file):
+ acc = load(score_file)
+ return acc
+ data = mcq_vanilla_eval(model, data, meta, nproc, result_file, self.dataset_name)
+ dump(data, eval_file.replace(f'.{suffix}', f'_{name_str}_result.{suffix}'))
+ data = load(eval_file.replace(f'.{suffix}', f'_{name_str}_result.{suffix}'))
+
+ acc = report_acc_hrbench(data)
+
+ score_file = eval_file.replace(f'.{suffix}', '_acc.csv')
+ dump(acc, score_file)
+
+ return acc
+
+
+class CustomMCQDataset(ImageMCQDataset):
+
+ def load_data(self, dataset):
+ data_path = osp.join(LMUDataRoot(), f'{dataset}.tsv')
+
+ if file_size(data_path, 'GB') > 1:
+ local_path = data_path.replace('.tsv', '_local.tsv')
+ if not osp.exists(local_path) or os.environ.get('FORCE_LOCAL', None):
+ from ..tools import LOCALIZE
+ LOCALIZE(data_path, local_path)
+ data_path = local_path
+ return load(data_path)
+
+
+class NaturalBenchDataset(ImageMCQDataset):
+
+ DATASET_URL = {
+ 'NaturalBenchDataset': (
+ 'https://huggingface.co/datasets/BaiqiL/'
+ 'NaturalBench/resolve/main/NaturalBenchDataset.tsv'
+ ),
+ }
+ DATASET_MD5 = {
+ 'NaturalBenchDataset':'dbe25b044bc35696426381e9ba4fe930',
+ }
+
+ def build_prompt(self, line):
+ SUFFIX_FOR_VQA = {
+ "yes_no": "Please answer Yes or No.",
+ "multiple_choice": "Please output the letter corresponding to the correct option."
+ }
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ if self.meta_only:
+ tgt_path = toliststr(line['image_path'])
+ else:
+ tgt_path = self.dump_image(line)
+
+ question = line['question']
+ prompt = f'{question} {SUFFIX_FOR_VQA[line["type"]]}'
+ msgs = []
+ if isinstance(tgt_path, list):
+ msgs.extend([dict(type='image', value=p) for p in tgt_path])
+ else:
+ msgs = [dict(type='image', value=tgt_path)]
+ msgs.append(dict(type='text', value=prompt))
+
+ return msgs
+
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.naturalbench import extract_answer, get_scores
+
+ data = load(eval_file)
+ data = data.sort_values(by='index')
+ predictions = [str(x) for x in data['prediction']]
+ answers = [str(x) for x in data['answer']]
+ indexs = [str(x) for x in data['index']]
+ meta = self.data
+ types = [str(x) for x in meta['type']]
+ results = {}
+ assert len(predictions) == len(answers) == len(indexs) == len(types) == (1900 * 4)
+ number_answered_samples = len(predictions) // 4
+ for i in range(number_answered_samples):
+ results[i] = {
+ "q0_i0": extract_answer(predictions[i * 4], types[i * 4]),
+ "q0_i1": extract_answer(predictions[i * 4 + 1], types[i * 4 + 1]),
+ "q1_i0": extract_answer(predictions[i * 4 + 2], types[i * 4 + 2]),
+ "q1_i1": extract_answer(predictions[i * 4 + 3], types[i * 4 + 3])
+ }
+
+ scores = get_scores(results)
+ print(scores)
+ score_file = 'NaturalBench_acc.csv'
+ df = pd.DataFrame(list(scores.items()), columns=['Metric', 'Score'])
+ dump(df, score_file)
+
+ return scores
+
+
+class WeMath(ImageBaseDataset):
+ TYPE = 'MCQ'
+ DATASET_URL = {
+ 'WeMath': 'https://opencompass.openxlab.space/utils/VLMEval/WeMath.tsv',
+ 'WeMath_COT': 'https://opencompass.openxlab.space/utils/VLMEval/WeMath.tsv',
+ }
+ DATASET_MD5 = {'WeMath': 'b5e969a075f01290a542411fb7766388',
+ 'WeMath_COT': 'b5e969a075f01290a542411fb7766388'}
+
+ def build_prompt(self, line):
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ if self.meta_only:
+ tgt_path = toliststr(line['image_path'])
+ else:
+ tgt_path = self.dump_image(line)
+
+ question = line['question']
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ options_prompt = 'Options:\n'
+ for key, item in options.items():
+ options_prompt += f'{key}. {item}\n'
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ prompt = ''
+ if hint is not None:
+ prompt += f'Hint: {hint}\n'
+ prompt += f'Question: {question}\n'
+ if len(options):
+ prompt += options_prompt
+
+ if 'COT' in self.dataset_name:
+ requirement = line['requirement']
+ if requirement is not None:
+ prompt += f'\n{requirement}'
+
+ msgs = []
+ if isinstance(tgt_path, list):
+ msgs.extend([dict(type='image', value=p) for p in tgt_path])
+ else:
+ msgs = [dict(type='image', value=tgt_path)]
+ msgs.append(dict(type='text', value=prompt))
+
+ return msgs
+
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.wemath import wemath_evaluate_models, wemath_accuracy
+ from .utils.multiple_choice import mcq_vanilla_eval
+
+ # model = judge_kwargs['model']
+ model = judge_kwargs.get('model', 'exact_matching')
+ assert model in ['exact_matching', 'gpt-4-0125', 'gpt-4-turbo', 'gpt-4o-mini'], model
+ name_str_map = {'gpt-4-0125': 'gpt4', 'gpt-4-turbo': 'gpt4-turbo', 'gpt-4o-mini': 'gpt4o-mini'}
+ name_str = name_str_map[model] if model in name_str_map else model
+
+ if model == 'exact_matching':
+ model = None
+ elif gpt_key_set():
+ model = build_judge(**judge_kwargs)
+ if not model.working():
+ warnings.warn('OPENAI API is not working properly, will use exact matching for evaluation')
+ warnings.warn(DEBUG_MESSAGE)
+ model = None
+ else:
+ warnings.warn('OPENAI_API_KEY is not set properly, will use exact matching for evaluation')
+ model = None
+
+ suffix = eval_file.split('.')[-1]
+ storage = eval_file.replace(f'.{suffix}', f'_{name_str}.xlsx')
+ nproc = judge_kwargs.pop('nproc', 4)
+
+ if not osp.exists(storage) and model is not None:
+ data = load(eval_file)
+ result_file = eval_file.replace(f'.{suffix}', f'_{name_str}_result.pkl')
+
+ data = load(eval_file)
+ data = data.sort_values(by='index')
+ data['prediction'] = [str(x) for x in data['prediction']]
+ # If not choice label, then use lower case
+ for k in data.keys():
+ data[k.lower() if k not in list(string.ascii_uppercase) else k] = data.pop(k)
+
+ meta = self.data
+ meta_q_map = {x: y for x, y in zip(meta['index'], meta['question'])}
+ data_map = {x: y for x, y in zip(data['index'], data['question'])}
+ for k in data_map:
+ assert k in meta_q_map, (
+ f'eval_file should be the same as or a subset of dataset {self.dataset_name}'
+ )
+ data = mcq_vanilla_eval(model, data, meta, nproc, result_file, self.dataset_name)
+
+ if 'id' in data.columns:
+ # 更改列名
+ data.rename(columns={'id': 'ID'}, inplace=True)
+ dump(data, storage)
+ if osp.exists(storage):
+ accuracy_scores = wemath_evaluate_models(storage)
+ four_dim_scores = wemath_accuracy(storage)
+ else:
+ accuracy_scores = wemath_evaluate_models(eval_file)
+ four_dim_scores = wemath_accuracy(eval_file)
+ combine_score = {**accuracy_scores, **four_dim_scores}
+ combine_score = pd.DataFrame(combine_score)
+ score_pth = storage.replace('.xlsx', '_score.csv')
+ dump(combine_score, score_pth)
+ return combine_score
+
+class VMCBenchDataset(ImageBaseDataset):
+
+ TYPE = 'MCQ'
+
+ DATASET_URL = {
+ 'VMCBench_DEV': 'https://huggingface.co/datasets/suyc21/VMCBench/resolve/main/data/tsv/VMCBench_DEV.tsv',
+ 'VMCBench_TEST': 'https://huggingface.co/datasets/suyc21/VMCBench/resolve/main/data/tsv/VMCBench_TEST.tsv'
+ }
+
+ DATASET_MD5 = {
+ }
+ def build_prompt(self, line):
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ if self.meta_only:
+ tgt_path = toliststr(line['image_path'])
+ else:
+ tgt_path = self.dump_image(line)
+ question = line['question']
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ options_prompt = 'Options:\n'
+ for key, item in options.items():
+ options_prompt += f'{key}. {item}\n'
+ prompt = ''
+ prompt += f'Question: {question}\n'
+ if len(options):
+ prompt += options_prompt
+ prompt += "Answer with the option's letter from the given choices directly. \n"
+
+ msgs = []
+ if isinstance(tgt_path, list):
+ msgs.extend([dict(type='image', value=p) for p in tgt_path])
+ else:
+ msgs = [dict(type='image', value=tgt_path)]
+ msgs.append(dict(type='text', value=prompt))
+
+ return msgs
+
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.vmcbench import get_mc_score, report_vmc_acc
+ suffix = eval_file.split('.')[-1]
+ data = load(eval_file)
+ data = data.sort_values(by='index')
+ data['prediction'] = [str(x) for x in data['prediction']]
+ data['hit'] = data.apply(get_mc_score, axis=1)
+ result_file = eval_file.replace(f'.{suffix}', f'_result.{suffix}')
+ dump(data, result_file)
+ acc = report_vmc_acc(data)
+ score_file = eval_file.replace(f'.{suffix}', '_acc.csv')
+ dump(acc, score_file)
+
+ return acc
diff --git a/vlmeval/dataset/image_mt.py b/vlmeval/dataset/image_mt.py
new file mode 100644
index 0000000000000000000000000000000000000000..07658948a01c7e65d857794c92ef32e9c4b94f46
--- /dev/null
+++ b/vlmeval/dataset/image_mt.py
@@ -0,0 +1,128 @@
+from .image_base import ImageBaseDataset
+from .utils.judge_util import build_judge
+from ..smp import *
+from ..utils import track_progress_rich
+
+
+class ImageMTDataset(ImageBaseDataset):
+
+ TYPE = 'MT'
+
+ def build_prompt(self, line):
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ if self.meta_only:
+ tgt_path = toliststr(line['image_path'])
+ else:
+ tgt_path = self.dump_image(line)
+
+ questions = toliststr(line['question'])
+ if 'answer' in line:
+ answers = toliststr(line['answer'])
+ else:
+ answers = [''] * len(questions)
+ assert len(questions) == len(answers)
+
+ dlgs, pics_number = [], 0
+ for i in range(len(questions)):
+ q, a = questions[i], answers[i]
+ if '' in q:
+ content = []
+ tag_number = q.count('')
+ images = tgt_path[pics_number: pics_number + tag_number]
+ pics_number += tag_number
+ q_split = q.split('')
+ for i in range(tag_number):
+ qsp, im = q_split[i], images[i]
+ if qsp != '':
+ content.append(dict(type='text', value=qsp))
+ content.append(dict(type='image', value=im))
+ if q_split[-1] != '':
+ content.append(dict(type='text', value=q_split[-1]))
+ else:
+ content = [dict(type='text', value=q)]
+ dlgs.append(dict(role='user', content=content))
+ assert '' not in a, 'We currently do not support images in the answer. '
+ content = [dict(type='text', value=a)]
+ dlgs.append(dict(role='assistant', content=content))
+ return dlgs
+
+
+class MMDUDataset(ImageMTDataset):
+
+ DATASET_URL = {'MMDU': 'https://opencompass.openxlab.space/utils/VLMEval/MMDU.tsv'}
+ DATASET_MD5 = {'MMDU': '848b635a88a078f49aebcc6e39792061'}
+ DIMS = [
+ 'Creativity', 'Richness', 'Visual Perception', 'Logical Coherence',
+ 'Answer Accuracy', 'Image Relationship Understanding', 'Overall Score'
+ ]
+
+ def calculat_metric(self, ans):
+ all = defaultdict(lambda: 0)
+ tot = defaultdict(lambda: 0)
+ valid = defaultdict(lambda: 0)
+ for k in ans:
+ res = ans[k]['res']
+ assert isinstance(res, pd.DataFrame)
+ lt = len(res)
+ for i in range(lt):
+ line = res.iloc[i]
+ for k in self.DIMS:
+ tot[k] += 1
+ if k in line and line[k] is not None:
+ try:
+ score = int(line[k])
+ score = np.clip(score, 0, 10)
+ all[k] += score
+ valid[k] += 1
+ except Exception as e:
+ print(f'Failed to parse the score: {str(e)}')
+ sp1 = {'set': 'all'}
+ sp1.update({k: all[k] / tot[k] * 10 for k in self.DIMS})
+ sp2 = {'set': 'valid'}
+ sp2.update({k: all[k] / valid[k] * 10 for k in self.DIMS})
+
+ return pd.DataFrame([sp1, sp2])
+
+ def evaluate(self, eval_file, **judge_kwargs):
+ suffix = eval_file.split('.')[-1]
+ model = judge_kwargs['model']
+
+ tmp_file = eval_file.replace(f'.{suffix}', f'_{model}.pkl')
+ score_file = eval_file.replace(f'.{suffix}', f'_{model}_score.csv')
+ nproc = judge_kwargs.pop('nproc', 4)
+
+ data = load(eval_file)
+ model = judge_kwargs.pop('model', 'gpt-4o')
+ judge_model = build_judge(model=model, **judge_kwargs)
+
+ lt = len(data)
+ lines = [data.iloc[i] for i in range(lt)]
+ tups = [(judge_model, line) for line in lines]
+ indices = [line['index'] for line in lines]
+
+ ans = {}
+ if osp.exists(tmp_file):
+ ans = load(tmp_file)
+
+ tups = [x for x, i in zip(tups, indices) if i not in ans]
+ indices = [i for i in indices if i not in ans]
+
+ from .utils.mmdu import mmdu_score
+
+ if len(indices):
+ new_results = track_progress_rich(
+ mmdu_score,
+ tups,
+ nproc=nproc,
+ chunksize=nproc,
+ keys=indices,
+ save=tmp_file,)
+ ans = load(tmp_file)
+ for k, v in zip(indices, new_results):
+ assert k in ans
+
+ metric = self.calculat_metric(ans)
+ dump(metric, score_file)
+ return metric
diff --git a/vlmeval/dataset/image_shortqa.py b/vlmeval/dataset/image_shortqa.py
new file mode 100644
index 0000000000000000000000000000000000000000..acbcb089e1dc7261b6500f2cdf6aeec596c6d94b
--- /dev/null
+++ b/vlmeval/dataset/image_shortqa.py
@@ -0,0 +1,139 @@
+from vlmeval import *
+from .image_base import ImageBaseDataset
+from .utils import build_judge
+from .utils.multiple_choice import report_acc, eval_vanilla, eval_circular_group
+from .utils.shortqa import ShortQA_prompt
+from ..utils import track_progress_rich
+
+
+def ShortQA_auxeval(model, line):
+ def proc_str(s):
+ chs = set(s)
+ chs = [x for x in chs if x not in string.ascii_letters + ': ']
+ for ch in chs:
+ s = s.replace(ch, ' ')
+ return s
+
+ def extraction(resp):
+ correct, reason = None, None
+ correct_st, correct_ed = '[Begin Correctness]', '[End Correctness]'
+ reason_st, reason_ed = '[Begin Reason]', '[End Reason]'
+ if correct_st in resp and correct_ed in resp:
+ correct = resp.split(correct_st)[1].split(correct_ed)[0].strip().lower()
+ if ('yes' in correct) ^ ('no' in correct):
+ correct = 1 if 'yes' in correct else 0
+ if reason_st in resp and reason_ed in resp:
+ reason = resp.split(reason_st)[1].split(reason_ed)[0].strip()
+ return correct, reason
+ else:
+ return None, None
+ else:
+ return None, None
+
+ prompt = ShortQA_prompt(line)
+ retry = 3
+ for i in range(retry):
+ output = model.generate(prompt, temperature=0.5 * i)
+ ans = extraction(output)
+ # print(output, ans)
+ if ans[0] in [0, 1]:
+ return dict(hit=ans[0], log=ans[1])
+
+ return dict(hit=0, log='Fail to Judge')
+
+
+def Comprehensive_auxeval(model, data):
+ def valid(record, key_name):
+ return key_name in record and (not pd.isna(record[key_name])) and record[key_name] != ''
+
+ if isinstance(data, pd.DataFrame) and len(data) > 1:
+ # Should Adopt CircularEval
+ assert valid(data.iloc[0], 'A')
+ data['GT'] = data['answer']
+ return eval_circular_group(model, data)
+ else:
+ item = data.iloc[0] if isinstance(data, pd.DataFrame) else data
+ if valid(item, 'A') and len(item['answer']) == 1:
+ item['GT'] = item['answer']
+ return eval_vanilla(model, item)
+ else:
+ return ShortQA_auxeval(model, item)
+
+
+class ImageShortQADataset(ImageBaseDataset):
+ TYPE = 'Short'
+
+ DATASET_URL = {
+ 'LiveMMBench_Infographic': '',
+ 'LiveMMBench_Perception': '',
+ 'LiveMMBench_Reasoning': '',
+ 'LiveMMBench_Reasoning_circular': '',
+ }
+
+ DATASET_MD5 = {}
+
+ def build_prompt(self, line):
+ msgs = super().build_prompt(line)
+ assert msgs[-1]['type'] == 'text'
+ msgs[-1]['value'] += '\nPlease directly provide a short answer to the question. '
+ return msgs
+
+ # It returns a DataFrame
+ def evaluate(self, eval_file, **judge_kwargs):
+ data = load(eval_file)
+ dataset = self.dataset_name
+ assert 'answer' in data and 'prediction' in data
+ data['prediction'] = [str(x) for x in data['prediction']]
+ data['answer'] = [str(x) for x in data['answer']]
+
+ storage = eval_file.replace('.xlsx', '_judge.xlsx')
+ tmp_file = eval_file.replace('.xlsx', '_tmp.pkl')
+ nproc = judge_kwargs.pop('nproc', 4)
+
+ if not osp.exists(storage):
+ ans_map = {} if not osp.exists(tmp_file) else load(tmp_file)
+
+ model = judge_kwargs.get('model', 'gpt-4o-mini')
+ if model == 'exact_matching':
+ model = None
+ elif gpt_key_set():
+ model = build_judge(model=model, **judge_kwargs)
+ if not model.working():
+ warnings.warn('OPENAI API is not working properly, will use exact matching for evaluation')
+ warnings.warn(DEBUG_MESSAGE)
+ model = None
+ else:
+ model = None
+ warnings.warn('OPENAI_API_KEY is not working properly, will use exact matching for evaluation')
+
+ if model is not None:
+ if 'g_index' not in data:
+ lines = [data.iloc[i] for i in range(len(data))]
+ indices = [x['index'] for x in lines if x['index'] not in ans_map]
+ lines = [x for x in lines if x['index'] not in ans_map]
+ tups = [(model, line) for line in lines]
+ else:
+ main_data = data[[x == y for x, y in zip(data['index'], data['g_index'])]]
+ lines = [data[data['g_index'] == x] for x in main_data['index']]
+ indices = [x.iloc[0]['g_index'] for x in lines if x.iloc[0]['g_index'] not in ans_map]
+ lines = [x for x in lines if x.iloc[0]['g_index'] not in ans_map]
+ tups = [(model, x) for x in lines]
+ data = main_data
+
+ if len(lines):
+ res = track_progress_rich(
+ Comprehensive_auxeval, tups, nproc=nproc, chunksize=nproc, keys=indices, save=tmp_file)
+ for k, v in zip(indices, res):
+ ans_map[k] = v
+
+ judge_results = [ans_map[x] for x in data['index']]
+ data['hit'] = [x['hit'] for x in judge_results]
+ data['log'] = [x['log'] for x in judge_results]
+ dump(data, storage)
+
+ data = load(storage)
+ acc = report_acc(data)
+
+ score_file = eval_file.replace(f'.xlsx', '_acc.csv')
+ dump(acc, score_file)
+ return acc
diff --git a/vlmeval/dataset/image_vqa.py b/vlmeval/dataset/image_vqa.py
new file mode 100644
index 0000000000000000000000000000000000000000..f3de48f0de4f09e9849f93d0af13a47c670e46b5
--- /dev/null
+++ b/vlmeval/dataset/image_vqa.py
@@ -0,0 +1,1536 @@
+import os
+import re
+import tempfile
+from functools import partial
+
+import pandas as pd
+
+from .image_base import ImageBaseDataset
+from .utils import build_judge, DEBUG_MESSAGE
+from ..smp import *
+from ..utils import track_progress_rich
+
+
+class ImageVQADataset(ImageBaseDataset):
+ TYPE = 'VQA'
+
+ DATASET_URL = {
+ 'OCRVQA_TEST': 'https://opencompass.openxlab.space/utils/VLMEval/OCRVQA_TEST.tsv',
+ 'OCRVQA_TESTCORE': 'https://opencompass.openxlab.space/utils/VLMEval/OCRVQA_TESTCORE.tsv',
+ 'TextVQA_VAL': 'https://opencompass.openxlab.space/utils/VLMEval/TextVQA_VAL.tsv',
+ 'DocVQA_VAL': 'https://opencompass.openxlab.space/utils/VLMEval/DocVQA_VAL.tsv',
+ 'DocVQA_TEST': 'https://opencompass.openxlab.space/utils/VLMEval/DocVQA_TEST.tsv',
+ 'InfoVQA_VAL': 'https://opencompass.openxlab.space/utils/VLMEval/InfoVQA_VAL.tsv',
+ 'InfoVQA_TEST': 'https://opencompass.openxlab.space/utils/VLMEval/InfoVQA_TEST.tsv',
+ 'ChartQA_TEST': 'https://opencompass.openxlab.space/utils/VLMEval/ChartQA_TEST.tsv',
+ 'GQA_TestDev_Balanced': 'https://opencompass.openxlab.space/utils/VLMEval/GQA_TestDev_Balanced.tsv',
+ }
+
+ DATASET_MD5 = {
+ 'OCRVQA_TEST': 'ca46a6d74b403e9d6c0b670f6fc00db9',
+ 'OCRVQA_TESTCORE': 'c5239fe77db8bdc1f2ad8e55e0d1fe97',
+ 'TextVQA_VAL': 'b233b31f551bbf4056f2f955da3a92cd',
+ 'DocVQA_VAL': 'd5ee77e1926ff10690d469c56b73eabf',
+ 'DocVQA_TEST': '6a2f28cac26ef2d3447374e8c6f6c8e9',
+ 'InfoVQA_VAL': '2342e9c225222f0ef4dec545ebb126fe',
+ 'InfoVQA_TEST': 'df535bf51b88dc9718252c34131a6227',
+ 'ChartQA_TEST': 'c902e0aa9be5582a7aad6dcf52734b42',
+ 'GQA_TestDev_Balanced': '99b62f22e224d9b2f32dcbe41359d1c9',
+ }
+
+ def build_prompt(self, line):
+ msgs = super().build_prompt(line)
+ assert msgs[-1]['type'] == 'text'
+ msgs[-1]['value'] += '\nAnswer the question using a single word or phrase.'
+ return msgs
+
+ # It returns a DataFrame
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.vqa_eval import hit_calculate, process_line
+
+ data = load(eval_file)
+ dataset = self.dataset_name
+ assert 'answer' in data and 'prediction' in data
+ data['prediction'] = [str(x) for x in data['prediction']]
+ data['answer'] = [str(x) for x in data['answer']]
+ lt = len(data)
+ pool = mp.Pool(16)
+ lines = [data.iloc[i] for i in range(lt)]
+ if listinstr(['TextVQA'], dataset):
+ res = pool.map(partial(process_line, method='vqa_score'), lines)
+ elif listinstr(['ChartQA'], dataset):
+ res = pool.map(partial(process_line, method='relaxed_accuracy'), lines)
+ elif listinstr(['OCRVQA', 'GQA'], dataset):
+ res = pool.map(partial(process_line, method='accuracy'), lines)
+ elif listinstr(['DocVQA', 'InfoVQA'], dataset):
+ res = pool.map(partial(process_line, method='anls'), lines)
+ else: # default using vqa_score to calculate score
+ res = pool.map(process_line, lines)
+ hit = hit_calculate(res, dataset)
+ ret = dict()
+ if 'split' in data:
+ splits = set(data['split'])
+ for sp in splits:
+ sub = [r for l, r in zip(lines, res) if l['split'] == sp]
+ # [np.mean(x['match']) >= full_score_weight for x in sub]
+ hit = hit_calculate(sub, dataset)
+ ret[sp] = np.mean(hit) * 100
+ sub = [r for l, r in zip(lines, res)]
+ hit = hit_calculate(sub, dataset)
+ ret['Overall'] = np.mean(hit) * 100
+ else:
+ ret['Overall'] = np.mean(hit) * 100
+ if 'category' in data:
+ cates = list(set(data['category']))
+ cates.sort()
+ for c in cates:
+ sub = [r for l, r in zip(lines, res) if l['category'] == c]
+ # [np.mean(x['match']) >= full_score_weight for x in sub]
+ hit = hit_calculate(sub, dataset)
+ ret[c] = np.mean(hit) * 100
+ ret = d2df(ret)
+ ret.round(2)
+
+ suffix = eval_file.split('.')[-1]
+ result_file = eval_file.replace(f'.{suffix}', '_acc.csv')
+ dump(ret, result_file)
+ return ret
+
+
+class VizWiz(ImageBaseDataset):
+ TYPE = 'VQA'
+ DATASET_URL = {
+ 'VizWiz': 'https://opencompass.openxlab.space/utils/VLMEval/VizWiz.tsv'
+ }
+ DATASET_MD5 = {
+ 'VizWiz': 'fa4ac4164467563ed2fac6eac6631bd0'
+ }
+
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.vqa_eval import hit_calculate, process_line
+
+ suffix = eval_file.split('.')[-1]
+ result_file = eval_file.replace(f'.{suffix}', '_acc.csv')
+
+ if not osp.exists(result_file):
+ data = load(eval_file)
+ assert 'answers' in data and 'prediction' in data
+ data['prediction'] = [str(x) for x in data['prediction']]
+ data['answer'] = [str(x) for x in data['answers']]
+
+ lt = len(data)
+ pool = mp.Pool(16)
+ lines = [data.iloc[i] for i in range(lt)]
+ res = pool.map(process_line, lines)
+
+ hit = hit_calculate(res, 'VizWiz')
+ ret = dict()
+
+ ret['Overall'] = np.mean(hit) * 100
+ ret = d2df(ret)
+ ret.round(2)
+
+ dump(ret, result_file)
+
+ retz = pd.read_csv(result_file)
+ return retz
+
+
+class OCRBench(ImageBaseDataset):
+ TYPE = 'VQA'
+ DATASET_URL = {
+ 'OCRBench': 'https://opencompass.openxlab.space/utils/VLMEval/OCRBench.tsv',
+ # For internal test only
+ 'OCRBench_MINI': 'https://opencompass.openxlab.space/utils/TEST/OCRBench_MINI.tsv'
+ }
+ DATASET_MD5 = {'OCRBench': 'e953d98a987cc6e26ef717b61260b778'}
+
+ # It returns a dictionary
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ OCRBench_score = {
+ 'Regular Text Recognition': 0,
+ 'Irregular Text Recognition': 0,
+ 'Artistic Text Recognition': 0,
+ 'Handwriting Recognition': 0,
+ 'Digit String Recognition': 0,
+ 'Non-Semantic Text Recognition': 0,
+ 'Scene Text-centric VQA': 0,
+ 'Doc-oriented VQA': 0,
+ 'Key Information Extraction': 0,
+ 'Handwritten Mathematical Expression Recognition': 0,
+ }
+
+ data = load(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 = eval(line['answer'])
+ category = line['category']
+ if category == 'Handwritten Mathematical Expression Recognition':
+ for j in range(len(answers)):
+ answer = answers[j].strip().replace('\n', ' ').replace(' ', '')
+ predict = predict.strip().replace('\n', ' ').replace(' ', '')
+ if answer in predict:
+ OCRBench_score[category] += 1
+ break
+ else:
+ for j in range(len(answers)):
+ answer = answers[j].lower().strip().replace('\n', ' ')
+ predict = predict.lower().strip().replace('\n', ' ')
+ if answer in predict:
+ OCRBench_score[category] += 1
+ break
+
+ final_score_dict = {}
+ final_score_dict['Text Recognition'] = \
+ (OCRBench_score['Regular Text Recognition'] + OCRBench_score['Irregular Text Recognition']
+ + OCRBench_score['Artistic Text Recognition'] + OCRBench_score['Handwriting Recognition']
+ + OCRBench_score['Digit String Recognition'] + OCRBench_score['Non-Semantic Text Recognition'])
+ final_score_dict['Scene Text-centric VQA'] = OCRBench_score['Scene Text-centric VQA']
+ final_score_dict['Doc-oriented VQA'] = OCRBench_score['Doc-oriented VQA']
+ final_score_dict['Key Information Extraction'] = OCRBench_score['Key Information Extraction']
+ final_score_dict['Handwritten Mathematical Expression Recognition'] = \
+ (OCRBench_score['Handwritten Mathematical Expression Recognition'])
+ final_score_dict['Final Score'] = \
+ (final_score_dict['Text Recognition'] + final_score_dict['Scene Text-centric VQA']
+ + final_score_dict['Doc-oriented VQA'] + final_score_dict['Key Information Extraction']
+ + final_score_dict['Handwritten Mathematical Expression Recognition'])
+ final_score_dict['Final Score Norm'] = (float(final_score_dict['Final Score']) / 10)
+ score_pth = eval_file.replace('.xlsx', '_score.json')
+ dump(final_score_dict, score_pth)
+ return final_score_dict
+
+
+class MathVista(ImageBaseDataset):
+ TYPE = 'VQA'
+ DATASET_URL = {
+ 'MathVista_MINI': 'https://opencompass.openxlab.space/utils/VLMEval/MathVista_MINI.tsv'
+ }
+ DATASET_MD5 = {'MathVista_MINI': 'f199b98e178e5a2a20e7048f5dcb0464'}
+
+ # It returns a DataFrame
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.mathvista import MathVista_auxeval, MathVista_acc
+
+ model = judge_kwargs['model']
+ suffix = eval_file.split('.')[-1]
+ storage = eval_file.replace(f'.{suffix}', f'_{model}.xlsx')
+ tmp_file = eval_file.replace(f'.{suffix}', f'_{model}.pkl')
+ nproc = judge_kwargs.pop('nproc', 4)
+
+ if not osp.exists(storage):
+ data = load(eval_file)
+ model = build_judge(max_tokens=128, **judge_kwargs)
+ assert model.working(), ('MathVista evaluation requires a working OPENAI API\n' + DEBUG_MESSAGE)
+ lt = len(data)
+ lines = [data.iloc[i] for i in range(lt)]
+ tups = [(model, line) for line in lines]
+ indices = [line['index'] for line in lines]
+
+ ans = {}
+ if osp.exists(tmp_file):
+ ans = load(tmp_file)
+ tups = [x for x, i in zip(tups, indices) if i not in ans]
+ indices = [i for i in indices if i not in ans]
+
+ if len(indices):
+ new_results = track_progress_rich(
+ MathVista_auxeval,
+ tups,
+ nproc=nproc,
+ chunksize=nproc,
+ keys=indices,
+ save=tmp_file,
+ )
+ ans = load(tmp_file)
+ for k, v in zip(indices, new_results):
+ assert k in ans
+ assert ans[k]['log'] == v['log'] and ans[k]['res'] == v['res']
+
+ data['res'] = [ans[idx]['res'] for idx in data['index']]
+ data['log'] = [ans[idx]['log'] for idx in data['index']]
+ dump(data, storage)
+
+ score = MathVista_acc(storage)
+ score_pth = storage.replace('.xlsx', '_score.csv')
+ dump(score, score_pth)
+ return score
+
+
+class MathVerse(ImageBaseDataset):
+ TYPE = 'VQA'
+ DATASET_URL = {
+ 'MathVerse_MINI': 'http://opencompass.openxlab.space/utils/benchmarks/MathVerse/MathVerse_MINIV.tsv', # noqa
+ 'MathVerse_MINI_Vision_Only': 'http://opencompass.openxlab.space/utils/benchmarks/MathVerse/MathVerse_MINIVOnly.tsv', # noqa
+ 'MathVerse_MINI_Vision_Only_cot': 'http://opencompass.openxlab.space/utils/benchmarks/MathVerse/MathVerse_MINIVOnly.tsv', # noqa
+ 'MathVerse_MINI_Vision_Dominant': 'http://opencompass.openxlab.space/utils/benchmarks/MathVerse/MathVerse_MINIVDom.tsv', # noqa
+ 'MathVerse_MINI_Vision_Intensive': 'http://opencompass.openxlab.space/utils/benchmarks/MathVerse/MathVerse_MINIVInt.tsv', # noqa
+ 'MathVerse_MINI_Text_Lite': 'http://opencompass.openxlab.space/utils/benchmarks/MathVerse/MathVerse_MINITLite.tsv', # noqa
+ 'MathVerse_MINI_Text_Dominant': 'http://opencompass.openxlab.space/utils/benchmarks/MathVerse/MathVerse_MINITDom.tsv', # noqa
+ }
+ DATASET_MD5 = {
+ 'MathVerse_MINI': '5017caca32b7fa110c350a1bea861b65',
+ 'MathVerse_MINI_Vision_Only': '68a11d4680014ac881fa37adeadea3a4',
+ 'MathVerse_MINI_Vision_Only_cot': '68a11d4680014ac881fa37adeadea3a4',
+ 'MathVerse_MINI_Vision_Dominant': 'b8fb63852d261ab2aaefba29cc2414d3',
+ 'MathVerse_MINI_Vision_Intensive': '01cbd35be202bb0c4873a4186a63bc19',
+ 'MathVerse_MINI_Text_Lite': '19e4b13bdd30b89a03b2e358bcfefa04',
+ 'MathVerse_MINI_Text_Dominant': '4f5cd2fa6630ea00bb11d6fde1f6fe6a',
+ }
+
+ # Given one data record, return the built prompt (a multi-modal message), can override
+ def build_prompt(self, line):
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ if self.meta_only:
+ tgt_path = toliststr(line['image_path'])
+ else:
+ tgt_path = self.dump_image(line)
+ if 'cot' in self.dataset_name:
+ question = line['query_cot']
+ else:
+ question = line['question']
+
+ msgs = []
+ if isinstance(tgt_path, list):
+ msgs.extend([dict(type='image', value=p) for p in tgt_path])
+ else:
+ msgs = [dict(type='image', value=tgt_path)]
+ msgs.append(dict(type='text', value=question))
+ return msgs
+
+ # It returns a DataFrame
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.mathverse import MathVerse_auxeval_extract, MathVerse_auxeval_score, MathVerse_acc
+
+ model = judge_kwargs['model']
+ suffix = eval_file.split('.')[-1]
+ storage_extract = eval_file.replace(f'.{suffix}', f'_{model}_extract.xlsx')
+ tmp_file_extract = eval_file.replace(f'.{suffix}', f'_{model}_extract.pkl')
+ storage_score = eval_file.replace(f'.{suffix}', f'_{model}_score.xlsx')
+ tmp_file_score = eval_file.replace(f'.{suffix}', f'_{model}_score.pkl')
+ nproc = judge_kwargs.pop('nproc', 4)
+ # stage1: extract the answer
+ if not osp.exists(storage_extract):
+ data = load(eval_file)
+ model = build_judge(max_tokens=128, **judge_kwargs)
+ assert model.working(), ('MathVerse evaluation requires a working OPENAI API\n' + DEBUG_MESSAGE)
+ lt = len(data)
+ lines = [data.iloc[i] for i in range(lt)]
+ tups = [(model, line) for line in lines]
+ indices = [line['index'] for line in lines]
+
+ ans = {}
+ if osp.exists(tmp_file_extract):
+ ans = load(tmp_file_extract)
+ tups = [x for x, i in zip(tups, indices) if i not in ans]
+ indices = [i for i in indices if i not in ans]
+
+ if len(indices):
+ new_results = track_progress_rich(
+ MathVerse_auxeval_extract,
+ tups,
+ nproc=nproc,
+ chunksize=nproc,
+ keys=indices,
+ save=tmp_file_extract,
+ )
+ ans = load(tmp_file_extract)
+ for k, v in zip(indices, new_results):
+ assert k in ans
+ assert ans[k]['log_extract'] == v['log_extract'] and ans[k]['extract'] == v['extract']
+
+ data['extract'] = [ans[idx]['extract'] for idx in data['index']]
+ data['log_extract'] = [ans[idx]['log_extract'] for idx in data['index']]
+ dump(data, storage_extract)
+
+ # stage2: score the answer
+ if not osp.exists(storage_score):
+ data = load(storage_extract)
+ model = build_judge(max_tokens=128, **judge_kwargs)
+ assert model.working(), ('MathVerse evaluation requires a working OPENAI API\n' + DEBUG_MESSAGE)
+ lt = len(data)
+ lines = [data.iloc[i] for i in range(lt)]
+ tups = [(model, line) for line in lines]
+ indices = [line['index'] for line in lines]
+
+ ans = {}
+ if osp.exists(tmp_file_score):
+ ans = load(tmp_file_score)
+ tups = [x for x, i in zip(tups, indices) if i not in ans]
+ indices = [i for i in indices if i not in ans]
+
+ if len(indices):
+ new_results = track_progress_rich(
+ MathVerse_auxeval_score,
+ tups,
+ nproc=nproc,
+ chunksize=nproc,
+ keys=indices,
+ save=tmp_file_score,
+ )
+ ans = load(tmp_file_score)
+ for k, v in zip(indices, new_results):
+ assert k in ans
+ assert ans[k]['log_score'] == v['log_score'] and ans[k]['score'] == v['score']
+
+ data['score'] = [ans[idx]['score'] for idx in data['index']]
+ data['log_score'] = [ans[idx]['log_score'] for idx in data['index']]
+ dump(data, storage_score)
+
+ score = MathVerse_acc(storage_score)
+ score_pth = storage_score.replace('.xlsx', '.csv')
+ dump(score, score_pth)
+ return score
+
+
+class MathVision(ImageBaseDataset):
+ TYPE = 'VQA'
+ DATASET_URL = {
+ 'MathVision': 'https://opencompass.openxlab.space/utils/VLMEval/MathVision.tsv',
+ 'MathVision_MINI': 'https://opencompass.openxlab.space/utils/VLMEval/MathVision_MINI.tsv'
+ }
+ DATASET_MD5 = {
+ 'MathVision': '93f6de14f7916e598aa1b7165589831e',
+ 'MathVision_MINI': '060fe4fa5d868987ce179307bd5f8a33'
+ }
+
+ # It returns a DataFrame
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.mathv import MATH_V_auxeval, MATH_V_acc
+
+ if 'model' in judge_kwargs:
+ model = judge_kwargs['model']
+ else:
+ model = os.path.basename(os.environ.get('LOCAL_LLM'))
+ suffix = eval_file.split('.')[-1]
+ storage = eval_file.replace(f'.{suffix}', f'_{model}.xlsx')
+ tmp_file = eval_file.replace(f'.{suffix}', f'_{model}.pkl')
+ nproc = judge_kwargs.pop('nproc', 4)
+
+ if not osp.exists(storage):
+ data = load(eval_file)
+ model = build_judge(max_tokens=128, **judge_kwargs)
+ assert model.working(), ('MATH-Vision evaluation requires a working OPENAI API\n' + DEBUG_MESSAGE)
+ lt = len(data)
+ lines = [data.iloc[i] for i in range(lt)]
+ tups = [(model, line) for line in lines]
+ indices = [line['index'] for line in lines]
+
+ ans = {}
+ if osp.exists(tmp_file):
+ ans = load(tmp_file)
+ tups = [x for x, i in zip(tups, indices) if i not in ans]
+ indices = [i for i in indices if i not in ans]
+
+ if len(indices):
+ new_results = track_progress_rich(
+ MATH_V_auxeval,
+ tups,
+ nproc=nproc,
+ chunksize=nproc,
+ keys=indices,
+ save=tmp_file,
+ )
+ ans = load(tmp_file)
+ for k, v in zip(indices, new_results):
+ assert k in ans
+ assert ans[k]['log'] == v['log'] and ans[k]['res'] == v['res']
+
+ data['res'] = [ans[idx]['res'] for idx in data['index']]
+ data['log'] = [ans[idx]['log'] for idx in data['index']]
+ dump(data, storage)
+
+ score = MATH_V_acc(storage)
+ score_pth = storage.replace('.xlsx', '_score.csv')
+ dump(score, score_pth)
+ return score
+
+
+class OlympiadBench(ImageBaseDataset):
+ TYPE = 'VQA_ex_prompt'
+ DATASET_URL = {
+ 'OlympiadBench': 'https://opencompass.openxlab.space/utils/VLMEval/OlympiadBench.tsv',
+ 'OlympiadBench_EN': 'https://opencompass.openxlab.space/utils/VLMEval/OlympiadBench_EN.tsv',
+ 'OlympiadBench_CN': 'https://opencompass.openxlab.space/utils/VLMEval/OlympiadBench_CN.tsv'
+ }
+ DATASET_MD5 = {
+ 'OlympiadBench': '9735ae0f0299eae1e7d07f5a7feab914',
+ 'OlympiadBench_EN': '5c68e100d394351fc7049f29d4d4efed',
+ 'OlympiadBench_CN': 'ea01b16788955702c79650c701e5b623'
+ }
+
+ def dump_image(self, line):
+ os.makedirs(self.img_root, exist_ok=True)
+
+ tgt_path_z = []
+ if isinstance(line['image'], list):
+ for i in range(len(line['image'])):
+ tgt_path = osp.join(self.img_root, f"{line['index']}--{i + 1}.jpg")
+ if not read_ok(tgt_path):
+ decode_base64_to_image_file(line['image'][i], tgt_path)
+ tgt_path_z.append(tgt_path)
+ else:
+ tgt_path = osp.join(self.img_root, f"{line['index']}.jpg")
+ if not read_ok(tgt_path):
+ decode_base64_to_image_file(line['image'], tgt_path)
+ tgt_path_z.append(tgt_path)
+ return tgt_path_z
+
+ def build_prompt(self, line):
+
+ from .utils.olympiadbench import get_answer_type_text, make_input
+
+ self.is_chinese = 'zh' in line['source']
+ self.is_math = 'maths' in line['source']
+ self.is_theorem_proving = 'TP' in line['source']
+
+ if self.is_chinese:
+ subject_content = '数学' if self.is_math else '物理'
+ if self.is_theorem_proving:
+ prompt = (
+ f"以下是中国{subject_content}竞赛中的证明题。请根据题目的要求，运用逻辑推理及常用定理证明题目中的命题。"
+ "证明过程中使用的变量和公式请使用LaTeX格式表示。"
+ )
+ else:
+ answer_type_text = get_answer_type_text(line['answer_type'], is_chinese=True,
+ multiple_answer=line['is_multiple_answer'])
+ if line['is_multiple_answer']:
+ multiple_answer_text = '\\boxed{用英文逗号连接的多个答案}'
+ else:
+ multiple_answer_text = '\\boxed{答案}'
+ unit_text = ''
+ if line['unit']:
+ multiple_answer_text += '(单位)'
+ unit_text = '，注意答案的单位不要放在\\boxed{}中'
+ prompt = (
+ f'以下是中国{subject_content}竞赛中的解答题{answer_type_text}。请根据题目的要求和所提供的信息计算得出答案。'
+ f'解答过程和结果中使用的变量和公式请使用LaTeX格式表示。请在最后以“所以最终答案是{multiple_answer_text}。”'
+ f'显式给出结果{unit_text}。'
+ )
+ else:
+ subject_content = 'Math' if self.is_math else 'Physics'
+ if self.is_theorem_proving:
+ prompt = (
+ f'The following is a theorem proving problem from an International {subject_content} competition. '
+ 'Please use logical reasoning and common theorems to prove the proposition in the problem '
+ 'according to the given requirements. '
+ 'Please use LaTeX format to represent the variables and formulas used in the proof.'
+ )
+ else:
+ if line['is_multiple_answer']:
+ multiple_answer_text = '\\boxed{multiple answers connected with commas}'
+ else:
+ multiple_answer_text = '\\boxed{answer}'
+ unit_text = ''
+ if line['unit']:
+ multiple_answer_text += '(unit)'
+ unit_text = ', note that the unit of the answer should not be included in \\boxed{}'
+ answer_type_text = get_answer_type_text(line['answer_type'], is_chinese=False,
+ multiple_answer=line['is_multiple_answer'])
+ prompt = (
+ f'The following is an open-ended problem from an International {subject_content} competition. '
+ f'{answer_type_text}Please calculate the answer according to the given requirements and '
+ 'the information provided. Please use LaTeX format to represent the variables and formulas '
+ 'used in the solution process and results. Please end your solution with "So the final answer '
+ f'is {multiple_answer_text}." and give the result explicitly{unit_text}.'
+ )
+
+ if self.is_math:
+ input = make_input(prompt, line['question'])
+ else:
+ if 'context' in line.keys() and str(line['context']) != 'nan': # cannot be null
+ input = make_input(prompt, line['context'] + '\n' + line['question'])
+ else:
+ input = make_input(prompt, line['question'])
+
+ ret = [dict(type='text', value=input)]
+ tgt_path = self.dump_image(line)
+
+ ret.extend([dict(type='image', value=s) for s in tgt_path])
+
+ return ret
+
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.olympiadbench import MathJudger, extract_answer
+ judger = MathJudger()
+
+ suffix = eval_file.split('.')[-1]
+ name_str1 = 'judge'
+ name_str2 = 'score'
+ result_file = eval_file.replace(f'.{suffix}', f'_{name_str1}_result.xlsx')
+ score_file = eval_file.replace(f'.{suffix}', f'_{name_str2}_result.csv')
+
+ if not osp.exists(result_file):
+ data = load(eval_file)
+ scorez = []
+
+ for i in tqdm(data.iterrows()):
+ line = i[1]
+ model_answer = line['prediction']
+ is_chinese = 'zh' in line['source']
+ model_answer = extract_answer(is_chinese, model_answer, is_deepseek=False)
+ answer_type = line['answer_type']
+
+ final_answer = line['final_answer'][2:-2]
+
+ if str(answer_type) != 'nan' and 'Tuple' in answer_type:
+ judge_result = judger.judge(model_answer, final_answer)
+ else:
+ if str(line['error']) != 'nan':
+ if ',' in line['error']:
+ precisions = line['error'].split(',')
+ precisions = [float(p) if p else 1e-8 for p in precisions]
+ judge_result = judger.judge(model_answer, final_answer, precisions)
+ else:
+ precision = float(line['error'])
+ judge_result = judger.judge(model_answer, final_answer, precision)
+ else:
+ judge_result = judger.judge(model_answer, final_answer)
+ scorez.append(judge_result)
+
+ data['score'] = scorez
+ dump(data, result_file)
+
+ judge_file = load(result_file)
+
+ if not osp.exists(score_file):
+ name_list = ['OE_MM_maths_en_COMP', 'OE_MM_maths_zh_CEE', 'OE_MM_maths_zh_COMP', 'OE_MM_physics_en_COMP',
+ 'OE_MM_physics_zh_CEE','OE_TO_maths_en_COMP', 'OE_TO_maths_zh_CEE', 'OE_TO_maths_zh_COMP',
+ 'OE_TO_physics_en_COMP', 'OE_TO_physics_zh_CEE']
+
+ sample_list = [[] for _ in range(len(name_list))]
+ for i in judge_file.iterrows():
+ line = i[1]
+ for j in range(len(name_list)):
+ if line['source'] == name_list[j]:
+ sample_list[j].append(line['score'])
+
+ acc_dict = {}
+ correct_list = []
+
+ # fine-grained
+ for i in range(len(name_list)):
+ correct_num = 0
+ for j in sample_list[i]:
+ if j:
+ correct_num += 1
+ correct_list.append(correct_num)
+ acc = 100 * correct_num / len(sample_list[i])
+ acc_dict[name_list[i]] = [acc]
+
+ # 4 grained
+ labela = ['zh', 'en']
+ labelb = ['maths', 'physics']
+
+ grain_list = [[x,y] for x in labela for y in labelb]
+ for j in grain_list:
+ dict_name = j[0] + "_" + j[1]
+ correct_num = 0
+ full_num = 0
+ for i in range(len(name_list)):
+ if all(k in name_list[i] for k in j):
+ correct_num += correct_list[i]
+ full_num += len(sample_list[i])
+ acc = 100 * correct_num / full_num
+ acc_dict[dict_name] = [acc]
+
+ # 2 grained
+ grain_list = ['maths', 'physics']
+ for j in grain_list:
+ dict_name = j
+ correct_num = 0
+ full_num = 0
+ for i in range(len(name_list)):
+ if j in name_list[i]:
+ correct_num += correct_list[i]
+ full_num += len(sample_list[i])
+ acc = 100 * correct_num / full_num
+ acc_dict[dict_name] = [acc]
+
+ # AVG
+ correct_num = sum(correct_list)
+ acc = 100 * correct_num / len(judge_file)
+ acc_dict['AVG'] = [acc]
+
+ acc_pd = pd.DataFrame(acc_dict)
+ acc_pd.to_csv(score_file, index=False, encoding='gbk')
+
+ accdz = pd.read_csv(score_file)
+ return accdz
+
+
+class LogicVista(ImageBaseDataset):
+ TYPE = 'VQA'
+ DATASET_URL = {
+ 'LogicVista': 'https://opencompass.openxlab.space/utils/VLMEval/LogicVista.tsv'
+ }
+ DATASET_MD5 = {'LogicVista': '41c5d33adf33765c399e0e6ae588c061'}
+
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.logicvista import LogicVista_auxeval, evaluate_logicvista
+
+ # model = judge_kwargs['model']
+ model = judge_kwargs.get('model', 'exact_matching')
+ assert model in ['exact_matching', 'gpt-4-0125', 'gpt-4-turbo', 'gpt-4o-mini'], model
+ name_str_map = {'gpt-4-0125': 'gpt4', 'gpt-4-turbo': 'gpt4-turbo', 'gpt-4o-mini': 'gpt4o-mini'}
+ name_str = name_str_map[model] if model in name_str_map else model
+
+ if model == 'exact_matching':
+ model = None
+ elif gpt_key_set():
+ model = build_judge(**judge_kwargs)
+ if not model.working():
+ warnings.warn('OPENAI API is not working properly, will use exact matching for evaluation')
+ warnings.warn(DEBUG_MESSAGE)
+ model = None
+ else:
+ warnings.warn('OPENAI_API_KEY is not set properly, will use exact matching for evaluation')
+ model = None
+
+ suffix = eval_file.split('.')[-1]
+ storage = eval_file.replace(f'.{suffix}', f'_{name_str}.xlsx')
+ tmp_file = eval_file.replace(f'.{suffix}', f'_{name_str}.pkl')
+ nproc = judge_kwargs.pop('nproc', 4)
+
+ if not osp.exists(storage) and model is not None:
+ data = load(eval_file)
+ model = build_judge(max_tokens=128, **judge_kwargs)
+ assert model.working(), ('LogicVista evaluation requires a working OPENAI API\n' + DEBUG_MESSAGE)
+ lt = len(data)
+ lines = [data.iloc[i] for i in range(lt)]
+ tups = [(model, line) for line in lines]
+ indices = [line['index'] for line in lines]
+
+ ans = {}
+ if osp.exists(tmp_file):
+ ans = load(tmp_file)
+ tups = [x for x, i in zip(tups, indices) if i not in ans]
+ indices = [i for i in indices if i not in ans]
+
+ if len(indices):
+ new_results = track_progress_rich(
+ LogicVista_auxeval,
+ tups,
+ nproc=nproc,
+ chunksize=nproc,
+ keys=indices,
+ save=tmp_file,
+ )
+ ans = load(tmp_file)
+ for k, v in zip(indices, new_results):
+ assert k in ans
+ assert ans[k]['log'] == v['log'] and ans[k]['res'] == v['res'] and ans[k]['hit'] == v['hit']
+
+ data['res'] = [ans[idx]['res'] for idx in data['index']]
+ data['log'] = [ans[idx]['log'] for idx in data['index']]
+ data['hit'] = [ans[idx]['hit'] for idx in data['index']]
+
+ dump(data, storage)
+ if osp.exists(storage):
+ accuracy_scores = evaluate_logicvista(storage)
+ score_pth = storage.replace('.xlsx', '_score.csv')
+ dump(accuracy_scores, score_pth)
+
+ return accuracy_scores
+
+class MME_CoT(ImageBaseDataset):
+ TYPE = 'VQA'
+ DATASET_URL = {
+ 'MME_CoT_TEST': 'https://huggingface.co/datasets/CaraJ/MME-CoT_VLMEvalKit/resolve/main/MME-CoT.tsv' # noqa
+ }
+ DATASET_MD5 = {
+ 'MME_CoT_TEST': 'a612dee0f2d702e01fe50267201302e0',
+ }
+
+ def split_MME_CoT(self, msgs):
+ text, images = None, []
+
+ # Separate images and text from msgs
+ for s in msgs:
+ if s['type'] == 'image':
+ images.append(s['value'])
+ elif s['type'] == 'text':
+ assert text is None # Ensure only one text entry is expected
+ text = s['value']
+
+ # Split text by tags
+ text_segs = text.split('')
+
+ # Initialize the segments list
+ segs = []
+ # Iterate through the text segments and images
+ for i, seg in enumerate(text_segs):
+ # Append the image if this is not the first segment and there are still images left
+ if i > 0 and i - 1 < len(images):
+ segs.append(dict(type='image', value=images[i - 1]))
+ # Append the text segment (if it's non-empty)
+ if len(seg.strip()) > 0:
+ segs.append(dict(type='text', value=seg))
+
+ return segs
+
+ def dump_image(self, line):
+ os.makedirs(self.img_root, exist_ok=True)
+
+ if 'image' in line:
+ if isinstance(line['image'], list):
+ tgt_path = []
+ if 'image_path' in line:
+ image_path_list = line['image_path']
+ else:
+ image_path_list = [f"{line['index']}--{i + 1}.jpg" for i in range(len(line['image']))]
+ for img, im_name in zip(line['image'], image_path_list):
+ path = osp.join(self.img_root, im_name)
+ if not read_ok(path):
+ decode_base64_to_image_file(img, path)
+ tgt_path.append(path)
+ else:
+ tgt_path = osp.join(self.img_root, f"{line['index']}.jpg")
+ if not read_ok(tgt_path):
+ decode_base64_to_image_file(line['image'], tgt_path)
+ tgt_path = [tgt_path]
+ else:
+ assert 'image_path' in line
+ tgt_path = toliststr(line['image_path'])
+
+ return tgt_path
+
+ def build_prompt(self, line):
+
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ tgt_path = self.dump_image(line)
+
+ prompt = line['question']
+
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ prompt = prompt + '\n' + '\n'.join([f'{key}. {item}' for key, item in options.items()])
+
+ # add cot prompt
+ if os.environ.get('USE_COT_PROMPT', '1') == '1':
+ prompt += "\nPlease generate a step by step answer, include all your intermediate reasoning process, and provide the final answer at the end."
+ else:
+ prompt += "\nPlease directly provide the final answer without any other output."
+
+ msgs = []
+ if isinstance(tgt_path, list):
+ msgs.extend([dict(type='image', value=p) for p in tgt_path])
+ else:
+ msgs = [dict(type='image', value=tgt_path)]
+ msgs.append(dict(type='text', value=prompt))
+
+ msgs = self.split_MME_CoT(msgs)
+ return msgs
+
+ # It returns a DataFrame
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ print("\033[1;31;40m" + "[MME-CoT Evaluation]: Please refer to the official repository for evaluation: https://github.com/CaraJ7/MME-CoT/tree/main" + "\033[0m")
+ dummy_result = dict(
+ dummy_result=0
+ )
+ return pd.DataFrame(dummy_result, index=[0])
+
+
+
+class LLaVABench(ImageBaseDataset):
+ TYPE = 'VQA'
+ DATASET_URL = {'LLaVABench': 'https://opencompass.openxlab.space/utils/VLMEval/LLaVABench.tsv'}
+ DATASET_MD5 = {'LLaVABench': 'd382a093f749a697820d3dadd61c8428'}
+
+ # It returns a DataFrame
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.llavabench import (
+ build_prompt,
+ LLaVABench_atomeval,
+ LLaVABench_score,
+ )
+
+ suffix = '.' + eval_file.split('.')[-1]
+ record_file = eval_file.replace(suffix, '_openai_result' + suffix)
+ score_file = eval_file.replace(suffix, '_score.csv')
+ nproc = judge_kwargs.pop('nproc', 4)
+ system_prompt = 'You are a helpful and precise assistant for checking the quality of the answer.'
+
+ if not osp.exists(record_file):
+ data = load(eval_file)
+ lines = [data.iloc[i] for i in range(len(data))]
+ model = build_judge(temperature=0.2, system_prompt=system_prompt, **judge_kwargs)
+ assert model.working(), ('LLaVABench evaluation requires a working OPENAI API\n' + DEBUG_MESSAGE)
+
+ prompts = [build_prompt(line) for line in lines]
+ tups = [(model, prompt) for prompt in prompts]
+ scores = track_progress_rich(LLaVABench_atomeval, tups, nproc=nproc, chunksize=nproc)
+ data['gpt4_score'] = [x[0] for x in scores]
+ data['score'] = [x[1] for x in scores]
+ dump(data, record_file)
+
+ data = load(record_file)
+ ret = LLaVABench_score(data).round(1)
+ dump(ret, score_file)
+ return ret
+
+
+class MMVet(ImageBaseDataset):
+ TYPE = 'VQA'
+ DATASET_URL = {
+ 'MMVet': 'https://opencompass.openxlab.space/utils/VLMEval/MMVet.tsv',
+ 'MMVet_Hard': 'http://opencompass.openxlab.space/utils/VLMEval/MMVet_Hard.tsv'
+ }
+ DATASET_MD5 = {'MMVet': '748aa6d4aa9d4de798306a63718455e3', 'MMVet_Hard': '63a598819a936a2e77c410a78a21ff16'}
+
+ # It returns a DataFrame
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.mmvet import MMVet_auxeval, MMVet_acc
+
+ suffix = eval_file.split('.')[-1]
+ model = judge_kwargs['model']
+ storage = eval_file.replace(f'.{suffix}', f'_{model}.xlsx')
+ tmp_file = eval_file.replace(f'.{suffix}', f'_{model}.pkl')
+ nproc = judge_kwargs.pop('nproc', 4)
+ if not osp.exists(storage):
+ data = load(eval_file)
+ model = build_judge(max_tokens=3, **judge_kwargs)
+ assert model.working(), ('MMVet evaluation requires a working OPENAI API\n' + DEBUG_MESSAGE)
+
+ lt = len(data)
+ lines = [data.iloc[i] for i in range(lt)]
+ tups = [(model, line) for line in lines]
+ indices = [line['index'] for line in lines]
+
+ ans = load(tmp_file) if osp.exists(tmp_file) else {}
+ tups = [x for x, i in zip(tups, indices) if i not in ans]
+ indices = [i for i in indices if i not in ans]
+
+ if len(indices):
+ new_results = track_progress_rich(
+ MMVet_auxeval,
+ tups,
+ nproc=nproc,
+ chunksize=nproc,
+ keys=indices,
+ save=tmp_file,
+ )
+ ans = load(tmp_file)
+ for k, v in zip(indices, new_results):
+ assert k in ans
+ assert ans[k]['log'] == v['log'] and ans[k]['score'] == v['score']
+ data['score'] = [ans[idx]['score'] for idx in data['index']]
+ data['log'] = [ans[idx]['log'] for idx in data['index']]
+ dump(data, storage)
+
+ score, score_fine = MMVet_acc(storage)
+ score_pth = storage.replace('.xlsx', '_score.csv')
+ score_fine_pth = storage.replace('.xlsx', '_score_fine.csv')
+ dump(score, score_pth)
+ dump(score_fine, score_fine_pth)
+ return score
+
+
+class MTVQADataset(ImageBaseDataset):
+ TYPE = 'VQA'
+ DATASET_URL = {'MTVQA_TEST': 'https://opencompass.openxlab.space/utils/VLMEval/MTVQA_TEST.tsv'}
+ DATASET_MD5 = {'MTVQA_TEST': 'd87c17dbab934b7cd89c0a3c1c5657f4'}
+
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ data = load(eval_file)
+ assert 'answer' in data and 'prediction' in data and 'category' in data
+ data['prediction'] = [str(x) for x in data['prediction']]
+ data['answer'] = [str(x) for x in data['answer']]
+ if 'split' in data:
+ assert np.all([x.lower() == 'test' for x in data['split']]), 'We only support MTVQA_TEST for now. '
+ lt = len(data)
+ category_scores = defaultdict(list)
+ for i in range(lt):
+ line = data.iloc[i]
+ ans = line['answer'].strip().lower().replace('.', '')
+ pred = line['prediction'].strip().lower().replace('.', '')
+ cate = line['category']
+ score = 1.0 if ans in pred else 0.0
+ category_scores[cate].append(score)
+ category_scores['Average'].append(score)
+ # Calculate the average score for each category, the score is normalized to [0, 100]
+ category_averages = {category: np.mean(scores) * 100 for category, scores in category_scores.items()}
+
+ suffix = eval_file.split('.')[-1]
+ result_file = eval_file.replace(f'.{suffix}', '_acc.json')
+ dump(category_averages, result_file)
+
+ return category_averages
+
+ # MT-VQA adopts a custom prompt
+ def build_prompt(self, line):
+ msgs = super().build_prompt(line)
+ assert sum([x['type'] == 'text' for x in msgs]) == 1
+ for item in msgs:
+ if item['type'] == 'text':
+ item['value'] += '\nAnswer the question using a word or phrase in the language of the question.'
+ return msgs
+
+
+class TableVQABench(ImageBaseDataset):
+ TYPE = 'VQA'
+ DATASET_URL = {
+ 'TableVQABench': 'https://pai-aigc-photog.oss-cn-hangzhou.aliyuncs.com/mentor-vil/datasets/tablevqa-bench.tsv'
+ }
+ DATASET_MD5 = {'TableVQABench': '2550adc61bdc82d8e62f3b003de7c62d'}
+
+ from .utils.tablevqabench import FINTABNETQA_PROMPT, VTABFACT_PROMPT, VWTQ_PROMPT
+
+ # It returns a DataFrame
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ import pandas as pd
+ from .utils.tablevqabench import evaluate_fintabnet, evaluate_tabfact, evaluate_wtq
+
+ data = load(eval_file)
+ assert 'answer' in data and 'prediction' in data
+
+ data['prediction'] = data['prediction'].str.replace('^Answer: ', '', regex=True)
+ data_group = dict(tuple(data.groupby('split')))
+ eval_result = {'split': [], 'average_scores': []}
+ for split in ['fintabnetqa', 'vtabfact', 'vwtq', 'vwtq_syn']:
+ data_split = data_group[split].to_dict(orient='records')
+ if split == 'fintabnetqa':
+ split_eval_meta = evaluate_fintabnet(data_split, ['accuracy'])
+ elif split == 'vtabfact':
+ split_eval_meta = evaluate_tabfact(data_split, ['accuracy'])
+ elif split == 'vwtq' or split == 'vwtq_syn':
+ split_eval_meta = evaluate_wtq(data_split, ['accuracy'])
+ eval_result['split'].append(split)
+ eval_result['average_scores'].append(split_eval_meta['average_scores'])
+
+ suffix = eval_file.split('.')[-1]
+ result_file = eval_file.replace(f'.{suffix}', '_acc.csv')
+ eval_result = pd.DataFrame(eval_result)
+ dump(eval_result, result_file)
+
+ return eval_result
+
+ # TableVQABench adopts a custom prompt
+ def build_prompt(self, line):
+ msgs = super().build_prompt(line)
+ assert sum([x['type'] == 'text' for x in msgs]) == 1
+ for item in msgs:
+ if item['type'] == 'text':
+ if line['split'] == 'fintabnetqa':
+ item['value'] = self.FINTABNETQA_PROMPT.format_map({'question': item['value']})
+ elif line['split'] == 'vtabfact':
+ item['value'] = self.VTABFACT_PROMPT.format_map({'question': item['value']})
+ elif line['split'] == 'vwtq_syn' or line['split'] == 'vwtq':
+ item['value'] = self.VWTQ_PROMPT.format_map({'question': item['value']})
+ return msgs
+
+
+class CustomVQADataset(ImageBaseDataset):
+ TYPE = 'VQA'
+
+ def load_data(self, dataset):
+ data_path = osp.join(LMUDataRoot(), f'{dataset}.tsv')
+
+ if file_size(data_path, 'GB') > 1:
+ local_path = data_path.replace('.tsv', '_local.tsv')
+ if not osp.exists(local_path) or os.environ.get('FORCE_LOCAL', None):
+ from ..tools import LOCALIZE
+
+ LOCALIZE(data_path, local_path)
+ data_path = local_path
+ return load(data_path)
+
+ def evaluate(self, eval_file, **judge_kwargs):
+ raise NotImplementedError
+
+
+class CRPE(ImageBaseDataset):
+ TYPE = 'VQA'
+ DATASET_URL = {
+ 'CRPE_EXIST': 'https://huggingface.co/datasets/petter12321/crpe_vlmevalkit/resolve/main/CRPE_EXIST.tsv',
+ 'CRPE_RELATION': 'https://huggingface.co/datasets/petter12321/crpe_vlmevalkit/resolve/main/CRPE_RELATION.tsv'
+ }
+ DATASET_MD5 = {
+ 'CRPE_EXIST': '315584e23ac1ff7f8719ed3b7ad90f08',
+ 'CRPE_RELATION': 'bad7094cde0b572288f4b119c2d0c656'}
+
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.crpe import is_correct
+ # find-image, count-text, find-text,
+ # infer-choose, count-image, visual-reasoning
+ score = {
+ 'exist': 0,
+ 'subject': 0,
+ 'predicate': 0,
+ 'object': 0,
+ 'total': 0,
+ }
+ num = {
+ 'exist': 0,
+ 'subject': 0,
+ 'predicate': 0,
+ 'object': 0,
+ 'total': 0,
+ }
+ final_score_dict = {
+ 'exist': 0,
+ 'subject': 0,
+ 'predicate': 0,
+ 'object': 0,
+ 'total': 0,
+ }
+ data = load(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'])
+ # print("predict =", predict)
+ # print("answers =", answers)
+ category = line['category']
+ if is_correct(answers, predict):
+ score[category] += 1
+ score['total'] += 1
+ num[category] += 1
+ num['total'] += 1
+
+ for category in ['exist', 'subject', 'predicate', 'object', 'total']:
+ if num[category] != 0:
+ final_score_dict[category] = score[category] / num[category]
+ else:
+ final_score_dict[category] = None
+
+ score_pth = eval_file.replace('.xlsx', '_score.json')
+ dump(final_score_dict, score_pth)
+ return final_score_dict
+
+ def build_prompt(self, line):
+ ROOT = LMUDataRoot()
+ msgs = super().build_prompt(line)
+ for msg in msgs:
+ if msg['type'] == 'image':
+ msg['value'] = osp.join(osp.join(ROOT, 'images', self.dataset_name), msg['value'])
+ return msgs
+
+
+class QSpatial(ImageBaseDataset):
+ TYPE = 'VQA'
+ DATASET_URL = {
+ 'QSpatial_plus': '',
+ 'QSpatial_scannet': ''
+ }
+
+ # NOTE: To evaluate Q-Spatial-ScanNet, you need to get the permission from ScanNet website
+ # Once you get the permission, you can use the helper code here to download and extract necessary images:
+ # https://github.com/andrewliao11/Q-Spatial-Bench-code?tab=readme-ov-file#for-qspatial_scannet
+ qspatial_root = "TO_BE_REPLACED_WITH_THE_PATH_TO_QSPATIAL_DATASET"
+ url = "https://raw.githubusercontent.com/andrewliao11/Q-Spatial-Bench-code/refs/heads/main/prompt_templates/"
+
+ def post_build(self, dataset):
+ # Download the prompt templates from github
+
+ links = [
+ self.url + "system_prompt.txt",
+ self.url + "spatial_prompt_single.txt",
+ self.url + "spatial_prompt_steps.txt",
+ self.url + "standard_prompt.txt",
+ self.url + "zero_shot_prompt.txt"
+ ]
+ with tempfile.TemporaryDirectory() as temp_dir:
+ for link in links:
+ tgt_path = os.path.join(temp_dir, link.split("/")[-1])
+ os.system(f"wget {link} -O {tgt_path}")
+
+ self.system_prompt = open(os.path.join(temp_dir, "system_prompt.txt")).read()
+ self._prompt_templates = dict(
+ spatial_prompt_single=open(os.path.join(temp_dir, "spatial_prompt_single.txt")).read(),
+ spatial_prompt_steps=open(os.path.join(temp_dir, "spatial_prompt_steps.txt")).read(),
+ standard_prompt=open(os.path.join(temp_dir, "standard_prompt.txt")).read(),
+ zero_shot_prompt=open(os.path.join(temp_dir, "zero_shot_prompt.txt")).read(),
+ )
+
+ # Given one data record, return the built prompt (a multi-modal message), can override
+ def build_prompt(self, line):
+ from jinja2.sandbox import SandboxedEnvironment
+ text_prompt_template = self._prompt_templates["spatial_prompt_single"]
+ env = SandboxedEnvironment()
+ text_prompt = env.from_string(text_prompt_template).render(question=line["question"])
+ tgt_path = self.dump_image(line)
+
+ msgs = []
+ if isinstance(tgt_path, list):
+ msgs.extend([dict(type='image', value=p) for p in tgt_path])
+ else:
+ msgs = [dict(type='image', value=tgt_path)]
+
+ msgs.append(dict(type='text', value=f"{self.system_prompt}\n{text_prompt}"))
+ return msgs
+
+ # Given the dataset name, return the dataset as a pandas dataframe, can override
+ def load_data(self, dataset):
+ import io
+ import pandas as pd
+ from datasets import load_dataset
+
+ hf_dataset = load_dataset("andrewliao11/Q-Spatial-Bench", split=dataset)
+ df = hf_dataset.to_pandas()
+
+ df.reset_index(drop=True, inplace=True)
+ df['index'] = df.index
+ df['answer'] = list(zip(df['answer_value'], df['answer_unit']))
+ df = df[['index'] + [col for col in df.columns if col != 'index']]
+
+ if dataset == "QSpatial_scannet":
+ df = df.drop(columns=["image"])
+ df["image"] = [Image.open(os.path.join(self.qspatial_root, image_path)) for image_path in df["image_path"]]
+ else:
+ df["image"] = [Image.open(io.BytesIO(image_dict["bytes"])) for image_dict in df["image"]]
+
+ df["image"] = [encode_image_to_base64(image) for image in df["image"]]
+ return df
+
+ @classmethod
+ def get_multiplier(self, unit):
+
+ unit = unit.lower()
+ if unit in ["meters", "meter", "m", "metre", "metres"]:
+ multiplier = 100
+ elif unit in ["centimeters", "centimeter", "cm"]:
+ multiplier = 1
+ elif unit in ["feet", "foot", "ft"]:
+ multiplier = 30.48
+ elif unit in ["inch", "inches", "in"]:
+ multiplier = 2.54
+ elif unit in ["mm"]:
+ multiplier = 0.1
+ else:
+ print(f"Unknown unit: {unit}")
+ multiplier = 0.
+
+ return multiplier
+
+ @classmethod
+ def parse_string(self, input_str):
+ # Regular expression to match the pattern (number or range, text)
+ match = re.match(r'\(([\d.-]+), (.+)\)', input_str)
+ if match:
+ number_part = match.group(1)
+ text = match.group(2)
+
+ if '-' in number_part:
+ start, end = map(float, number_part.split('-'))
+ number = (start + end) / 2
+ else:
+ number = float(number_part)
+
+ return number * self.get_multiplier(text)
+ else:
+ print(f"Unable to parse the input string {input_str}")
+ return 0
+
+ @classmethod
+ def parse_prediction(self, vlm_response):
+ # Value
+ pattern = r'scalar{([^}]*)}'
+ str_inside_scalar_boxes = re.findall(pattern, vlm_response)[-1]
+ scalar_list = re.findall(r'\d+\.?\d*', str_inside_scalar_boxes)
+ parsed_scalar = np.array(scalar_list).astype(float).mean()
+
+ # Unit
+ pattern = r'distance_unit{([^}]*)}'
+ str_inside_unit_boxes = re.findall(pattern, vlm_response)
+ parsed_unit = str_inside_unit_boxes[-1]
+
+ pred_value_in_cms = parsed_scalar * self.get_multiplier(parsed_unit)
+ return pred_value_in_cms
+
+ # It returns a dictionary
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+
+ data = load(eval_file)
+ if "model" in judge_kwargs:
+ from .utils.qspatial import QSpatial_auxeval
+
+ # extract using model
+ model = judge_kwargs['model']
+ suffix = eval_file.split('.')[-1]
+ storage = eval_file.replace(f'.{suffix}', f'_{model}.xlsx')
+ tmp_file = eval_file.replace(f'.{suffix}', f'_{model}.pkl')
+ nproc = judge_kwargs.pop('nproc', 4)
+
+ if not osp.exists(storage):
+ model = build_judge(max_tokens=128, **judge_kwargs)
+
+ assert model.working(), ('Evaluation requires a working OPENAI API\n' + DEBUG_MESSAGE)
+ lt = len(data)
+ lines = [data.iloc[i] for i in range(lt)]
+ tups = [(model, line) for line in lines]
+ indices = [line['index'] for line in lines]
+
+ ans = {}
+ if osp.exists(tmp_file):
+ ans = load(tmp_file)
+ tups = [x for x, i in zip(tups, indices) if i not in ans]
+ indices = [i for i in indices if i not in ans]
+
+ if len(indices):
+ new_results = track_progress_rich(
+ QSpatial_auxeval,
+ tups,
+ nproc=nproc,
+ chunksize=nproc,
+ keys=indices,
+ save=tmp_file,
+ )
+ ans = load(tmp_file)
+ for k, v in zip(indices, new_results):
+ assert k in ans
+ assert ans[k]['log'] == v['log'] and ans[k]['res'] == v['res']
+
+ data['res'] = [ans[idx]['res'] for idx in data['index']]
+ data['log'] = [ans[idx]['log'] for idx in data['index']]
+ dump(data, storage)
+
+ data = load(storage)
+
+ pred_value_in_cms = []
+ for res in data["res"]:
+ try:
+ pred_value_in_cms.append(self.parse_string(res))
+ except ValueError:
+ pred_value_in_cms.append(0.)
+
+ pred_value_in_cms = np.array(pred_value_in_cms) + 1e-8
+ else:
+ # regex parsing
+ pred_value_in_cms = []
+ n_errors_in_parsing = 0
+ for pred in data["prediction"]:
+ try:
+ parsed_value = self.parse_prediction(pred)
+ except IndexError:
+ n_errors_in_parsing += 1
+ parsed_value = 1e-8
+
+ pred_value_in_cms.append(parsed_value)
+
+ print(f"Encounter {n_errors_in_parsing} errors in parsing")
+ pred_value_in_cms = np.array(pred_value_in_cms) + 1e-8
+
+ # Ground truth
+ ground_truth_value_in_cms = []
+ for answer in data["answer"]:
+ value, unit = eval(answer)
+ ground_truth_value_in_cms.append(value * self.get_multiplier(unit))
+ ground_truth_value_in_cms = np.array(ground_truth_value_in_cms) + 1e-8
+
+ # Calculate the score
+ pred_gt = pred_value_in_cms / ground_truth_value_in_cms
+ gt_pred = ground_truth_value_in_cms / pred_value_in_cms
+ delta_2 = np.stack([pred_gt, gt_pred]).max(0) < 2.
+ delta_1_point_5 = np.stack([pred_gt, gt_pred]).max(0) < 1.5
+
+ data["eval_score_delta_2"] = delta_2
+ data["eval_score_delta_1_point_5"] = delta_1_point_5
+
+ final_score_dict = {
+ "delta_2": delta_2.mean(),
+ "delta_1_point_5": delta_1_point_5.mean()
+ }
+ for question_type in set(data["question_type"]):
+ filtered_data = data[data["question_type"] == question_type]
+ delta_2_per_question_type = filtered_data["eval_score_delta_2"].mean()
+ delta_1_point_5_per_question_type = filtered_data["eval_score_delta_1_point_5"].mean()
+ final_score_dict.update({f"{question_type}_delta_2": delta_2_per_question_type})
+ final_score_dict.update({f"{question_type}_delta_1_point_5": delta_1_point_5_per_question_type})
+
+ score_pth = eval_file.replace('.xlsx', '_score.json')
+ dump(final_score_dict, score_pth)
+ return final_score_dict
+
+
+class MMNIAH(ImageBaseDataset):
+ TYPE = 'VQA'
+ DATASET_URL = {
+ 'MM_NIAH_VAL':
+ 'https://huggingface.co/datasets/petter12321/MM-NIAH-VLMEvalKit/resolve/main/MM_NIAH_VAL.tsv',
+ 'MM_NIAH_TEST':
+ ['https://huggingface.co/datasets/petter12321/MM-NIAH-VLMEvalKit/resolve/main/part-aa',
+ 'https://huggingface.co/datasets/petter12321/MM-NIAH-VLMEvalKit/resolve/main/part-ab',
+ 'https://huggingface.co/datasets/petter12321/MM-NIAH-VLMEvalKit/resolve/main/part-ac',
+ 'https://huggingface.co/datasets/petter12321/MM-NIAH-VLMEvalKit/resolve/main/part-ad',
+ 'https://huggingface.co/datasets/petter12321/MM-NIAH-VLMEvalKit/resolve/main/part-ae']}
+ DATASET_MD5 = {'MM_NIAH_VAL': '27e5a8c3cef7746cb38f89cd86c474c5',
+ 'MM_NIAH_TEST': 'f490eb2a43096307465fe9e7ef13497c'}
+
+ def prepare_tsv(self, url, file_md5=None):
+ import os
+ data_root = LMUDataRoot()
+ os.makedirs(data_root, exist_ok=True)
+ update_flag = False
+ file_name = 'MM_NIAH_VAL.tsv' if 'MM_NIAH_VAL' in url else 'MM_NIAH_TEST.tsv'
+ data_path = osp.join(data_root, file_name)
+ if osp.exists(data_path) and (file_md5 is None or md5(data_path) == file_md5):
+ pass
+ elif file_name == 'MM_NIAH_TEST.tsv':
+ warnings.warn('The dataset tsv is not downloaded')
+ for i in range(len(url)):
+ if osp.exists(osp.join(data_root, 'part-a' + chr(ord('a') + i))):
+ print('part_a' + chr(ord('a') + i) + ' is existed')
+ continue
+ download_file(url[i], data_path)
+ file_prefix = 'part-'
+ output_file = data_path
+ split_files = sorted([f for f in os.listdir(data_root) if f.startswith(file_prefix)])
+ with open(output_file, 'wb') as outfile:
+ # 逐个读取每个拆分文件并写入到输出文件
+ for filename in split_files:
+ with open(osp.join(data_root, filename), 'rb') as infile:
+ outfile.write(infile.read())
+ update_flag = True
+ else:
+ warnings.warn('The dataset tsv is not downloaded')
+ download_file(url, data_path)
+ update_flag = True
+
+ if file_size(data_path, 'GB') > 1:
+ local_path = data_path.replace('.tsv', '_local.tsv')
+ if not osp.exists(local_path) or os.environ.get('FORCE_LOCAL', None) or update_flag:
+ from ..tools import LOCALIZE
+ LOCALIZE(data_path, local_path)
+ data_path = local_path
+ return load(data_path)
+
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.mmniah import is_correct
+ # find-image, count-text, find-text,
+ # infer-choose, count-image, visual-reasoning
+ MMNIAH_score = {
+ 'count-text': 0,
+ 'find-image': 0,
+ 'find-text': 0,
+ 'infer-choose': 0,
+ 'count-image': 0,
+ 'visual-reasoning': 0,
+ 'total': 0,
+ }
+ MMNIAH_num = {
+ 'count-text': 0,
+ 'find-image': 0,
+ 'find-text': 0,
+ 'infer-choose': 0,
+ 'count-image': 0,
+ 'visual-reasoning': 0,
+ 'total': 0,
+ }
+ final_score_dict = {
+ 'count-text': 0,
+ 'find-image': 0,
+ 'find-text': 0,
+ 'infer-choose': 0,
+ 'count-image': 0,
+ 'visual-reasoning': 0,
+ 'total': 0,
+ }
+ data = load(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 = line['prediction']
+ answers = line['answer']
+ category = line['category']
+ if category in ['visual-reasoning', 'find-image']:
+ answers = int(answers)
+ if is_correct(answers, predict):
+ MMNIAH_score[category] += 1
+ MMNIAH_score['total'] += 1
+ MMNIAH_num[category] += 1
+ MMNIAH_num['total'] += 1
+
+ for category in ['find-image', 'count-text', 'find-text',
+ 'infer-choose', 'count-image', 'visual-reasoning', 'total']:
+ if MMNIAH_num[category] != 0:
+ final_score_dict[category] = MMNIAH_score[category] / MMNIAH_num[category]
+ else:
+ final_score_dict[category] = None
+
+ score_pth = eval_file.replace('.xlsx', '_score.json')
+ dump(final_score_dict, score_pth)
+ return final_score_dict
+
+ def build_prompt(self, line):
+ msgs = super().build_prompt(line)
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+ totalchoice = line['multi-choice options']
+ totalchoice = eval(totalchoice)
+ # find-image, count-text, find-text,
+ # infer-choose, count-image, visual-reasoning
+ context = msgs[-1]['value']
+ context = eval(context)
+ question = context[0] + '\n' + context[1]
+ # tgt_path是所有图像地址列表
+ tgt_path = []
+ for i in range(len(msgs) - 1):
+ tgt_path.append(msgs[i]['value'])
+ choices = totalchoice[0]
+ choices_image = totalchoice[1]
+ if choices:
+ for c_idx, c in enumerate(choices):
+ question = f"{question}\n{chr(c_idx + ord('A'))}. {c}"
+ question += "\nAnswer with the option's letter from the given choices directly."
+ elif choices_image:
+ for c_idx in range(len(choices_image)):
+ question = f"{question}\n{chr(c_idx + ord('A'))}. "
+ question += "\nAnswer with the option's letter from the given choices directly."
+ else:
+ question += '\nAnswer the question using a single word or phrase.'
+ question = '' + question + ''
+ question = question.split('')
+ if choices_image:
+ for i in range(len(question) - 5):
+ question[i] = question[i] + '\n'
+ for i in range(len(question) - 5, len(question) - 1):
+ question[i] = question[i] + ''
+ else:
+ for i in range(len(question) - 1):
+ question[i] = question[i] + '\n'
+ assert len(tgt_path) + 1 == len(question)
+ context = []
+ for i in range(len(tgt_path)):
+ context.append(question[i])
+ context.append(tgt_path[i])
+ context.append(question[-1])
+ context[0] = context[0][7:]
+ context[-1] = context[-1][:-5]
+ msgs = []
+ for i in range(len(context)):
+ if i % 2 == 0:
+ msgs.append(dict(type='text', value=context[i]))
+ else:
+ ROOT = LMUDataRoot()
+ msgs.append(dict(type='image', value=osp.join(osp.join(ROOT, 'images', self.dataset_name), context[i])))
+ for element in msgs:
+ if element['value'] == '':
+ msgs.remove(element)
+ return msgs
diff --git a/vlmeval/dataset/image_yorn.py b/vlmeval/dataset/image_yorn.py
new file mode 100644
index 0000000000000000000000000000000000000000..46083e6c3b8147901448a8919d20d3e58dfc2b9f
--- /dev/null
+++ b/vlmeval/dataset/image_yorn.py
@@ -0,0 +1,95 @@
+from ..smp import *
+from ..utils import *
+from .image_base import ImageBaseDataset
+from .utils import build_judge, DEBUG_MESSAGE
+
+
+class ImageYORNDataset(ImageBaseDataset):
+
+ TYPE = 'Y/N'
+
+ DATASET_URL = {
+ 'MME': 'https://opencompass.openxlab.space/utils/VLMEval/MME.tsv',
+ 'HallusionBench': 'https://opencompass.openxlab.space/utils/VLMEval/HallusionBench.tsv',
+ 'POPE': 'https://opencompass.openxlab.space/utils/VLMEval/POPE.tsv',
+ 'AMBER': 'https://huggingface.co/datasets/yifanzhang114/AMBER_base64/resolve/main/AMBER.tsv',
+ }
+
+ DATASET_MD5 = {
+ 'MME': 'b36b43c3f09801f5d368627fb92187c3',
+ 'HallusionBench': '0c23ac0dc9ef46832d7a24504f2a0c7c',
+ 'POPE': 'c12f5acb142f2ef1f85a26ba2fbe41d5',
+ 'AMBER': '970d94c0410916166e0a76ba75da7934',
+ }
+
+ # It returns a dataframe
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.yorn import YOrN_Extraction, YOrN_auxeval
+ from .utils.yorn import default_rating, MME_rating, Hallusion_rating, POPE_rating, AMBER_rating
+
+ dataset = self.dataset_name
+ data = load(eval_file)
+ data['prediction'] = [str(x) for x in data['prediction']]
+ storage = eval_file.replace('.xlsx', '_auxmatch.xlsx')
+ tmp_file = eval_file.replace('.xlsx', '_tmp.pkl')
+ nproc = judge_kwargs.pop('nproc', 4)
+
+ if not osp.exists(storage):
+ ans_map = {k: YOrN_Extraction(v) for k, v in zip(data['index'], data['prediction'])}
+ if osp.exists(tmp_file):
+ tmp = load(tmp_file)
+ for k in tmp:
+ if ans_map[k] == 'Unknown' and tmp[k] != 'Unknown':
+ ans_map[k] = tmp[k]
+
+ data['extracted'] = [ans_map[x] for x in data['index']]
+ unknown = data[data['extracted'] == 'Unknown']
+
+ model = judge_kwargs.get('model', 'exact_matching')
+ if model == 'exact_matching':
+ model = None
+ elif gpt_key_set():
+ model = build_judge(**judge_kwargs)
+ if not model.working():
+ warnings.warn('OPENAI API is not working properly, will use exact matching for evaluation')
+ warnings.warn(DEBUG_MESSAGE)
+ model = None
+ else:
+ model = None
+ warnings.warn('OPENAI_API_KEY is not working properly, will use exact matching for evaluation')
+
+ if model is not None:
+ lt = len(unknown)
+ lines = [unknown.iloc[i] for i in range(lt)]
+ tups = [(model, line) for line in lines]
+ indices = list(unknown['index'])
+ if len(tups):
+ res = track_progress_rich(
+ YOrN_auxeval, tups, nproc=nproc, chunksize=nproc, keys=indices, save=tmp_file)
+ for k, v in zip(indices, res):
+ ans_map[k] = v
+
+ data['extracted'] = [ans_map[x] for x in data['index']]
+ dump(data, storage)
+
+ data = load(storage)
+ if listinstr(['AMBER'], dataset):
+ data['score'] = (data['answer'].str.lower() == data['extracted'].str.lower())
+ else:
+ data['score'] = (data['answer'] == data['extracted'])
+ dump(data, storage)
+
+ if dataset is not None and listinstr(['MME'], dataset):
+ score = MME_rating(storage)
+ elif dataset is not None and listinstr(['Hallusion'], dataset):
+ score = Hallusion_rating(storage)
+ elif dataset is not None and listinstr(['POPE'], dataset):
+ score = POPE_rating(storage)
+ elif dataset is not None and listinstr(['AMBER'], dataset):
+ score = AMBER_rating(storage)
+ else:
+ score = default_rating(storage)
+
+ score_tgt = eval_file.replace('.xlsx', '_score.csv')
+ dump(score, score_tgt)
+ return score
diff --git a/vlmeval/dataset/longvideobench.py b/vlmeval/dataset/longvideobench.py
new file mode 100644
index 0000000000000000000000000000000000000000..5204713b1a3f04da2e13daff8b15edfda5233762
--- /dev/null
+++ b/vlmeval/dataset/longvideobench.py
@@ -0,0 +1,328 @@
+from huggingface_hub import snapshot_download
+from ..smp import *
+from .video_base import VideoBaseDataset
+from .utils import build_judge, DEBUG_MESSAGE
+from glob import glob
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+def timestamp_to_seconds(timestamp):
+ # Split the timestamp into hours, minutes, and seconds
+ h, m, s = timestamp.split(":")
+ # Convert hours, minutes, and total seconds (including fractions) to float and compute total seconds
+ total_seconds = int(h) * 3600 + int(m) * 60 + float(s)
+ return total_seconds
+
+
+def uniformly_subsample(lst, K):
+ n = len(lst)
+ if K >= n:
+ return lst
+ step = n / K
+ return [lst[int(i * step)] for i in range(K)]
+
+
+def insert_subtitles_into_frames(
+ frames,
+ frame_timestamps,
+ subtitles,
+ starting_timestamp_for_subtitles,
+ duration,
+):
+ interleaved_list = []
+ cur_i = 0
+
+ for subtitle in subtitles:
+ if "timestamp" in subtitle:
+ start, end = subtitle["timestamp"]
+
+ if not isinstance(end, float):
+ end = duration
+
+ start -= starting_timestamp_for_subtitles
+ end -= starting_timestamp_for_subtitles
+
+ subtitle_timestamp = (start + end) / 2
+ subtitle_text = subtitle["text"]
+ else:
+ start, end = subtitle["start"], subtitle["end"]
+ start = timestamp_to_seconds(start)
+ end = timestamp_to_seconds(end)
+ start -= starting_timestamp_for_subtitles
+ end -= starting_timestamp_for_subtitles
+
+ subtitle_timestamp = (start + end) / 2
+ subtitle_text = subtitle["line"]
+
+ for i, (frame, frame_timestamp) in enumerate(
+ zip(frames[cur_i:], frame_timestamps[cur_i:])
+ ):
+ if frame_timestamp <= subtitle_timestamp:
+ # print("frame:", frame_timestamp)
+ interleaved_list.append({"type": "image", "value": frame})
+ cur_i += 1
+ else:
+ break
+
+ if end - start < 1:
+ end = subtitle_timestamp + 0.5
+ start = subtitle_timestamp - 0.5
+
+ covering_frames = False
+ for frame, frame_timestamp in zip(frames, frame_timestamps):
+ if frame_timestamp < end and frame_timestamp > start:
+ covering_frames = True
+ break
+
+ if covering_frames:
+ interleaved_list.append({"type": "text", "value": subtitle_text + "\n"})
+ else:
+ pass
+
+ for i, (frame, frame_timestamp) in enumerate(
+ zip(frames[cur_i:], frame_timestamps[cur_i:])
+ ):
+ interleaved_list.append({"type": "image", "value": frame})
+ return interleaved_list
+
+
+class LongVideoBench(VideoBaseDataset):
+
+ MD5 = '82905eae3a5ae7383c5a8ee9655e1ab9'
+ SYS = ''
+
+ TYPE = 'Video-MCQ'
+
+ def __init__(self, dataset='LongVideoBench', use_subtitle=False, nframe=0, fps=-1):
+ super().__init__(dataset=dataset, nframe=nframe, fps=fps)
+ self.use_subtitle = use_subtitle
+ self.dataset_name = dataset
+
+ @classmethod
+ def supported_datasets(cls):
+ return ['LongVideoBench']
+
+ def prepare_dataset(self, dataset_name='LongVideoBench', repo_id='longvideobench/LongVideoBench'):
+
+ def check_integrity(pth):
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+
+ if not osp.exists(data_file):
+ return False
+
+ if md5(data_file) != self.MD5:
+ print("md5 mismatch", md5(data_file), self.MD5)
+ return False
+ data = load(data_file)
+ for video_pth in data['video_path']:
+ if not osp.exists(osp.join(pth, video_pth)):
+ print(video_pth, "is not found")
+ return False
+ return True
+
+ if modelscope_flag_set():
+ repo_id = "AI-ModelScope/LongVideoBench"
+
+ cache_path = get_cache_path(repo_id)
+ if cache_path is not None and check_integrity(cache_path):
+ dataset_path = cache_path
+ else:
+ def generate_tsv(pth):
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+ if osp.exists(data_file) and md5(data_file) == self.MD5:
+ return
+
+ data_file = pd.read_json(osp.join(pth, 'lvb_val.json'))
+ data_file = data_file.assign(index=range(len(data_file)))
+ data_file['video'] = data_file['video_id']
+ data_file['video_path'] = data_file['video_path'].apply(lambda x: f'./videos/{x}')
+
+ data_file.to_csv(osp.join(pth, f'{dataset_name}.tsv'), sep='\t', index=False)
+
+ if modelscope_flag_set():
+ from modelscope import dataset_snapshot_download
+ dataset_snapshot_download(dataset_id=repo_id)
+ else:
+ snapshot_download(repo_id=repo_id, repo_type='dataset')
+ print("All videos are downloaded for LongVideoBench")
+
+ if not glob(osp.join(cache_path, "videos")):
+ tar_files = glob(osp.join(cache_path, "**/*.tar*"), recursive=True)
+
+ def untar_video_data(tar_file, cache_dir):
+ import tarfile
+ with tarfile.open(tar_file, "r") as tar_ref:
+ tar_ref.extractall(cache_dir)
+ print(f"Extracted all files from {tar_file} to {cache_dir}")
+
+ def concat_tar_parts(tar_parts, output_tar):
+ with open(output_tar, "wb") as out_tar:
+ from tqdm import tqdm
+ for part in tqdm(sorted(tar_parts)):
+ with open(part, "rb") as part_file:
+ out_tar.write(part_file.read())
+ print(f"Concatenated parts {tar_parts} into {output_tar}")
+
+ tar_parts_dict = {}
+
+ # Group tar parts together
+ for tar_file in tar_files:
+ base_name = tar_file.split(".tar")[0]
+ if base_name not in tar_parts_dict:
+ tar_parts_dict[base_name] = []
+ tar_parts_dict[base_name].append(tar_file)
+
+ # Concatenate and untar split parts
+ for base_name, parts in tar_parts_dict.items():
+ print(f"Extracting following tar files: {parts}")
+ output_tar = base_name + ".tar"
+ if not osp.exists(output_tar):
+ print('Start concatenating tar files')
+
+ concat_tar_parts(parts, output_tar)
+ print('Finish concatenating tar files')
+
+ if not osp.exists(osp.join(cache_path, osp.basename(base_name))):
+ untar_video_data(output_tar, cache_path)
+
+ print('All videos are extracted for LongVideoBench')
+
+ dataset_path = cache_path
+ generate_tsv(dataset_path)
+
+ data_file = osp.join(dataset_path, f'{dataset_name}.tsv')
+
+ return dict(data_file=data_file, root=dataset_path)
+
+ def save_video_frames(self, video_path, video_llm=False):
+
+ vid_path = osp.join(self.data_root, video_path)
+ vid = decord.VideoReader(vid_path)
+ video_info = {
+ 'fps': vid.get_avg_fps(),
+ 'n_frames': len(vid),
+ }
+ if self.nframe > 0 and self.fps < 0:
+ step_size = len(vid) / (self.nframe + 1)
+ indices = [int(i * step_size) for i in range(1, self.nframe + 1)]
+ frame_paths = self.frame_paths(video_path[:-4])
+ elif self.fps > 0:
+ # not constrained by num_frames, get frames by fps
+ total_duration = video_info['n_frames'] / video_info['fps']
+ required_frames = int(total_duration * self.fps)
+ step_size = video_info['fps'] / self.fps
+ indices = [int(i * step_size) for i in range(required_frames)]
+ frame_paths = self.frame_paths_fps(video_path[:-4], len(indices))
+
+ flag = np.all([osp.exists(p) for p in frame_paths])
+
+ if not flag:
+ images = [vid[i].asnumpy() for i in indices]
+ images = [Image.fromarray(arr) for arr in images]
+ for im, pth in zip(images, frame_paths):
+ if not osp.exists(pth) and not video_llm:
+ im.save(pth)
+
+ return frame_paths, indices, video_info
+
+ # def save_video_into_images(self, line, num_frames=8):
+ # frame_paths, indices, video_info = self.save_video_frames(line['video_path'], num_frames)
+ # return frame_paths
+
+ def build_prompt(self, line, video_llm):
+ if isinstance(line, int):
+ assert line < len(self)
+ line = self.data.iloc[line]
+
+ frames, indices, video_info = self.save_video_frames(line['video_path'], video_llm)
+ fps = video_info["fps"]
+
+ message = [dict(type='text', value=self.SYS)]
+ if video_llm:
+ message.append(dict(type='video', value=osp.join(self.data_root, line['video_path'])))
+ else:
+ if not self.use_subtitle:
+ with open(osp.join(self.data_root, "subtitles", line["subtitle_path"])) as f:
+ subtitles = json.load(f)
+
+ frame_message = insert_subtitles_into_frames(
+ frames,
+ [ind_ / fps for ind_ in indices],
+ subtitles,
+ line["starting_timestamp_for_subtitles"],
+ line["duration"]
+ )
+
+ message += frame_message
+ else:
+ for im in frames:
+ message.append(dict(type='image', value=im))
+
+ line['question'] += '\n' + '\n'.join(
+ ["{}. {}".format(chr(ord("A") + i), cand) for i, cand in enumerate(eval(line['candidates']))]
+ )
+ prompt = line["question"] + "\nAnswer with the option's letter from the given choices directly."
+ message.append(dict(type='text', value=prompt))
+ return message
+
+ # It returns a dictionary
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.longvideobench import get_dimension_rating, extract_characters_regex, extract_option
+
+ assert eval_file.endswith('.xlsx'), 'data file should be an xlsx file'
+
+ tmp_file = eval_file.replace('.xlsx', '_tmp.pkl')
+ tgt_file = eval_file.replace('.xlsx', '_rating.json')
+ score_file = eval_file.replace('.xlsx', '_score.xlsx')
+
+ if not osp.exists(score_file):
+ model = judge_kwargs.get('model', 'exact_matching')
+ assert model in ['chatgpt-0125', 'exact_matching', 'gpt-4-0125']
+
+ if model == 'exact_matching':
+ model = None
+ elif gpt_key_set():
+ model = build_judge(**judge_kwargs)
+ if not model.working():
+ warnings.warn('OPENAI API is not working properly, will use exact matching for evaluation')
+ warnings.warn(DEBUG_MESSAGE)
+ model = None
+ else:
+ warnings.warn('OPENAI_API_KEY is not set properly, will use exact matching for evaluation')
+ model = None
+ res = {} if not osp.exists(tmp_file) else load(tmp_file)
+ res = {k: v for k, v in res.items() if FAIL_MSG not in v}
+
+ data = load(eval_file)
+ data_un = data[~pd.isna(data['prediction'])]
+
+ for idx in data['index']:
+ ans = data.loc[data['index'] == idx, 'correct_choice'].values[0]
+ ans = chr(ord("A") + ans)
+ pred = str(data.loc[data['index'] == idx, 'prediction'].values[0])
+
+ if extract_characters_regex(pred) == '':
+ extract_pred = extract_option(
+ model,
+ data.loc[data['index'] == idx].to_dict(orient='records')[0],
+ 'LongVideoBench'
+ )
+ data.loc[idx, 'score'] = int(extract_pred == ans)
+ else:
+ data.loc[idx, 'score'] = int(extract_characters_regex(pred) == ans)
+
+ rejected = [x for x in data['score'] if x == -1]
+
+ print(
+ f'Among {len(data)} questions, failed to obtain prediction for {len(data) - len(data_un)} questions, '
+ f'failed to obtain the score for another {len(rejected)} questions. '
+ f'Those questions will be counted as -1 score in ALL rating, and will not be counted in VALID rating.'
+ )
+
+ dump(data, score_file)
+
+ rating = get_dimension_rating(score_file)
+ dump(rating, tgt_file)
+ return rating
diff --git a/vlmeval/dataset/megabench.py b/vlmeval/dataset/megabench.py
new file mode 100644
index 0000000000000000000000000000000000000000..6f1831a5049679d3b0824f7e8b4fd14da0361f52
--- /dev/null
+++ b/vlmeval/dataset/megabench.py
@@ -0,0 +1,435 @@
+import math
+import re
+import tempfile
+import cv2
+from vlmeval.smp import *
+from vlmeval.dataset.video_base import VideoBaseDataset
+from vlmeval.dataset.utils.megabench.evaluator import MEGABenchEvaluator
+import json
+import glob
+
+
+class MEGABench(VideoBaseDataset):
+ TYPE = 'Video-VQA'
+ ZIP_MD5 = '5ec01ab69cd25b643c4f5e1396e96441'
+ MODALITY = 'VIDEO'
+
+ def __init__(self, dataset='MEGABench', use_subtitle=False, nframe=0, fps=-1, subset_name="core"):
+ self.subset_name = subset_name
+ super().__init__(dataset=dataset, nframe=nframe, fps=fps)
+ self.use_subtitle = use_subtitle
+ self.dataset_name = dataset
+ self.max_num_frames = nframe
+ self.total_demo_video_frames = nframe / 4
+ self.max_side = 1000
+
+ def _set_sampling_config(self, line):
+ def count_videos(media_str):
+ if not media_str or media_str == '[]':
+ return 0
+ try:
+ media_list = eval(str(media_str))
+ num_videos = sum(1 for m in media_list if self.is_video_file(m))
+ return num_videos
+ except:
+ return 0
+
+ num_query_videos = 0
+ num_demo_videos = 0
+
+ num_query_videos += count_videos(line['global_media'])
+ num_demo_videos += count_videos(line['example_media'])
+ num_query_videos += count_videos(line['query_media'])
+
+ # print("num_query_videos, num_demo_videos:", num_query_videos, num_demo_videos)
+
+ if hasattr(self, 'max_num_frames') and self.max_num_frames:
+ if num_demo_videos > 0:
+ self.demo_video_frames = math.ceil(
+ self.total_demo_video_frames / num_demo_videos
+ ) if hasattr(self, 'total_demo_video_frames') else 2
+ else:
+ self.demo_video_frames = 0
+
+ if num_query_videos > 0:
+ total_query_video_frames = (
+ self.max_num_frames
+ - self.demo_video_frames * num_demo_videos
+ )
+ if total_query_video_frames <= 0:
+ raise ValueError(
+ f"Cannot query <= 0 frames: please raise the number of maximum images allowed. "
+ f"demo_video_frames={self.demo_video_frames}, num_demo_videos={num_demo_videos}, "
+ f"max_num_frames={self.max_num_frames}"
+ )
+ self.query_video_frames = total_query_video_frames // num_query_videos
+ else:
+ self.query_video_frames = 0
+
+ else:
+ self.demo_video_frames = 2
+ self.query_video_frames = 8
+
+ # print("demo_video_frames, query_video_frames:", self.demo_video_frames, self.query_video_frames)
+
+ def is_video_file(self, file_path):
+ from mimetypes import guess_type
+ mime_type, _ = guess_type(file_path)
+ if not mime_type:
+ return False
+ return mime_type.startswith("video")
+
+ @classmethod
+ def supported_datasets(cls):
+ return ['MEGABench']
+
+ def prepare_dataset(self, dataset_name='MEGABench', repo_id='TIGER-Lab/MEGA-Bench'):
+ def not_integrity(dataset_path):
+ zip_file = osp.join(dataset_path, 'data.zip')
+ return self.ZIP_MD5 != md5(zip_file)
+
+ def unzip_hf_zip(pth, hub_pth):
+ dataset_path = osp.join(pth, 'images') # LMUData/images
+ os.makedirs(dataset_path, exist_ok=True)
+
+ # 解压到megabench目录
+ extract_path = osp.join(dataset_path, 'MEGABench')
+ if not osp.exists(extract_path):
+ zip_path = osp.join(hub_pth, 'data.zip')
+ import zipfile
+ with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+ zip_ref.extractall(extract_path)
+ return extract_path
+
+ def generate_tsv(pth, data_file, dataset, split='test'):
+ if osp.exists(data_file):
+ print(f'TSV file already exists at {data_file}')
+ return
+
+ def process_media_path(media_str, base_path):
+ if media_str == '[]':
+ return media_str
+ try:
+ media_list = eval(media_str)
+ media_list = [osp.join(base_path, path.lstrip('./')) for path in media_list]
+ return str(media_list)
+ except:
+ return media_str
+
+ def check_field(field):
+ if isinstance(field, str):
+ field = field.replace('\t', ' ')
+ field = ' '.join(field.split())
+ return field
+ return ' '
+
+ with open(data_file, 'w', encoding='utf-8') as f:
+ import csv
+ writer = csv.writer(f, delimiter='\t', quoting=csv.QUOTE_MINIMAL,
+ quotechar='"', escapechar='\\')
+ headers = [
+ 'index', 'task_name', 'task_description', 'global_media',
+ 'example_text', 'example_media', 'question', 'query_media',
+ 'answer', 'metric_info', 'eval_context','video'
+ ]
+ writer.writerow(headers)
+
+ for item in dataset[split]:
+ global_media = process_media_path(str(item['global_media']), pth)
+ example_media = process_media_path(str(item['example_media']), pth)
+ query_media = process_media_path(str(item['query_media']), pth)
+ row = [
+ check_field(str(item['id'])),
+ check_field(item['task_name']),
+ check_field(item['task_description']),
+ check_field(global_media),
+ check_field(item['example_text']),
+ check_field(example_media),
+ check_field(item['query_text']),
+ check_field(query_media),
+ check_field(item['answer']),
+ check_field(item['metric_info']),
+ check_field(item['eval_context']),
+ ]
+ row = [str(field).replace('\t', ' ') for field in row]
+ f.write('\t'.join(row) + '\n')
+
+ print(f'Generated TSV file at {data_file} with {len(dataset[split])} entries')
+
+ from datasets import load_dataset
+ dataset = load_dataset(repo_id, self.subset_name)
+ lmu_root = LMUDataRoot()
+ dataset_path = get_cache_path(repo_id)
+ if dataset_path is None or not_integrity(dataset_path):
+ print(f'download {repo_id} dataset automatically')
+ from huggingface_hub import snapshot_download
+ dataset_path = snapshot_download(repo_id=repo_id, repo_type='dataset')
+ dataset_path = unzip_hf_zip(lmu_root, dataset_path)
+ data_file_path = osp.join(lmu_root, f'{dataset_name}_{self.subset_name}.tsv')
+ generate_tsv(dataset_path, data_file_path, dataset, 'test')
+
+ return dict(data_file=data_file_path, root=dataset_path)
+
+ def build_prompt(self, line, video_llm):
+
+ if isinstance(line, int):
+ assert line < len(self)
+ line = self.data.iloc[line]
+
+ def process_video(file_path, is_demo=False):
+ if video_llm:
+ return (dict(type='video', value=file_path))
+ else:
+ msg = []
+ msg.append(dict(type='text', value=""))
+ msg.extend(_process_video(file_path, is_demo))
+ msg.append(dict(type='text', value=""))
+ return msg
+
+ def _process_video(file_path, is_demo=False):
+ # Open the video file
+ cap = cv2.VideoCapture(file_path)
+ frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+ fps = cap.get(cv2.CAP_PROP_FPS) # Frames per second
+ num_frames = self.demo_video_frames if is_demo else self.query_video_frames
+
+ # the sampling rate using max number of frames
+ sampling_gap_maxframe = (
+ 1 if not num_frames else math.ceil(frame_count / num_frames)
+ )
+
+ if fps >= 10:
+ sampling_gap = max(math.ceil(fps / 5), sampling_gap_maxframe)
+ else:
+ sampling_gap = sampling_gap_maxframe
+
+ frame_number = 0
+ msg = []
+ base_path = osp.splitext(file_path)[0]
+ existing_frames = glob.glob(f"{base_path}_frame_*.jpg")
+ for f in existing_frames:
+ try:
+ os.remove(f)
+ except:
+ pass
+
+ frame_idx = 0
+ while True:
+ success, frame = cap.read()
+ if not success:
+ break
+ # Sample frames based on the dynamic sampling rate
+ if frame_number % sampling_gap == 0:
+ frame_filename = f"{base_path}_frame_{frame_idx:04d}.jpg"
+ os.makedirs(osp.dirname(frame_filename), exist_ok=True)
+ cv2.imwrite(frame_filename, frame)
+ frame_filename = _encode_image(frame_filename)
+ msg.append(dict(type='image', value=frame_filename))
+ frame_idx += 1
+ frame_number += 1
+ if frame_number == 0:
+ raise ValueError(f"Failed to read video from {file_path}, check data...")
+ cap.release()
+
+ return msg
+
+ def _encode_image(image_path):
+ original_path = image_path # 字符串不需要 deepcopy
+ current_path = image_path # 跟踪当前处理阶段的路径
+ image = None
+ rgba_transform = False
+
+ try:
+ # 第一阶段：RGBA 转换
+ image = Image.open(current_path)
+ if image.mode == 'RGBA':
+ try:
+ background = Image.new("RGBA", image.size, (255, 255, 255, 255))
+ image = Image.alpha_composite(background, image).convert("RGB")
+ base_path = osp.splitext(current_path)[0]
+ current_path = f"{base_path}_rgb.jpg"
+ image.save(current_path, "JPEG")
+ print(f'Turn RGBA image into RGB mode, stored to {current_path}')
+ rgba_transform = True
+ except Exception as e:
+ print(f"Warning: Failed to convert RGBA image {current_path}: {e}")
+ # 使用原始图像继续处理
+ image = Image.open(original_path)
+
+ if rgba_transform:
+ original_path = current_path
+
+ # 第二阶段：调整大小
+ resize_scale = self.max_side / max(image.size)
+ if resize_scale < 1:
+ try:
+ new_size = (int(image.size[0] * resize_scale), int(image.size[1] * resize_scale))
+ image = image.resize(new_size)
+ base_path = osp.splitext(current_path)[0]
+ current_path = f"{base_path}_resize.jpg"
+ image.save(current_path)
+ print(f'Resized image, stored to {current_path}')
+ except Exception as e:
+ print(f"Warning: Failed to resize image {current_path}: {e}")
+ return original_path # 返回当前路径（可能是 RGB 转换后的）
+
+ return current_path
+
+ except Exception as e:
+ print(f"Warning: Critical error processing image {original_path}: {e}")
+ return original_path # 任何严重错误都返回原始路径
+
+ def create_media_content(file_path, is_demo=False):
+ if self.is_video_file(file_path):
+ # Handle video processing with the frame subsampling logic
+ return process_video(file_path, is_demo)
+ else:
+ # Handle image processing otherwise
+ return (dict(type='image', value=_encode_image(file_path)))
+
+ def process_media_list(media_str):
+ if not media_str or media_str == '[]':
+ return None
+ try:
+ if not isinstance(media_str, str):
+ media_str = str(media_str)
+ media_list = eval(media_str)
+ if isinstance(media_list, list):
+ return media_list
+ return None
+ except:
+ return None
+
+ def process_text_and_media(text, media_list, is_demo=False):
+ if not media_list:
+ return [dict(type='text', value=text.strip())]
+
+ message = []
+ chunks = re.split(r'(|)', text)
+ media_index = 0
+
+ placeholder_count = sum(1 for chunk in chunks if chunk in ['', ''])
+ if placeholder_count != len(media_list):
+ if text.strip():
+ message.append(dict(type='text', value=text.strip()))
+ for media in media_list:
+ media_content = create_media_content(media, is_demo=is_demo)
+ if media_content:
+ if isinstance(media_content, list):
+ message.extend(media_content)
+ else:
+ message.append(media_content)
+ return message
+
+ for chunk in chunks:
+ if chunk in ['', '']:
+ media_content = create_media_content(media_list[media_index], is_demo=is_demo)
+ if media_content:
+ if isinstance(media_content, list):
+ message.extend(media_content)
+ else:
+ message.append(media_content)
+ media_index += 1
+ elif chunk.strip():
+ message.append(dict(type='text', value=chunk.strip()))
+
+ return message
+
+ message = []
+ self._set_sampling_config(line)
+
+ if pd.notna(line['task_description']):
+ global_media = process_media_list(line['global_media'])
+ message.extend(process_text_and_media(line['task_description'], global_media))
+
+ if pd.notna(line['example_text']):
+ example_media = process_media_list(line['example_media'])
+ message.extend(process_text_and_media(line['example_text'], example_media, is_demo=True))
+
+ if pd.notna(line['question']):
+ query_media = process_media_list(line['query_media'])
+ message.extend(process_text_and_media(line['question'], query_media))
+
+ return message
+
+ def evaluate(self, eval_file, **judge_kwargs):
+ assert eval_file.endswith('.xlsx'), 'data file should be an xlsx file'
+ data = load(eval_file)
+ result = []
+
+ def str_to_dict(s):
+ try:
+ if isinstance(s, dict):
+ return s
+ import ast
+ return ast.literal_eval(str(s))
+ except:
+ print(f"Warning: Could not parse dictionary string: {s}")
+ return {}
+
+ def process_media_path(media_str):
+ if not media_str:
+ return []
+ try:
+ media_list = eval(str(media_str))
+ if isinstance(media_list, list):
+ return media_list
+ return []
+ except:
+ return []
+
+ # group by task_name
+ # save the result to json
+ output_path = os.path.join(os.path.dirname(eval_file), f'megabench_result_{self.subset_name}.json')
+ result_path = os.path.join(os.path.dirname(eval_file), f'megabench_score_{self.subset_name}.json')
+ if not os.path.exists(output_path) or not os.path.exists(result_path):
+ for task_name, group in data.groupby('task_name'):
+ task_dict = {
+ "task_name": task_name,
+ "task_description": str(group['task_description'].iloc[0]) if 'task_description' in group else "",
+ "global_media": [],
+ "example_contents": [],
+ "query_response": []
+ }
+
+ if 'global_media' in group:
+ task_dict["global_media"] = process_media_path(group['global_media'].iloc[0])
+ if 'example_media' in group:
+ task_dict["example_contents"] = process_media_path(group['example_media'].iloc[0])
+ for _, row in group.iterrows():
+ response_dict = {
+ "response": str(row['prediction']),
+ "correct_answer": str_to_dict(row['answer']) if 'answer' in row else {},
+ "global_idx": str(row['index']),
+ "images": [],
+ "question": str(row['question']) if 'question' in row else "",
+ }
+ if 'query_media' in row:
+ response_dict["images"] = process_media_path(row['query_media'])
+ task_dict["query_response"].append(response_dict)
+
+ result.append(task_dict)
+
+ with open(output_path, 'w', encoding='utf-8') as f:
+ json.dump(result, f, indent=2, ensure_ascii=False)
+
+ evaluator = MEGABenchEvaluator(
+ subset_name=self.subset_name,
+ responses_file=output_path,
+ output_file=result_path,
+ )
+ evaluator.evaluate()
+
+ with open(result_path, 'r', encoding='utf-8') as f:
+ scores = json.load(f)
+
+ eval_results = {
+ 'summary': {
+ 'macro_mean': scores['summary']['macro_mean_score'],
+ 'micro_mean': scores['summary']['micro_mean_score'],
+ 'num_tasks': scores['summary']['num_tasks'],
+ 'num_queries': scores['summary']['num_queries']
+ }
+ }
+
+ return eval_results
diff --git a/vlmeval/dataset/miabench.py b/vlmeval/dataset/miabench.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e99d39ecb3a62957dbe2b8cdd0bdb3911532729
--- /dev/null
+++ b/vlmeval/dataset/miabench.py
@@ -0,0 +1,167 @@
+import json
+import os
+
+import pandas as pd
+
+from .image_base import ImageBaseDataset
+from ..smp import *
+from .utils import build_judge, DEBUG_MESSAGE
+from ..utils import track_progress_rich
+
+
+def generate_prompt(d):
+ question = d['question']
+ weights = eval(d['component_weight'])
+ components = eval(d['components'])
+ num_of_component = int(d['num_of_component'])
+ response = d['prediction']
+
+ if num_of_component == 1:
+ components = f"The first component is: '{components[0]}'. "
+ score = f"The first component is worth: {weights[0]} scores. "
+ elif num_of_component == 2:
+ components = f"The first component is: '{components[0]}', and the second component is '{components[1]}'. "
+ score = f"The first and second component is each worth {weights[0]} and {weights[1]} scores. "
+ elif num_of_component == 3:
+ components = (
+ f"The first component is: '{components[0]}', and the second component is '{components[1]}', "
+ f"and the third component is '{components[2]}'. "
+ )
+ score = (
+ "The first, second, and third component is each worth "
+ f"{weights[0]}, {weights[1]}, and {weights[2]} scores."
+ )
+ elif num_of_component == 4:
+ components = (
+ f"The first component is: '{components[0]}', and the second component is '{components[1]}', "
+ f"and the third component is '{components[2]}', and the fourth component is '{components[3]}'. "
+ )
+ score = (
+ "The first, second, third, and fourth component is each worth "
+ f"{weights[0]}, {weights[1]}, {weights[2]}, and {weights[3]} scores."
+ )
+ elif num_of_component == 5:
+ components = (
+ f"The first component is: '{components[0]}', and the second component is '{components[1]}', "
+ f"and the third component is '{components[2]}', and the fourth component is '{components[3]}', "
+ f"and the fifth component is '{components[4]}'. "
+ )
+ score = (
+ "The first, second, third, fourth, and fifth component is each worth "
+ f"{weights[0]}, {weights[1]}, {weights[2]}, {weights[3]}, and {weights[4]} scores."
+ )
+
+ return (
+ "Here is an instruction for a multimodal LLM: '"
+ f"{question}"
+ "'. You need to grade if the response from the model follows each component of the instruction. "
+ f"{components}"
+ "The response is: '"
+ f"{response}"
+ "'. You need to score the response and be strict. The total score ranges from 0 to 10, "
+ "depending on if the response follows the instruction. "
+ f"{score}"
+ "List scores of each component, and the total score in one sentence in this format: "
+ "score of component 1: x/2, score of component 2: y/8, total score: z/10. Then explain your reasons."
+ )
+
+
+def process_rawscore(component_type, raw_score):
+ first_sentence = raw_score.split('.')[0].split(',')
+ score_dict = {}
+ for i in range(len(first_sentence) - 1):
+ score_ = first_sentence[i].split(':')[1][1:].split('/')
+ score = int(score_[0]) / int(score_[1])
+ score_dict[component_type[i]] = score
+ total_score_ = first_sentence[i + 1].split(':')[1][1:].split('/')
+ total_score = int(total_score_[0]) / int(total_score_[1])
+ score_dict['total_score'] = total_score
+ return score_dict
+
+
+def get_score_dict(data, score_raw):
+ cat_score_dict = {}
+ for i in range(len(data)):
+ try:
+ cmp = data['component_type'][i][2:-2]
+ cmp_list = cmp.split('\', \'')
+ score_dict = process_rawscore(cmp_list, score_raw[i])
+ for key, val in score_dict.items():
+ if key not in cat_score_dict.keys():
+ cat_score_dict[key] = [val]
+ else:
+ cat_score_dict[key].append(val)
+ except:
+ pass
+ cat_score_dict_average = {}
+ for key, val in cat_score_dict.items():
+ cat_score_dict_average[key] = sum(val) / len(val)
+ return cat_score_dict_average
+
+
+class MIABench(ImageBaseDataset):
+ TYPE = 'VQA'
+
+ DATASET_URL = {
+ 'MIA-Bench': 'https://opencompass.openxlab.space/utils/VLMEval/Mia-Bench.tsv',
+ }
+ DATASET_MD5 = {
+ 'MIA-Bench': '0b9de595f4dd40af18a69b94d89aba82',
+ }
+
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ judge_name = judge_kwargs.pop('model', 'gpt-4o')
+
+ model = build_judge(model=judge_name, **judge_kwargs)
+ suffix = eval_file.split('.')[-1]
+
+ storage = eval_file.replace(f'.{suffix}', f'_{judge_name}.xlsx') # noqa: F841
+ tmp_file = eval_file.replace(f'.{suffix}', f'_{judge_name}.pkl') # noqa: F841
+ nproc = judge_kwargs.pop('nproc', 4) # noqa: F841
+
+ if not osp.exists(storage):
+ data = load(eval_file)
+ num_samples = len(data)
+ lines = [data.loc[i] for i in range(num_samples)]
+ prompts = [generate_prompt(line) for line in lines]
+ org_data = MIABench('MIA-Bench').data
+ img_map = {x: y for x, y in zip(org_data['index'], org_data['image'])}
+ image_b64 = [img_map[idx] for idx in data['index']]
+ indices = list(data['index'])
+ mm_messages = [
+ dict(message=[
+ dict(type='text', value=prompt),
+ dict(type='image', value=f'data:image/jpeg;base64,{b64}')
+ ])
+ for prompt, b64 in zip(prompts, image_b64)
+ ]
+
+ res = {}
+ if osp.exists(tmp_file):
+ res = load(tmp_file)
+
+ jobs = {k: v for k, v in zip(indices, mm_messages) if k not in res}
+ job_keys = list(jobs.keys())
+ job_vals = [jobs[k] for k in job_keys]
+
+ resps = track_progress_rich(
+ model.generate,
+ job_vals,
+ nproc=nproc,
+ chunksize=nproc,
+ keys=job_keys,
+ save=tmp_file,
+ )
+ for k, resp in zip(job_keys, resps):
+ res[k] = resp
+ data['score_raw'] = [res[idx] for idx in indices]
+ dump(data, storage)
+
+ goresult = load(storage)
+ results = get_score_dict(goresult, goresult['score_raw'])
+ result_pth = storage.replace('.xlsx', '_score.csv')
+ results_pd = pd.DataFrame.from_dict(list(results.items()))
+ dump(results_pd, result_pth)
+
+ return results
diff --git a/vlmeval/dataset/mlvu.py b/vlmeval/dataset/mlvu.py
new file mode 100644
index 0000000000000000000000000000000000000000..f7094a0f590d52a3ee6cb9263f255d2264049604
--- /dev/null
+++ b/vlmeval/dataset/mlvu.py
@@ -0,0 +1,455 @@
+import huggingface_hub
+from huggingface_hub import snapshot_download
+from ..smp import *
+from .video_concat_dataset import ConcatVideoDataset
+from .video_base import VideoBaseDataset
+from .utils import build_judge, DEBUG_MESSAGE
+from ..utils import track_progress_rich
+import torchvision.transforms as T
+from torchvision import transforms
+from torchvision.transforms.functional import InterpolationMode
+from decord import VideoReader, cpu
+import pandas as pd
+import imageio
+import cv2
+import zipfile
+import os
+import glob
+from .utils.mlvu import *
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+class MLVU(ConcatVideoDataset):
+ def __init__(self, dataset='MLVU', nframe=0, fps=-1):
+ self.DATASET_SETS[dataset] = ['MLVU_MCQ', 'MLVU_OpenEnded']
+ self.type_data_dict = {
+ 'M-Avg':['plotQA', 'needle', 'ego', 'count', 'anomaly_reco', 'topic_reasoning'],
+ 'G-Avg':['sub_scene', 'summary']
+ }
+ super().__init__(dataset=dataset, nframe=nframe, fps=fps)
+
+ @classmethod
+ def supported_datasets(cls):
+ return ['MLVU']
+
+ def evaluate(self, eval_file, **judge_kwargs):
+ result = super().evaluate(eval_file=eval_file, **judge_kwargs)
+ suffix = eval_file.split('.')[-1]
+ score_file = eval_file.replace(f'.{suffix}', '_acc.csv')
+ for key in self.type_data_dict:
+ result.loc[key] = 0.0
+ for name, item in result.iterrows():
+ if name in self.type_data_dict[key]:
+ result.loc[key, 'success'] += item['success']
+ result.loc[key, 'overall'] += item['overall']
+ if key == 'G-Avg':
+ result.loc[key, 'acc'] = round(
+ result.loc[key, 'success'] / result.loc[key, 'overall'], 2
+ )
+ else:
+ result.loc[key, 'acc'] = round(
+ result.loc[key, 'success'] / result.loc[key, 'overall'] * 100, 1
+ )
+ result = result.reset_index().rename(columns={'index': 'task'})
+ dump(result, score_file)
+ return result
+
+
+class MLVU_MCQ(VideoBaseDataset):
+
+ MD5 = 'bb5c37e7cf8d43fc9a25c23d2b4633f5'
+ BASE_SYS = 'Carefully watch this video and pay attention to every detail. '
+ SYS = BASE_SYS + 'Based on your observations, select the best option that accurately addresses the question.'
+ TYPE = 'Video-MCQ'
+
+ def __init__(self, dataset='MLVU_MCQ', nframe=0, fps=-1):
+ self.type_data_list = {
+ 'plotQA': ('1_plotQA.json', './MLVU/video/1_plotQA', 'MCQ'),
+ 'needle': ('2_needle.json', './MLVU/video/2_needle', 'MCQ'),
+ 'ego': ('3_ego.json', './MLVU/video/3_ego', 'MCQ'),
+ 'count': ('4_count.json', './MLVU/video/4_count', 'MCQ'),
+ 'order': ('5_order.json', './MLVU/video/5_order', 'MCQ'),
+ 'anomaly_reco': ('6_anomaly_reco.json', './MLVU/video/6_anomaly_reco', 'MCQ'),
+ 'topic_reasoning': ('7_topic_reasoning.json', './MLVU/video/7_topic_reasoning', 'MCQ'),
+ }
+ super().__init__(dataset=dataset, nframe=nframe, fps=fps)
+
+ @classmethod
+ def supported_datasets(cls):
+ return ['MLVU_MCQ']
+
+ def prepare_dataset(self, dataset_name='MLVU_MCQ', repo_id='MLVU/MVLU'):
+ def check_integrity(pth):
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+
+ if not os.path.exists(data_file):
+ return False
+
+ if md5(data_file) != self.MD5:
+ return False
+
+ data = load(data_file)
+ for idx, item in data.iterrows():
+ if not osp.exists(osp.join(pth, item['prefix'], item['video'])):
+ return False
+ return True
+
+ if modelscope_flag_set():
+ repo_id = "AI-ModelScope/MLVU"
+
+ cache_path = get_cache_path(repo_id)
+ if cache_path is not None and check_integrity(cache_path):
+ dataset_path = cache_path
+ else:
+ def generate_tsv(pth):
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+ if os.path.exists(data_file) and md5(data_file) == self.MD5:
+ return
+ json_data_dir = os.path.join(dataset_path, 'MLVU', 'json')
+ self.data_list = []
+ for k, v in self.type_data_list.items():
+ with open(os.path.join(json_data_dir, v[0]), 'r') as f:
+ json_data = json.load(f)
+ for data in json_data:
+ self.data_list.append({
+ 'task_type': k,
+ 'prefix': v[1],
+ 'duration': data['duration'],
+ 'video': data['video'],
+ 'question': data['question'],
+ 'answer': data['answer'],
+ 'candidates': data['candidates'],
+ })
+
+ data_df = pd.DataFrame(self.data_list)
+ data_df = data_df.assign(index=range(len(data_df)))
+ data_df.to_csv(data_file, sep='\t', index=False)
+
+ if modelscope_flag_set():
+ from modelscope import dataset_snapshot_download
+ dataset_path = dataset_snapshot_download(dataset_id=repo_id)
+ else:
+ hf_token = os.environ.get('HUGGINGFACE_TOKEN')
+ huggingface_hub.login(hf_token)
+ dataset_path = snapshot_download(repo_id=repo_id, repo_type='dataset')
+
+ generate_tsv(dataset_path)
+
+ data_file = osp.join(dataset_path, f'{dataset_name}.tsv')
+ return dict(root=dataset_path, data_file=data_file)
+
+ def qa_template(self, data):
+ question = f"Question: {data['question']}\n"
+ question += 'Options:\n'
+ answer = data['answer']
+ answer_idx = -1
+ for idx, c in enumerate(eval(data['candidates'])):
+ question += f"({chr(ord('A') + idx)}) {c}\n"
+ if c == answer:
+ answer_idx = idx
+ question = question.rstrip()
+ answer = f"({chr(ord('A') + answer_idx)}) {answer}"
+ return question, answer
+
+ def save_video_frames(self, line):
+ suffix = line['video'].split('.')[-1]
+ video = line['video'].replace(f'.{suffix}','')
+ vid_path = osp.join(self.data_root, line['prefix'], line['video'])
+ vid = decord.VideoReader(vid_path)
+ video_info = {
+ 'fps': vid.get_avg_fps(),
+ 'n_frames': len(vid),
+ }
+ if self.nframe > 0 and self.fps < 0:
+ step_size = len(vid) / (self.nframe + 1)
+ indices = [int(i * step_size) for i in range(1, self.nframe + 1)]
+ frame_paths = self.frame_paths(video)
+ elif self.fps > 0:
+ # not constrained by num_frames, get frames by fps
+ total_duration = video_info['n_frames'] / video_info['fps']
+ required_frames = int(total_duration * self.fps)
+ step_size = video_info['fps'] / self.fps
+ indices = [int(i * step_size) for i in range(required_frames)]
+ frame_paths = self.frame_paths_fps(video, len(indices))
+
+ flag = np.all([osp.exists(p) for p in frame_paths])
+
+ if not flag:
+ images = [vid[i].asnumpy() for i in indices]
+ images = [Image.fromarray(arr) for arr in images]
+ for im, pth in zip(images, frame_paths):
+ if not osp.exists(pth):
+ im.save(pth)
+
+ return frame_paths
+
+ def save_video_into_images(self, line):
+ frame_paths = self.save_video_frames(line)
+ return frame_paths
+
+ def build_prompt(self, line, video_llm):
+ if isinstance(line, int):
+ assert line < len(self)
+ line = self.data.iloc[line]
+
+ question, answer = self.qa_template(line)
+ message = [dict(type='text', value=self.SYS, role='system')]
+ message.append(dict(type='text', value=question))
+ video_path = os.path.join(self.data_root, line['prefix'], line['video'])
+ if video_llm:
+ message.append(dict(type='video', value=video_path))
+ else:
+ img_frame_paths = self.save_video_into_images(line)
+ for im in img_frame_paths:
+ message.append(dict(type='image', value=im))
+ message.append(dict(type='text', value='\nOnly give the best option.'))
+ return message
+
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ assert eval_file.endswith('.xlsx'), 'data file should be an xlsx file'
+
+ tmp_file = eval_file.replace('.xlsx', '_tmp.pkl')
+ score_file = eval_file.replace('.xlsx', '_score.xlsx')
+
+ if not osp.exists(score_file):
+ model = judge_kwargs.setdefault('model', 'chatgpt-0125')
+ assert model in ['chatgpt-0125', 'exact_matching', 'gpt-4-0125']
+
+ if model == 'exact_matching':
+ model = None
+ elif gpt_key_set():
+ model = build_judge(**judge_kwargs)
+ if not model.working():
+ warnings.warn('OPENAI API is not working properly, will use exact matching for evaluation')
+ warnings.warn(DEBUG_MESSAGE)
+ model = None
+ else:
+ warnings.warn('OPENAI_API_KEY is not set properly, will use exact matching for evaluation')
+ model = None
+ res = {} if not osp.exists(tmp_file) else load(tmp_file)
+ res = {k: v for k, v in res.items() if FAIL_MSG not in v}
+
+ data = load(eval_file)
+ data_un = data[~pd.isna(data['prediction'])]
+
+ for idx in data['index']:
+ ans = data.loc[data['index'] == idx, 'answer'].values[0]
+ pred = data.loc[data['index'] == idx, 'prediction'].values[0]
+ options = eval(data.loc[data['index'] == idx, 'candidates'].values[0])
+ answer_idx = -1
+ for id, c in enumerate(options):
+ if c == ans:
+ answer_idx = id
+ ans = f"({chr(ord('A') + answer_idx)}) {ans}"
+ input_item = data.loc[data['index'] == idx].to_dict(orient='records')[0]
+ for id, option_content in enumerate(eval(input_item['candidates'])):
+ input_item[chr(ord('A') + id)] = option_content
+ if option_content == input_item['answer']:
+ input_item['answer'] = chr(ord('A') + id)
+
+ if FAIL_MSG in pred:
+ data.loc[idx, 'score'] = -1
+ else:
+ data.loc[idx, 'score'] = int(check_ans_with_model(
+ pred, ans, model,
+ input_item,
+ 'MLVU_MCQ'
+ ))
+
+ rejected = [x for x in data['score'] if x == -1]
+
+ print(
+ f'Among {len(data)} questions, failed to obtain prediction for {len(data) - len(data_un)} questions, '
+ f'failed to obtain the score for another {len(rejected)} questions. '
+ f'Those questions will be counted as -1 score in ALL rating, and will not be counted in VALID rating.'
+ )
+
+ dump(data, score_file)
+
+ rating = get_dimension_rating(score_file)
+ return rating
+
+
+class MLVU_OpenEnded(VideoBaseDataset):
+
+ MD5 = 'cee573a3627c6ac434ded704c60511ba'
+ BASE_SYS = 'Carefully watch this video and pay attention to every detail. '
+ SYS = BASE_SYS + 'Based on your observations, answer the given questions.'
+ TYPE = 'Video-VQA'
+
+ def __init__(self, dataset='MLVU_OpenEnded', nframe=0, fps=-1):
+ self.type_data_list = {
+ 'sub_scene': ('8_sub_scene.json', './MLVU/video/8_sub_scene', 'VQA'),
+ 'summary': ('9_summary.json', './MLVU/video/9_summary', 'VQA')
+ }
+ super().__init__(dataset=dataset, nframe=nframe, fps=fps)
+
+ @classmethod
+ def supported_datasets(cls):
+ return ['MLVU_OpenEnded']
+
+ def prepare_dataset(self, dataset_name='MLVU_OpenEnded', repo_id='MLVU/MVLU'):
+ def check_integrity(pth):
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+
+ if not os.path.exists(data_file):
+ return False
+
+ if md5(data_file) != self.MD5:
+ return False
+
+ data = load(data_file)
+ for idx, item in data.iterrows():
+ if not osp.exists(osp.join(pth, item['prefix'], item['video'])):
+ return False
+ return True
+
+ if modelscope_flag_set():
+ repo_id = "AI-ModelScope/MLVU"
+
+ cache_path = get_cache_path(repo_id)
+ if cache_path is not None and check_integrity(cache_path):
+ dataset_path = cache_path
+ else:
+ def generate_tsv(pth):
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+ if os.path.exists(data_file) and md5(data_file) == self.MD5:
+ return
+ json_data_dir = os.path.join(dataset_path, 'MLVU', 'json')
+ self.data_list = []
+ for k, v in self.type_data_list.items():
+ with open(os.path.join(json_data_dir, v[0]), 'r') as f:
+ json_data = json.load(f)
+ for data in json_data:
+ self.data_list.append({
+ 'task_type': k,
+ 'prefix': v[1],
+ 'duration': data['duration'],
+ 'video': data['video'],
+ 'question': data['question'],
+ 'answer': data['answer'],
+ 'scoring_points': data['scoring_points'] if 'scoring_points' in data else ''
+ })
+
+ data_df = pd.DataFrame(self.data_list)
+ data_df = data_df.assign(index=range(len(data_df)))
+ data_df.to_csv(data_file, sep='\t', index=False)
+
+ if modelscope_flag_set():
+ from modelscope import dataset_snapshot_download
+ dataset_path = dataset_snapshot_download(dataset_id=repo_id)
+ else:
+ hf_token = os.environ.get('HUGGINGFACE_TOKEN')
+ huggingface_hub.login(hf_token)
+ dataset_path = snapshot_download(repo_id=repo_id, repo_type='dataset')
+
+ generate_tsv(dataset_path)
+
+ data_file = osp.join(dataset_path, f'{dataset_name}.tsv')
+ return dict(root=dataset_path, data_file=data_file)
+
+ def qa_template(self, data):
+ question = f"{data['question']}"
+ answer = data['answer']
+ return question, answer
+
+ def save_video_frames(self, line):
+ suffix = line['video'].split('.')[-1]
+ video = line['video'].replace(f'.{suffix}','')
+ vid_path = osp.join(self.data_root, line['prefix'], line['video'])
+ vid = decord.VideoReader(vid_path)
+ video_info = {
+ 'fps': vid.get_avg_fps(),
+ 'n_frames': len(vid),
+ }
+ if self.nframe > 0 and self.fps < 0:
+ step_size = len(vid) / (self.nframe + 1)
+ indices = [int(i * step_size) for i in range(1, self.nframe + 1)]
+ frame_paths = self.frame_paths(video)
+ elif self.fps > 0:
+ # not constrained by num_frames, get frames by fps
+ total_duration = video_info['n_frames'] / video_info['fps']
+ required_frames = int(total_duration * self.fps)
+ step_size = video_info['fps'] / self.fps
+ indices = [int(i * step_size) for i in range(required_frames)]
+ frame_paths = self.frame_paths_fps(video, len(indices))
+
+ flag = np.all([osp.exists(p) for p in frame_paths])
+
+ if not flag:
+ images = [vid[i].asnumpy() for i in indices]
+ images = [Image.fromarray(arr) for arr in images]
+ for im, pth in zip(images, frame_paths):
+ if not osp.exists(pth):
+ im.save(pth)
+
+ return frame_paths
+
+ def save_video_into_images(self, line):
+ frame_paths = self.save_video_frames(line)
+ return frame_paths
+
+ def build_prompt(self, line, video_llm):
+ if isinstance(line, int):
+ assert line < len(self)
+ line = self.data.iloc[line]
+
+ question, answer = self.qa_template(line)
+ message = [dict(type='text', value=self.SYS, role='system')]
+ message.append(dict(type='text', value=question))
+ video_path = os.path.join(self.data_root, line['prefix'], line['video'])
+ if video_llm:
+ message.append(dict(type='video', value=video_path))
+ else:
+ img_frame_paths = self.save_video_into_images(line)
+ for im in img_frame_paths:
+ message.append(dict(type='image', value=im))
+ return message
+
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+
+ model = judge_kwargs['model'] if 'model' in judge_kwargs else judge_kwargs.setdefault('model', 'gpt-4-0125')
+ if model != 'gpt-4-0125':
+ print('MLVU Open Ended default using gpt-4-0125! So judge model is changed to gpt-4-0125')
+ judge_kwargs['model'] = 'gpt-4-0125'
+
+ suffix = eval_file.split('.')[-1]
+ score_file = eval_file.replace(f'.{suffix}', f'_{model}_score.xlsx')
+ tmp_file = eval_file.replace(f'.{suffix}', f'_{model}.pkl')
+ nproc = judge_kwargs.pop('nproc', 4)
+
+ if not osp.exists(score_file):
+ data = load(eval_file)
+ model_dict = {
+ 'sub_scene': build_judge(system_prompt=system_prompt_sub_scene, **judge_kwargs),
+ 'summary': build_judge(system_prompt=system_prompt_summary, **judge_kwargs)
+ }
+ lt = len(data)
+ lines = [data.iloc[i] for i in range(lt)]
+ tups = [(model_dict[line['task_type']], line) for line in lines]
+ indices = [line['index'] for line in lines]
+
+ ans = {}
+ if osp.exists(tmp_file):
+ ans = load(tmp_file)
+ tups = [x for x, i in zip(tups, indices) if i not in ans]
+ indices = [i for i in indices if i not in ans]
+
+ if len(indices):
+ _ = track_progress_rich(
+ MLVU_OpenEnded_generate,
+ tups,
+ nproc=nproc,
+ chunksize=nproc,
+ keys=indices,
+ save=tmp_file,
+ )
+ ans = load(tmp_file)
+ data = MLVU_OpenEnded_extract(ans, data)
+ dump(data, score_file)
+
+ rating = get_dimension_rating(score_file)
+ return rating
diff --git a/vlmeval/dataset/mmalignbench.py b/vlmeval/dataset/mmalignbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..ac7bf0f4c9be178581c384724d8aa6d1acd987c3
--- /dev/null
+++ b/vlmeval/dataset/mmalignbench.py
@@ -0,0 +1,298 @@
+import re
+from functools import partial
+
+from .image_base import ImageBaseDataset
+from .utils import build_judge, DEBUG_MESSAGE
+from ..smp import *
+from ..utils import track_progress_rich
+
+
+SYSTEM_PROMPT = """\
+Please act as an impartial evaluator and assess the quality of the responses provided by two AI assistants to a given user prompt and accompanying image. You will be provided with Assistant A's and Assistant B's answers. Your task is to determine which assistant's response is superior.
+
+Start your evaluation by generating your own answer to the prompt and image. Ensure that you complete your answer before reviewing any assistant responses.
+
+When evaluating the assistants' responses, compare each one to your own answer.
+
+First, assess whether the assistants' answers are helpful and relevant. A response is considered helpful if it appropriately addresses the prompt, follows the given instructions, and is well-organized. A relevant answer closely aligns with the context or requirements of the prompt.
+
+When applicable, consider the creativity and novelty of each assistant's response and evaluate the writing quality of both responses.
+
+Then, identify and correct any errors or inaccuracies in the assistants' answers. Lastly, identify any critical information missing from the assistants' responses that should have been included to improve the answer.
+
+After providing your explanation, you must output only one of the following choices as your final verdict with a label:
+
+1. Assistant A is significantly better: [[A>>B]]
+2. Assistant A is slightly better: [[A>B]]
+3. Tie, relatively the same: [[A=B]]
+4. Assistant B is slightly better: [[B>A]]
+5. Assistant B is significantly better: [[B>>A]]
+
+Example output: "My final verdict is tie: [[A=B]]".\
+"""
+
+SYSTEM_PROMPT_GT = """\
+Please act as an impartial evaluator and assess the quality of the responses provided by two AI assistants to a given user prompt and accompanying image. You will be provided with Assistant A's and Assistant B's answers. Your task is to determine which assistant's response is superior.
+
+Start your evaluation by generating your own answer to the prompt and image. Ensure that you complete your answer before reviewing any assistant responses.
+
+When evaluating the assistants' responses, compare each one to your own answer.
+
+First, assess whether the assistants' answers are helpful and relevant. A response is considered helpful if it appropriately addresses the prompt, follows the given instructions, and is well-organized. A relevant answer closely aligns with the context or requirements of the prompt.
+
+When applicable, consider the creativity and novelty of each assistant's response and evaluate the writing quality of both responses.
+
+Then, identify and correct any errors or inaccuracies in the assistants' answers. Lastly, identify any critical information missing from the assistants' responses that should have been included to improve the answer. Please refer to the provided Ground Truth answer, which constitutes the key fact relevant to the question.
+
+After providing your explanation, you must output only one of the following choices as your final verdict with a label:
+
+1. Assistant A is significantly better: [[A>>B]]
+2. Assistant A is slightly better: [[A>B]]
+3. Tie, relatively the same: [[A=B]]
+4. Assistant B is slightly better: [[B>A]]
+5. Assistant B is significantly better: [[B>>A]]
+
+Example output: "My final verdict is tie: [[A=B]]".\
+"""
+
+PROMPT_TEMPLATE = """**INPUT**:
+
+<|User Prompt|>\n{question}
+
+<|The Start of Assistant A's Answer|>\n{answer_1}\n<|The End of Assistant A's Answer|>
+
+<|The Start of Assistant B's Answer|>\n{answer_2}\n<|The End of Assistant B's Answer|>
+"""
+
+
+PROMPT_TEMPLATE_GT = """**INPUT**:
+
+<|User Prompt|>\n{question}
+
+<|Ground Truth|>\n{gt}
+
+<|The Start of Assistant A's Answer|>\n{answer_1}\n<|The End of Assistant A's Answer|>
+
+<|The Start of Assistant B's Answer|>\n{answer_2}\n<|The End of Assistant B's Answer|>
+"""
+
+
+REGEX_PATTERN = re.compile("\[\[([AB<>=]+)\]\]") # noqa: W605
+
+
+def get_score(judgement, pattern=REGEX_PATTERN):
+ matches = pattern.findall(judgement)
+ matches = [m for m in matches if m != ""]
+ if len(set(matches)) == 0:
+ return None, True
+ elif len(set(matches)) == 1:
+ return matches[0].strip("\n"), False
+ else:
+ return None, True
+
+
+def MMAlignBench_auxeval(model, line):
+ if 'gt' in line and str(line['gt']) != 'nan':
+ config = dict(question=line['question'], gt=line['gt'], answer_1=line['A'], answer_2=line['B'])
+ prompt = SYSTEM_PROMPT_GT + '\n' + PROMPT_TEMPLATE_GT.format(**config)
+ # prompt = PROMPT_TEMPLATE.format(**config)
+ print('gt_prompt'+prompt)
+ else:
+ config = dict(question=line['question'], answer_1=line['A'], answer_2=line['B'])
+ prompt = SYSTEM_PROMPT + '\n' + PROMPT_TEMPLATE.format(**config)
+ # prompt = PROMPT_TEMPLATE.format(**config)
+ print('prompt'+prompt)
+
+ prefix = 'data:image/jpeg;base64,'
+ img = prefix + line['image']
+
+ messages = [
+ dict(type='text', value=prompt),
+ dict(type='image', value=img)
+ ]
+
+ retry = 2
+ while retry:
+ resp = model.generate(messages)
+ score, try_again = get_score(resp)
+ if not try_again:
+ break
+ retry -= 1
+
+ if score is None:
+ return 'Unknown'
+ return [score, resp]
+
+
+class MMAlignBench(ImageBaseDataset):
+ TYPE = 'VQA'
+ DATASET_URL = {'MMAlignBench': 'https://opencompass.openxlab.space/utils/VLMEval/MMAlignBench.tsv'}
+ DATASET_MD5 = {'MMAlignBench': 'd00d8e61c99257cbaf76d8d5e926f01e'}
+
+ score_map = {
+ 'A>>B': -2,
+ 'A>B': -1,
+ 'A=B': 0,
+ 'B>A': 1,
+ 'B>>A': 2
+ }
+
+ # Given one data record, return the built prompt (a multi-modal message), can override
+ def build_prompt(self, line):
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ if self.meta_only:
+ tgt_path = toliststr(line['image_path'])
+ else:
+ tgt_path = self.dump_image(line)
+
+ question = line['question']
+
+ msgs = []
+ if isinstance(tgt_path, list):
+ msgs.extend([dict(type='image', value=p) for p in tgt_path])
+ else:
+ msgs = [dict(type='image', value=tgt_path)]
+ # WildVision adopts text first
+ msgs = [dict(type='text', value=question)] + msgs
+ return msgs
+
+ @classmethod
+ def gen_eval_base(self, eval_file, b64_map):
+ data = load(eval_file)
+ data['B'] = data.pop('prediction')
+ data['A'] = data.pop('claude3_sonnet')
+ data['image'] = [b64_map[x] for x in data['index']]
+ return data
+
+ # It returns a DataFrame
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ # We adopt pairwise evaluation (twice for a pair) for this dataset
+ suffix = eval_file.split('.')[-1]
+ model = judge_kwargs['model']
+ storage = eval_file.replace(f'.{suffix}', f'_{model}.xlsx')
+ score_file = eval_file.replace(f'.{suffix}', f'_{model}_score.csv')
+ tmp_file = eval_file.replace(f'.{suffix}', f'_{model}.pkl')
+ nproc = judge_kwargs.pop('nproc', 4)
+
+ if not osp.exists(storage):
+ raw_data = MMAlignBench('MMAlignBench').data
+ b64_map = {x: y for x, y in zip(raw_data['index'], raw_data['image'])}
+ data = self.gen_eval_base(eval_file, b64_map)
+
+ # judge_kwargs['system_prompt'] = SYSTEM_PROMPT
+ judge_kwargs['temperature'] = 0
+ judge_kwargs['img_detail'] = 'high'
+ judge_kwargs['timeout'] = 300
+ model = build_judge(max_tokens=4096, **judge_kwargs)
+
+ assert model.working(), (
+ 'MMAlignBench evaluation requires a working OPENAI API\n' + DEBUG_MESSAGE
+ )
+
+ lt = len(data)
+ lines = [data.iloc[i] for i in range(lt)]
+ tups = [(model, line) for line in lines]
+ indices = [line['index'] for line in lines]
+
+ ans = load(tmp_file) if osp.exists(tmp_file) else {}
+ tups = [x for x, i in zip(tups, indices) if i not in ans]
+ indices = [i for i in indices if i not in ans]
+
+ if len(indices):
+ new_results = track_progress_rich(
+ MMAlignBench_auxeval,
+ tups,
+ nproc=nproc,
+ chunksize=nproc,
+ keys=indices,
+ save=tmp_file,
+ )
+ ans = load(tmp_file)
+ for k, v in zip(indices, new_results):
+ ans[k] = {'score': v[0], 'resp': v[1]}
+ else:
+ for k,v in ans.items():
+ ans[k] = {'score': v[0], 'resp': v[1]}
+ # breakpoint()
+ data['score'] = [ans[x]['score'] for x in data['index']]
+ data['judge'] = [ans[x]['resp'] for x in data['index']]
+ data.pop('image')
+ dump(data, storage)
+
+ data = load(storage)
+ lt = len(data)
+
+ scores = defaultdict(lambda: 0)
+ type_scores = defaultdict(lambda: defaultdict(lambda: 0))
+
+ for i in range(lt):
+ item = data.iloc[i]
+ if item['score'] not in self.score_map:
+ score = 0
+ else:
+ score = self.score_map[item['score']]
+ if '_rev' in item['index']:
+ score = -score
+ scores[score] += 1
+ type = item['type']
+ type_scores[type][score] += 1
+
+ name_map = {
+ 2: 'Much Better',
+ 1: 'Better',
+ 0: 'Tie',
+ -1: 'Worse',
+ -2: 'Much Worse'
+ }
+ scores = {name_map[k]: v for k, v in scores.items()}
+ scores['Reward'] = (
+ 100 * scores.get('Much Better', 0)
+ + 50 * scores.get('Better', 0)
+ - 50 * scores.get('Worse', 0)
+ - 100 * scores.get('Much Worse', 0)
+ ) / lt
+ scores['Win Rate'] = (scores.get('Better', 0) + scores.get('Much Better', 0)) / lt
+ scores = {k: [v] for k, v in scores.items()}
+ scores = pd.DataFrame(scores)
+
+ for type_name, type_score_dict in type_scores.items():
+ type_score_dict = {name_map[k]: v for k, v in type_score_dict.items()}
+ type_lt = sum(type_score_dict.values())
+
+ type_score_dict['Reward'] = (
+ (
+ 100 * type_score_dict.get('Much Better', 0)
+ + 50 * type_score_dict.get('Better', 0)
+ - 50 * type_score_dict.get('Worse', 0)
+ - 100 * type_score_dict.get('Much Worse', 0)
+ )
+ / type_lt
+ if type_lt > 0
+ else 0
+ )
+
+ type_score_dict['Win Rate'] = (
+ (type_score_dict.get('Better', 0) + type_score_dict.get('Much Better', 0)) / type_lt
+ if type_lt > 0
+ else 0
+ )
+
+ # 将该类型的得分添加到结果中
+ type_score_df = pd.DataFrame(
+ {
+ f"{type_name}_Much Better": [type_score_dict.get('Much Better', 0)],
+ f"{type_name}_Better": [type_score_dict.get('Better', 0)],
+ f"{type_name}_Tie": [type_score_dict.get('Tie', 0)],
+ f"{type_name}_Worse": [type_score_dict.get('Worse', 0)],
+ f"{type_name}_Much Worse": [type_score_dict.get('Much Worse', 0)],
+ f"{type_name}_Reward": [type_score_dict['Reward']],
+ f"{type_name}_Win Rate": [type_score_dict['Win Rate']],
+ }
+ )
+ scores = pd.concat([scores, type_score_df], axis=1)
+
+ dump(scores, score_file)
+ return scores
diff --git a/vlmeval/dataset/mmbench_video.py b/vlmeval/dataset/mmbench_video.py
new file mode 100644
index 0000000000000000000000000000000000000000..816ec1db6dceb6718eb29c7bbd8a59146551b632
--- /dev/null
+++ b/vlmeval/dataset/mmbench_video.py
@@ -0,0 +1,256 @@
+from huggingface_hub import snapshot_download
+from ..smp import *
+from .video_base import VideoBaseDataset
+from .utils import build_judge, DEBUG_MESSAGE
+from ..utils import track_progress_rich
+
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+def unwrap_hf_pkl(pth, suffix='.mp4'):
+ base_dir = os.path.join(pth, 'video_pkl/')
+ target_dir = os.path.join(pth, 'video/')
+ pickle_files = [os.path.join(base_dir, file) for file in os.listdir(base_dir)]
+ pickle_files.sort()
+
+ if not os.path.exists(target_dir):
+ os.makedirs(target_dir, exist_ok=True)
+ for pickle_file in pickle_files:
+ with open(pickle_file, 'rb') as file:
+ video_data = pickle.load(file)
+ # For each video file in the pickle file, write its contents to a new mp4 file
+ for video_name, video_content in video_data.items():
+ output_path = os.path.join(target_dir, f'{video_name}{suffix}')
+ with open(output_path, 'wb') as output_file:
+ output_file.write(video_content)
+ print('The video file has been restored and stored from the pickle file.')
+ else:
+ print('The video file already exists.')
+
+
+class MMBenchVideo(VideoBaseDataset):
+
+ MD5 = '98f7df3eb1007fc375ea6fe88a98e2ff'
+ SYS = 'You are an AI assistant responsible for answering questions about videos.'
+ FRAMES_TMPL_PACK = """
+You will be provided with {} separate frames uniformly sampled from a video, \
+the frames are provided in chronological order of the video.
+Please analyze these images and provide the answer / answers to the \
+following question / questions about the video content.
+If multiple questions are provided (with indices I1, I2, I3, ...), \
+you should organize your answers in the following json format:
+{{
+ 'I1': 'Answer to Question I1',
+ 'I2': 'Answer to Question I2',
+ ...
+}}
+Otherwise, please directly reply with your response to the only question.
+Even if the information in these separate frames is not enough to give an answer,
+PLEASE GIVE A RESPONSE TO EACH OF THE QUESTIONS IN THE FORMAT DESCRIBED ABOVE.
+"""
+
+ FRAMES_TMPL_NOPACK = """
+You will be provided with {} separate frames uniformly sampled from a video, \
+the frames are provided in chronological order of the video.
+Please analyze these images and provide the answer to the question about the video content.
+Please directly reply with your response to the only question.
+"""
+
+ TYPE = 'Video-VQA'
+
+ def __init__(self, dataset='MMBench-Video', pack=False, nframe=0, fps=-1):
+ super().__init__(dataset=dataset, pack=pack, nframe=nframe, fps=fps)
+
+ @classmethod
+ def supported_datasets(cls):
+ return ['MMBench-Video']
+
+ def prepare_dataset(self, dataset_name='MMBench-Video', repo_id='opencompass/MMBench-Video'):
+ def check_integrity(pth):
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+ if md5(data_file) != self.MD5:
+ return False
+ data = load(data_file)
+ for video_pth in data['video_path']:
+ if not osp.exists(osp.join(pth, video_pth)):
+ return False
+ return True
+
+ cache_path = get_cache_path(repo_id)
+ if cache_path is not None and check_integrity(cache_path):
+ dataset_path = cache_path
+ else:
+ if modelscope_flag_set():
+ from modelscope import dataset_snapshot_download
+ dataset_path = dataset_snapshot_download(dataset_id=repo_id)
+ else:
+ dataset_path = snapshot_download(repo_id=repo_id, repo_type='dataset')
+ unwrap_hf_pkl(dataset_path)
+ self.video_path = osp.join(dataset_path, 'video/')
+ data_file = osp.join(dataset_path, f'{dataset_name}.tsv')
+
+ return dict(data_file=data_file, root=osp.join(dataset_path, 'video'))
+
+ def build_prompt_pack(self, line):
+ if isinstance(line, int):
+ assert line < len(self)
+ video = self.videos[line]
+ elif isinstance(line, pd.Series):
+ video = line['video']
+ elif isinstance(line, str):
+ video = line
+
+ frames = self.save_video_frames(video)
+ sub = self.data[self.data['video'] == video]
+ sys_prompt = self.SYS + self.FRAMES_TMPL_PACK.format(len(frames))
+ message = [dict(type='text', value=sys_prompt)]
+ for im in frames:
+ message.append(dict(type='image', value=im))
+ nq = len(sub)
+ prompt = 'Questions: \n{}\nAnswers: \n'
+ qs = {int(sub.iloc[i]['index']): sub.iloc[i]['question'] for i in range(nq)}
+ prompt = prompt.format(json.dumps(qs))
+ message.append(dict(type='text', value=prompt))
+ return message
+
+ def build_prompt_nopack(self, line, video_llm):
+ if isinstance(line, int):
+ assert line < len(self)
+ line = self.data.iloc[line]
+ if video_llm:
+ question = line['question']
+ prefix, video_idx_path = os.path.split(line['video_path'])
+ message = [dict(type='text', value=question)]
+ message.append(dict(type='video', value=os.path.join(self.video_path, video_idx_path)))
+ return message
+ else:
+ frames = self.save_video_frames(line['video'])
+ sys_prompt = self.FRAMES_TMPL_NOPACK.format(len(frames))
+ message = [dict(type='text', value=sys_prompt)]
+ for im in frames:
+ message.append(dict(type='image', value=im))
+ prompt = 'Question: {}\nAnswer: '.format(line['question'])
+ message.append(dict(type='text', value=prompt))
+ return message
+
+ def build_prompt(self, line, video_llm):
+ if self.pack and not video_llm:
+ return self.build_prompt_pack(line)
+ else:
+ return self.build_prompt_nopack(line, video_llm)
+
+ @staticmethod
+ def remove_side_quote(s, syms=[',', '"', "'"]):
+ if np.all([x in syms for x in s]):
+ return ''
+ while s[0] in syms:
+ s = s[1:]
+ while s[-1] in syms:
+ s = s[:-1]
+ return s
+
+ @staticmethod
+ def robust_json_load(s):
+ try:
+ jsons = list(extract_json_objects(s))
+ assert len(jsons) == 1
+ return jsons[0]
+ except:
+ if '{' in s and s.find('{') == s.rfind('{'):
+ sub_str = s[s.find('{') + 1:].strip()
+ lines = sub_str.split('\n')
+ res = {}
+ for l in lines:
+ l = l.strip()
+ if ': ' in l:
+ key = l.split(': ')[0].strip()
+ val = l.split(': ')[1].strip()
+ key = MMBenchVideo.remove_side_quote(key)
+ val = MMBenchVideo.remove_side_quote(val)
+ if len(key) and len(val):
+ res[key] = val
+ return res
+ return None
+
+ def load_pack_answers(self, data_raw):
+ vstats = defaultdict(lambda: 0)
+ data = defaultdict(lambda: {})
+
+ for k in data_raw:
+ ans = data_raw[k].strip()
+ if FAIL_MSG in ans:
+ vstats['GEN_FAIL'] += 1
+ continue
+ res = self.robust_json_load(ans)
+ if res is not None:
+ data[k] = res
+ vstats['PARSE_OK'] += 1
+ else:
+ vstats['PARSE_FAIL'] += 1
+
+ # return data
+ meta = cp.deepcopy(self.data)
+ lt = len(meta)
+ prediction = []
+ for i in range(lt):
+ line = meta.iloc[i]
+ vid = line['video']
+ idx = str(line['index'])
+ prediction.append(data[vid][idx] if idx in data[vid] else None)
+ meta['prediction'] = prediction
+ vstats['VALIDQ'] = len([x for x in prediction if x is not None])
+ vstats['INVALIDQ'] = len([x for x in prediction if x is None])
+ return meta, vstats
+
+ # It returns a dictionary
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.mmbench_video import get_dimension_rating, system_prompt, build_prompt
+
+ assert eval_file.endswith('.xlsx'), 'data file should be an xlsx file'
+ judge = judge_kwargs['model']
+ nproc = judge_kwargs.pop('nproc', 4)
+
+ tmp_file = eval_file.replace('.xlsx', f'_{judge}_tmp.pkl')
+ tgt_file = eval_file.replace('.xlsx', f'_{judge}_rating.json')
+ score_file = eval_file.replace('.xlsx', f'_{judge}_score.xlsx')
+
+ model = build_judge(system_prompt=system_prompt, **judge_kwargs)
+ assert model.working(), 'MMBench-Video evaluation requires a working OPENAI API\n' + DEBUG_MESSAGE
+
+ if not osp.exists(score_file):
+ res = {} if not osp.exists(tmp_file) else load(tmp_file)
+ res = {k: v for k, v in res.items() if model.fail_msg not in v}
+
+ data = load(eval_file)
+ data_un = data[~data['index'].isin(res)]
+ data_un = data_un[~pd.isna(data_un['prediction'])]
+ lt = len(data_un)
+ prompts = [build_prompt(data_un.iloc[i]) for i in range(lt)]
+ indices = [data_un.iloc[i]['index'] for i in range(lt)]
+
+ if len(prompts):
+ _ = track_progress_rich(
+ model.generate,
+ prompts,
+ keys=indices,
+ save=tmp_file,
+ nproc=nproc,
+ chunksize=nproc
+ )
+ score_map = load(tmp_file)
+ data['score'] = [score_map[idx] if idx in score_map else -1 for idx in data['index']]
+ rejected = [x for x in score_map.values() if FAIL_MSG in x]
+ data['score'] = [int(x) if istype(x, int) else -1 for x in data['score']]
+ print(
+ f'Among {len(data)} questions, failed to obtain prediction for {len(data) - len(score_map)} questions, '
+ f'failed to obtain the score for another {len(rejected)} questions. '
+ f'Those questions will be counted as 0 score in ALL rating, and will not be counted in VALID rating.'
+ )
+
+ dump(data, score_file)
+
+ rating = get_dimension_rating(score_file)
+ dump(rating, tgt_file)
+ return rating
diff --git a/vlmeval/dataset/mmdocbench.py b/vlmeval/dataset/mmdocbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..6eabf5c11cbb83d1b8f90dc3eec64ac6c4a307a9
--- /dev/null
+++ b/vlmeval/dataset/mmdocbench.py
@@ -0,0 +1,56 @@
+import pathlib
+from vlmeval.dataset.utils.mmdocbench_eval import update_data_format, eval_mmdocbench
+
+from .image_base import ImageBaseDataset
+from ..smp import *
+
+
+class MMDocBench(ImageBaseDataset):
+ TYPE = 'MMDoc'
+ DATASET_URL = {
+ 'MMDocBench': ''
+ }
+ DATASET_MD5 = {'MMDocBench': None}
+
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ data = load(eval_file)
+ data2 = update_data_format(data)
+ data2.drop("task", axis=1, inplace=True)
+ data2.drop("sub_task", axis=1, inplace=True)
+ data2.drop("image_path", axis=1, inplace=True)
+ data2.drop("full_prediction", axis=1, inplace=True)
+ data2.drop("raw_question", axis=1, inplace=True)
+ data2.drop("question", axis=1, inplace=True)
+ data2 = json.loads(data2.to_json(orient="records"))
+ accs = {"Visual Perception": 0, "Visual Reasoning": 0}
+ cnts = {"Visual Perception": 0, "Visual Reasoning": 0}
+ for r in data2:
+ cnts[r["category"]] += 1
+ accs[r["category"]] += eval_mmdocbench("" if r["prediction"] is None else r["prediction"], r["answer"], strict=False)
+ for k in accs:
+ accs[k] = accs[k] / cnts[k]
+ accs["Overall"] = (accs["Visual Perception"] + accs["Visual Reasoning"]) / 2
+ df_score = pd.DataFrame.from_dict(accs, orient='index', columns=['accuracy'])
+ # save df_score to xlsx
+ df_score.to_excel(eval_file.replace('.xlsx', '_score.xlsx'), index=True)
+ return df_score
+
+ def build_prompt(self, line):
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ if self.meta_only:
+ tgt_path = toliststr(line['image_path'])
+ else:
+ tgt_path = self.dump_image(line)
+
+ question = line['question']
+ msgs = []
+ if isinstance(tgt_path, list):
+ msgs.extend([dict(type='image', value=p) for p in tgt_path])
+ else:
+ msgs = [dict(type='image', value=tgt_path)]
+ msgs.append(dict(type='text', value=question))
+
+ return msgs
diff --git a/vlmeval/dataset/mmgenbench.py b/vlmeval/dataset/mmgenbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..7dec7946383f7dc6119ba3d6aebd6eabe0daa850
--- /dev/null
+++ b/vlmeval/dataset/mmgenbench.py
@@ -0,0 +1,69 @@
+import warnings
+import pandas as pd
+from abc import abstractmethod
+from ..smp import *
+from .image_base import ImageBaseDataset
+
+
+class MMGenBench(ImageBaseDataset):
+
+ prompt_list = [
+ """
+# Role
+You are an expert in the field of image understanding, focusing on the \
+understanding of images and generating the image caption-prompt.
+
+# Definition Explanation
+image caption-prompt: Refers to the caption or description of an image, \
+used to provide to a Text-to-Image model to generate a new image.
+Text-to-Image model: Can generate a new image based on the provided image \
+caption-prompt, such as stable diffusion 3, flux, and other image generation models.
+
+# Task Description
+Generate an image caption-prompt based on the input image.
+
+# Key Points and Requirements
+1. Accurately understand the input image and precisely generate an image caption-prompt.
+2. The generated image caption-prompt, when provided to the Text-to-Image model, requires the \
+Text-to-Image model to generate a new image that is as consistent as possible with the input image.
+3. The generated image caption-prompt must conform to the preferences of the Text-to-Image model.
+4. The generated image caption-prompt should describe the input image in as much \
+detail as possible, and it should be between 20 to 60 words.
+
+# Output Format
+A string, that is the image caption-prompt. No extra output needed.
+"""
+ ]
+ TYPE = 'GenerateImgPrompt'
+ DATASET_URL = {
+ 'MMGenBench-Test': 'https://huggingface.co/datasets/lerogo/MMGenBench/resolve/main/MMGenBench-Test.tsv',
+ 'MMGenBench-Domain': 'https://huggingface.co/datasets/lerogo/MMGenBench/resolve/main/MMGenBench-Domain.tsv',
+ }
+ PROMPT_MAP = {
+ 'MMGenBench-Test': prompt_list[0],
+ 'MMGenBench-Domain': prompt_list[0],
+ }
+ DATASET_MD5 = {
+ 'MMGenBench-Test': "94f8dac6bbf7c20be403f99adeaa73da",
+ 'MMGenBench-Domain': "5c10daf6e2c5f08bdfb0701aa6db86bb",
+ }
+
+ def __init__(self, dataset='MMGenBench', **kwargs):
+ super().__init__(dataset, **kwargs)
+ warnings.warn('This dataset is for inference only and does not support direct output of evaluation results.\n')
+ warnings.warn('Please refer to "https://github.com/lerogo/MMGenBench" for more evaluation information.\n')
+
+ def load_data(self, dataset):
+ data = super().load_data(dataset)
+ if 'question' not in data:
+ data['question'] = [(
+ self.PROMPT_MAP[dataset]
+ )] * len(data)
+ return data
+
+ # Given the prediction file, return the evaluation results in the format of a dictionary or pandas dataframe
+ @abstractmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ warnings.warn('This evaluation method is not supported.\n')
+ warnings.warn('Please refer to "https://github.com/lerogo/MMGenBench" for more evaluation information.\n')
+ return None
diff --git a/vlmeval/dataset/mmlongbench.py b/vlmeval/dataset/mmlongbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..8a7af74210dcf103cb2a3be7e12270b0b2de8841
--- /dev/null
+++ b/vlmeval/dataset/mmlongbench.py
@@ -0,0 +1,584 @@
+import re
+import math
+from urllib.request import urlopen
+from PIL import Image, ImageDraw, ImageFont
+import torchvision.transforms as transforms
+
+from vlmeval.dataset.utils import build_judge, levenshtein_distance
+from vlmeval.smp import *
+from .image_base import ImageBaseDataset
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+def get_gpt4_ICE():
+ example_1 = """
+---
+Question: List the primary questions asked about the services in this report.
+Analysis: The primary questions asked about the services in the report for The Limes Residential Home are:\n\n
+1. Is the service safe?\n
+2. Is the service effective?\n
+3. Is the service caring?\n
+4. Is the service responsive?\n
+5. Is the service well-led?
+Extracted answer: [
+ 'Is the servife safe?',
+ 'Is the service effective',
+ 'Is the serve caring?',
+ 'Is the service responsive?',
+ 'Is the service well-led?'
+]
+Answer format: List\n
+"""
+
+ example_2 = """
+---
+Question: How many regulations of the HSCA 2008 are breached in all according to this report?
+Analysis: According to the report, the provider breached 10 Health and Social Care Act 2008 (Regulated Activities)
+Regulations in total. Here are the specifics:\n\n1. Regulation 13: Safeguarding service users from abuse and
+improper treatment\n2. Regulation 12: Safe care and treatment\n3. Regulation 18: Staffing\n4. Regulation 11:
+Need for consent\n5. Regulation 10: Dignity and respect\n6. Regulation 9: Person-centred care\n7. Regulation 17:
+Good governance\n8. Regulation 18 (CQC Registration Regulations 2009): Notification of other incidents\n9.
+Regulation 18: Failure to maintain an accurate and up-to-date care plan\n10. Regulation 11: Failure to implement
+the Mental Capacity Act 2005 code of practice effectively\n\nThese breaches involve issues concerning staffing,
+safeguarding, medicines management, dignity and respect, consent, care planning, governance, and failure to
+notify the CQC of incidents.
+Extracted answer: 10
+Answer format: Integer\n
+"""
+
+ example_3 = """
+---
+Question: According to the survey that is the percentage of Chinese who are paying more or
+about the same attention to politics after Trump's election?
+Analysis: The survey provided does not specify the percentage of Chinese individuals specifically who are paying
+more or about the same attention to politics after Trump's election. The report focuses primarily on American
+demographics and does not include specific details about the Chinese population in relation to this question. If
+you need information about a different demographic or a summary of the findings from the American demographic,
+I can certainly help with that!
+Extracted answer: Not answerable
+Answer format: String\n
+"""
+
+ example_4 = """
+---
+Question: How many quotations from male respondent over 50 years old are included in this report?
+Analysis: The image you've provided appears to be a screenshot of a document with multiple charts. However, the
+text is too small and blurry to read accurately. If you can provide a clearer image or more context, I might be
+able to help you with your question.
+Extracted answer: Fail to answer
+Answer format: String\n
+"""
+
+ return [example_1, example_2, example_3, example_4]
+
+
+def build_mmlongbench_gpt4_prompt(line):
+ task_description = """
+Given the question and analysis, you are tasked to extract answers with required formats from the free-form analysis.
+- Your extracted answers should be one of the following formats: (1) Integer, (2) Float, (3) String and (4) List.
+If you find the analysis the question can not be answered from the given documents, type "Not answerable".
+Exception: If the analysis only tells you that it can not read/understand the images or documents,
+type "Fail to answer".
+- Please make your response as concise as possible. Also note that your response should be formatted as below:
+```
+Extracted answer: [answer]
+Answer format: [answer format]
+```
+Please read the following example, then extract the answer from the model response
+and type it at the end of the prompt.\n
+"""
+ question = line['question']
+ prediction = str(line['prediction'])
+ prompt = task_description
+ examples = get_gpt4_ICE()
+ for example in examples:
+ prompt += example
+ prompt += '---\nQuestion:' + question + '\n'
+ prompt += 'Analysis: ' + prediction
+ return prompt
+
+
+def anls_compute(groundtruth, prediction, threshold=0.5):
+ dist = levenshtein_distance(groundtruth, prediction)
+ length = max(len(groundtruth.upper()), len(prediction.upper()))
+ value = 0.0 if length == 0 else float(dist) / float(length)
+ anls = 1.0 - value
+ if anls <= threshold:
+ anls = 0.0
+ return anls
+
+
+def is_float_equal(reference, prediction, include_percentage: bool = False, is_close: float = False) -> bool:
+ def get_precision(gt_ans: float) -> int:
+ precision = 3
+ if '.' in str(gt_ans):
+ precision = len(str(gt_ans).split('.')[-1])
+ return precision
+
+ reference = float(str(reference).strip().rstrip('%').strip())
+ try:
+ prediction = float(str(prediction).strip().rstrip('%').strip())
+ except:
+ return False
+
+ if include_percentage:
+ gt_result = [reference / 100, reference, reference * 100]
+ else:
+ gt_result = [reference]
+ for item in gt_result:
+ try:
+ if is_close:
+ if math.isclose(item, prediction, rel_tol=0.01):
+ return True
+ precision = max(min(get_precision(prediction), get_precision(item)), 2)
+ if round(prediction, precision) == round(item, precision):
+ return True
+ except Exception:
+ continue
+ return False
+
+
+def get_clean_string(s):
+ s = str(s).lower().strip()
+ if s.endswith('mile'):
+ s.rstrip('mile').strip()
+ if s.endswith('miles'):
+ s.rstrip('miles').strip()
+ if s.endswith('million'):
+ s.rstrip('million').strip()
+ # remove parenthesis
+ s = re.sub(r'\s*\([^)]*\)', '', s).strip()
+ # remove quotes
+ s = re.sub(r"^['\"]|['\"]$", '', s).strip()
+ s = s.strip().lstrip('$').strip()
+ s = s.strip().rstrip('%').strip()
+ return s
+
+
+def is_exact_match(s):
+ flag = False
+ # Website
+ if 'https://' in s:
+ flag = True
+ # code file
+ if s.endswith('.py') or s.endswith('ipynb'):
+ flag = True
+ if s.startswith('page'):
+ flag = True
+ # telephone number
+ if re.fullmatch(r'\b\d+(-\d+|\s\d+)?\b', s):
+ flag = True
+ # time
+ if 'a.m.' in s or 'p.m.' in s:
+ flag = True
+ # YYYY-MM-DD
+ if re.fullmatch(r'\b\d{4}[-\s]\d{2}[-\s]\d{2}\b', s):
+ flag = True
+ # YYYY-MM
+ if re.fullmatch(r'\b\d{4}[-\s]\d{2}\b', s):
+ flag = True
+ # Email address
+ if re.fullmatch(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}', s):
+ flag = True
+ return flag
+
+
+def isfloat(num):
+ try:
+ float(num)
+ return True
+ except ValueError:
+ return False
+
+
+def get_font():
+ try:
+ truetype_url = "http://opencompass.openxlab.space/utils/Fonts/SimHei.ttf"
+ ff = urlopen(truetype_url)
+ font = ImageFont.truetype(ff, size=40)
+ except Exception as e:
+ logging.warning(f'{type(e)}: {e}')
+ logging.warning("Fail to download the font. Use the default one.")
+ font = ImageFont.load_default(size=40)
+ return font
+
+
+def frame2img(img_path_list, font, save_path=None, idx_start=0):
+ imgs = [Image.open(img_path) for img_path in img_path_list]
+
+ new_imgs = []
+ for img in imgs:
+ w, h = img.size
+ scale = w / h
+ if w > h:
+ new_w = 560 * 2
+ new_h = int(560 * 2 / scale)
+ else:
+ new_w = int(560 * 2 * scale)
+ new_h = 560 * 2
+ img = transforms.functional.resize(img, [new_h, new_w],)
+ new_imgs.append(img)
+ imgs = new_imgs
+ new_w = 0
+ new_h = 0
+ pad = 40
+ if w > h:
+ for im in imgs:
+ w, h = im.size
+ new_w = max(new_w, w)
+ new_h += h + 10 + pad
+ new_img = Image.new("RGB", (new_w, new_h), "white")
+ draw = ImageDraw.Draw(new_img)
+ curr_h = 0
+ for idx, im in enumerate(imgs):
+ w, h = im.size
+ new_img.paste(im, (0, pad + curr_h))
+ draw.text((0, curr_h), f"", font=font, fill="black")
+ if idx + 1 < len(imgs):
+ draw.line([(0, pad + curr_h + h + 5), (new_w, pad + curr_h + h + 5)], fill='black', width=2)
+ curr_h += h + 10 + pad
+ else:
+ for im in imgs:
+ w, h = im.size
+ new_w += w + 10
+ new_h = max(new_h, h)
+ new_h += pad
+ new_img = Image.new('RGB', (new_w, new_h), 'white')
+ draw = ImageDraw.Draw(new_img)
+ curr_w = 0
+ for idx, im in enumerate(imgs):
+ w, h = im.size
+ new_img.paste(im, (curr_w, pad))
+ draw.text((curr_w, 0), f"", font=font, fill='black')
+ if idx + 1 < len(imgs):
+ draw.line([(curr_w + w + 5, 0), (curr_w + w + 5, new_h)], fill='black', width=2)
+ curr_w += w + 10
+
+ if save_path is not None:
+ new_img.save(save_path)
+
+ return new_img
+
+
+def concat_images(image_list, max_concat=1, column_num=1):
+ concatenated_images = []
+ if column_num == -1:
+ MAX_COLUMN_NUM = 20
+ max_concat = 1
+ while len(image_list) / max_concat > MAX_COLUMN_NUM:
+ max_concat += 1
+ interval = max(math.ceil(len(image_list) / max_concat), 1)
+ for i in range(0, len(image_list), interval):
+ batch_images = image_list[i:i + interval]
+ concatenated_image = frame2img(batch_images, font=get_font(), idx_start=i)
+ concatenated_images.append(concatenated_image)
+ else:
+ interval = max(math.ceil(len(image_list) / max_concat), 1)
+ for i in range(0, len(image_list), interval):
+ batch_images = [Image.open(filename) for filename in image_list[i:i + interval]]
+ if column_num == 1:
+ total_height = batch_images[0].height * len(batch_images)
+ else:
+ total_height = batch_images[0].height * ((len(batch_images) - 1) // column_num + 1)
+ concatenated_image = Image.new('RGB', (batch_images[0].width * column_num, total_height), 'white')
+
+ x_offset, y_offset = 0, 0
+ for count, image in enumerate(batch_images):
+ concatenated_image.paste(image, (x_offset, y_offset))
+ x_offset += image.width
+ if (count + 1) % column_num == 0:
+ y_offset += image.height
+ x_offset = 0
+ concatenated_images.append(concatenated_image)
+ return concatenated_images
+
+
+def eval_score(gt, pred, answer_type):
+ if answer_type == 'Int':
+ try:
+ gt, pred = int(gt), int(float(pred))
+ except:
+ pred = ''
+ score = (gt == pred)
+ elif answer_type == 'Float':
+ try:
+ gt = float(get_clean_string(str(gt)))
+ pred = float(get_clean_string(str(pred)))
+ except:
+ pred = ''
+ score = is_float_equal(gt, pred, include_percentage=True, is_close=True)
+ elif answer_type == 'Str':
+ gt = get_clean_string(gt)
+ pred = get_clean_string(pred)
+ if is_exact_match(gt):
+ score = (gt == pred)
+ else:
+ score = anls_compute(gt, pred)
+ else:
+ if isinstance(gt, str) and gt.startswith('['):
+ gt = eval(gt)
+ if not isinstance(gt, list):
+ gt = [gt]
+ if isinstance(pred, str) and pred.startswith('['):
+ pred = eval(pred)
+ if not isinstance(pred, list):
+ pred = [pred]
+ print(len(gt), len(pred))
+ if len(gt) != len(pred):
+ score = 0.0
+ else:
+ gt = sorted([get_clean_string(a) for a in gt])
+ pred = sorted([get_clean_string(a) for a in pred])
+ print(gt, pred)
+ if isfloat(gt[0]) or is_exact_match(gt[0]):
+ score = ('-'.join(gt) == '-'.join(pred))
+ else:
+ score = min([anls_compute(gt_v, pred_v) for gt_v, pred_v in zip(gt, pred)])
+
+ return float(score)
+
+
+def MMLongBench_auxeval(model, line):
+ prompt = build_mmlongbench_gpt4_prompt(line)
+ log = ''
+ retry = 5
+
+ for i in range(retry):
+ prediction = line['prediction']
+ res = model.generate(prompt, temperature=i * 0.5)
+
+ if FAIL_MSG in res:
+ log += f'Try {i}: output is {prediction}, failed to parse.\n'
+ else:
+ log += 'Succeed'
+ try:
+ pred = res.split('Answer format:')[0].split('Extracted answer:')[1].strip()
+ except:
+ pred = ''
+ return dict(log=log, res=res, pred=pred)
+ log += 'All 5 retries failed.\n'
+ return dict(log=log, res='', pred='')
+
+
+def get_f1(data):
+ gt_pos_data = data[data.apply(lambda k: k['answer'] != 'Not answerable', axis=1)]
+ pred_pos_data = data[data.apply(lambda k: k['pred'] != 'Not answerable', axis=1)]
+ recall = sum(gt_pos_data['score'].tolist()) / len(gt_pos_data)
+ precision = sum(pred_pos_data['score'].tolist()) / len(pred_pos_data)
+ return 2 * recall * precision / (recall + precision)
+
+
+def MMLongBench_acc(result_file):
+ data = load(result_file)
+ overall_score = 0.0
+ score_list = list()
+ for i in range(len(data)):
+ item = data.iloc[i]
+ try:
+ score = eval_score(item['answer'], item['pred'], item['answer_format'])
+ except:
+ score = 0.0
+ score_list.append(score)
+ overall_score += score
+
+ data['score'] = score_list
+ dump(data, result_file)
+
+ data_chart = data[data.apply(lambda k: 'Chart' in eval(k['evidence_sources']), axis=1)]
+ data_table = data[data.apply(lambda k: 'Table' in eval(k['evidence_sources']), axis=1)]
+ data_image = data[data.apply(lambda k: 'Figure' in eval(k['evidence_sources']), axis=1)]
+ data_text = data[data.apply(lambda k: 'Pure-text (Plain-text)' in eval(k['evidence_sources']), axis=1)]
+ data_layout = data[data.apply(lambda k: 'Generalized-text (Layout)' in eval(k['evidence_sources']), axis=1)]
+
+ data_single = data[data.apply(lambda k: len(eval(k['evidence_pages'])) == 1, axis=1)]
+ data_multi = data[data.apply(lambda k: len(eval(k['evidence_pages'])) > 1, axis=1)]
+ data_unans = data[data.apply(lambda k: len(eval(k['evidence_pages'])) == 0, axis=1)]
+
+ res = dict()
+ res['category'] = [
+ 'overall_f1', 'overall_acc', 'text', 'layout', 'table', 'chart',
+ 'image', 'single-page', 'multi-page', 'unanswerable'
+ ]
+ res['num'] = [
+ len(data), len(data), len(data_text), len(data_layout), len(data_table),
+ len(data_chart), len(data_image), len(data_single), len(data_multi), len(data_unans)
+ ]
+ res['avg_score'] = [
+ get_f1(data),
+ overall_score / len(data),
+ sum(data_text['score'].tolist()) / len(data_text) if len(data_text) > 0 else 0.0,
+ sum(data_layout['score'].tolist()) / len(data_layout) if len(data_layout) > 0 else 0.0,
+ sum(data_table['score'].tolist()) / len(data_table) if len(data_table) > 0 else 0.0,
+ sum(data_chart['score'].tolist()) / len(data_chart) if len(data_chart) > 0 else 0.0,
+ sum(data_image['score'].tolist()) / len(data_image) if len(data_image) > 0 else 0.0,
+ sum(data_single['score'].tolist()) / len(data_single) if len(data_single) > 0 else 0.0,
+ sum(data_multi['score'].tolist()) / len(data_multi) if len(data_multi) > 0 else 0.0,
+ sum(data_unans['score'].tolist()) / len(data_unans) if len(data_unans) > 0 else 0.0,
+ ]
+ res = pd.DataFrame(res)
+ return res
+
+
+class MMLongBench(ImageBaseDataset):
+
+ TYPE = 'VQA'
+
+ DATASET_URL = {
+ 'MMLongBench_DOC': 'https://opencompass.openxlab.space/utils/VLMEval/MMLongBench_DOC.tsv',
+ }
+ DATASET_MD5 = {
+ 'MMLongBench_DOC': '9b393e1f4c52718380d50586197eac9b',
+ }
+
+ SUPPORTED_MODELS = {
+ 'GPT4': (1, 1),
+ 'GPT4V': (1, 1),
+ 'GPT4V_HIGH': (1, 1),
+ 'GPT4o': (1, 1),
+ 'GPT4o_HIGH': (1, 1),
+ 'GPT4o_MINI': (1, 1),
+ 'MiniCPM-Llama3-V-2_5': (1, 5),
+ 'InternVL-Chat-V1-5': (5, 2),
+ 'XComposer2_4KHD': (1, 5),
+ 'XComposer2d5': (1, -1),
+ }
+
+ def __init__(self, dataset, **kwargs):
+ self.model_list = list(self.SUPPORTED_MODELS.keys())
+ model_name = kwargs['model']
+ if not listinstr(self.model_list, model_name):
+ raise AssertionError("{} doesn't support the evaluation on MMLongBench_DOC.".format(model_name))
+ super(MMLongBench, self).__init__(dataset)
+
+ self.is_api = True if listinstr(['GPT4'], model_name) else False
+ self.max_pages = 120
+ concat_num, column_num = self.SUPPORTED_MODELS.get(model_name)
+ self.concat_num = concat_num
+ self.column_num = column_num
+
+ def dump_image(self, origin_line):
+ os.makedirs(self.img_root, exist_ok=True)
+ try:
+ import fitz
+ except Exception as e:
+ logging.critical(f'{type(e)}: {e}')
+ logging.critical('Please use `pip install pymupdf` to parse PDF files.')
+
+ line = origin_line.copy()
+ line['image_path'] = line['image_path'][:self.max_pages]
+ skip_pdf_parse = True
+ for im_name in line['image_path']:
+ path = osp.join(self.img_root, im_name)
+ if not read_ok(path):
+ skip_pdf_parse = False
+ break
+
+ # Just for being compatible with the zooped loop: zip(line['image'], line['image_path'])
+ if skip_pdf_parse:
+ line['image'] = line['image_path']
+ else:
+ pdf_data = base64.b64decode(line['image'])
+ pdf_file = io.BytesIO(pdf_data)
+ encoded_images = []
+ with fitz.open(stream=pdf_file, filetype='pdf') as doc:
+ doc = doc[:self.max_pages]
+ for page in doc:
+ image = page.get_pixmap(dpi=144)
+ image_file = io.BytesIO(image.tobytes(output='png'))
+ image = Image.open(image_file)
+ encoded_image = encode_image_to_base64(image)
+ encoded_images.append(encoded_image)
+ line['image'] = encoded_images
+ print('process {}'.format(line['doc_id']))
+
+ if 'image' in line:
+ if isinstance(line['image'], list):
+ tgt_path = []
+ assert 'image_path' in line
+ for img, im_name in zip(line['image'], line['image_path']):
+ path = osp.join(self.img_root, im_name)
+ if not read_ok(path):
+ decode_base64_to_image_file(img, path)
+ tgt_path.append(path)
+ else:
+ tgt_path = osp.join(self.img_root, f"{line['index']}.jpg")
+ if not read_ok(tgt_path):
+ decode_base64_to_image_file(line['image'], tgt_path)
+ tgt_path = [tgt_path]
+ else:
+ assert 'image_path' in line
+ tgt_path = toliststr(line['image_path'])
+
+ if self.concat_num > 0 and not self.is_api:
+ concatenated_images = concat_images(tgt_path, max_concat=self.concat_num, column_num=self.column_num)
+
+ old_tgt_path = tgt_path
+ assert isinstance(old_tgt_path, list)
+ if self.column_num != -1:
+ tgt_path = [
+ '_'.join(old_tgt_path[0].split('_')[:-1]) + '_concat{}_{}.jpg'.format(self.concat_num, i)
+ for i in range(len(concatenated_images))
+ ]
+ else:
+ tgt_path = [
+ '_'.join(old_tgt_path[0].split('_')[:-1]) + '_concat_all_{}.jpg'.format(i)
+ for i in range(len(concatenated_images))
+ ]
+
+ for path, concatenated_image in zip(tgt_path, concatenated_images):
+ if not read_ok(path):
+ decode_base64_to_image_file(encode_image_to_base64(concatenated_image), path)
+ num_images, image_size = len(old_tgt_path), concatenated_image.size
+ print('concat {} images to a new one with size {}. save at {}'.format(num_images, image_size, path))
+ return tgt_path
+
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ logger = get_logger('Evaluation')
+ model = judge_kwargs['model']
+
+ suffix = eval_file.split('.')[-1]
+ storage = eval_file.replace(f'.{suffix}', f'_{model}.xlsx')
+ tmp_file = eval_file.replace(f'.{suffix}', f'_{model}.pkl')
+
+ if osp.exists(storage):
+ logger.warning(f'GPT scoring file {storage} already exists, will reuse it in MMLongBench_eval. ')
+ else:
+ data = load(eval_file)
+ model = build_judge(max_tokens=128, **judge_kwargs)
+ lt = len(data)
+ lines = [data.iloc[i] for i in range(lt)]
+ tups = [(model, line) for line in lines]
+ indices = [line['index'] for line in lines]
+
+ ans = {}
+ if osp.exists(tmp_file):
+ ans = load(tmp_file)
+ tups = [x for x, i in zip(tups, indices) if i not in ans]
+ indices = [i for i in indices if i not in ans]
+
+ if len(indices):
+ new_results = list()
+ for model, line in tqdm(tups):
+ res = MMLongBench_auxeval(model, line)
+ new_results.append(res)
+
+ log_map, res_map, pred_map = {}, {}, {}
+ all_inds = [line['index'] for line in lines]
+ for k, v in zip(all_inds, new_results):
+ log_map[k] = v['log']
+ res_map[k] = v['res']
+ pred_map[k] = v['pred']
+ data['res'] = [res_map[idx] for idx in data['index']]
+ data['log'] = [log_map[idx] for idx in data['index']]
+ data['pred'] = [pred_map[idx] for idx in data['index']]
+ dump(data, storage)
+
+ score = MMLongBench_acc(storage)
+ score_pth = storage.replace('.xlsx', '_score.csv')
+
+ dump(score, score_pth)
+ logger.info(f'MMLongBench_eval successfully finished evaluating {eval_file}, results saved in {score_pth}')
+ logger.info('Score: ')
+ logger.info(score)
diff --git a/vlmeval/dataset/mmmath.py b/vlmeval/dataset/mmmath.py
new file mode 100644
index 0000000000000000000000000000000000000000..b3f9c0542fd3758543c4b7f2084cfbc3e0ad4b09
--- /dev/null
+++ b/vlmeval/dataset/mmmath.py
@@ -0,0 +1,458 @@
+import re
+import json
+
+import numpy as np
+import sys
+import math
+import os
+import argparse
+import timeout_decorator
+
+from .image_base import ImageBaseDataset
+from ..utils import track_progress_rich
+from ..smp import load, dump
+
+try:
+ import sympy as sp
+ from sympy import simplify, Eq, sympify, Pow, pi
+ from sympy.parsing.latex import parse_latex
+except ImportError:
+ logging.warning('sympy is not installed, please install it for MM-Math evaluation.')
+
+
+class AutoScoringJudge:
+ def __init__(self):
+ # Map of special symbols to their replacements
+ self.special_signal_map = {
+ "\\left": "",
+ "\\right": "",
+ "厘米":"",
+ # "∶": ":",
+ "，": ",",
+ "$": "",
+ "（":"(",
+ "）":")",
+ "\\infty":"oo",
+ "\\colon ":":",
+ # "\\approx": "=",
+ # "\\simeq": "=",
+ # "\\sim": "=",
+ # "^\\prime": "'",
+ # "^{\\prime}": "'",
+ "＋":"+",
+ "\\, ": "",
+ "\\,":"",
+ "^\\circ": "",
+ "^{\\circ}": "",
+ # "%": "",
+ }
+ self.pi = parse_latex("\\pi")
+ # MM-Math default precision
+ self.precision = 1e-2
+
+ def trans_greater_sign_to_interval(self, expr:str):
+ expr_tmp = expr.split("<")
+ return "(" + expr_tmp[0] + ", " + expr_tmp[-1] + ")"
+
+ def split_by_comma(self, expr: str):
+ # Splits expressions by commas outside of brackets
+ in_bracket_num = 0
+ splitted_expr = []
+ start_idx = 0
+ for i, char in enumerate(expr):
+ if char in ["(", "["]:
+ in_bracket_num += 1
+ elif char in [")", "]"]:
+ in_bracket_num -= 1
+ elif char == "," and in_bracket_num == 0:
+ splitted_expr.append(expr[start_idx:i].strip())
+ start_idx = i + 1
+
+ if start_idx < len(expr):
+ splitted_expr.append(expr[start_idx:].strip())
+
+ return splitted_expr
+
+ def trans_plus_minus_sign(self, expr_list: list):
+ # Translates plus-minus signs into separate expressions
+ new_expr_list = []
+ for expr in expr_list:
+ if "\\pm" in expr:
+ new_expr_list.append(expr.replace("\\pm", "+"))
+ new_expr_list.append(expr.replace("\\pm", "-"))
+ else:
+ new_expr_list.append(expr)
+
+ return new_expr_list
+
+ def judge(self, expression1, expression2, precision=1e-2):
+ # Judge if two expressions are equal (expression1 is considered as the Ground Truth)
+ # Default precision is a list for supporting multiple expressions
+ precision = precision if isinstance(precision, list) else [precision]
+
+ try:
+ expression1, expression2 = self.preprocess(expression1, expression2)
+ except:
+ return False
+ if expression1 == expression2:
+ # print("Exactly equal")
+ return True
+
+ # Remove Chinese characters from the string, as answers like "yes" or "no" in Chinese have been considered
+ expression1 = expression1 if re.fullmatch(r"[\u4e00-\u9fff]+", expression1) else re.sub(r'[\u4e00-\u9fff]+', '', expression1) # noqa: E501
+ expression2 = expression2 if re.fullmatch(r'[\u4e00-\u9fff]+', expression2) else re.sub(r'[\u4e00-\u9fff]+', '', expression2) # noqa: E501
+ # Check if two < or > in expression
+ if self.is_two_greater_sign(expression1):
+ expression1 = self.trans_greater_sign_to_interval(expression1)
+
+ if self.is_two_greater_sign(expression2):
+ expression2 = self.trans_greater_sign_to_interval(expression2)
+
+ expression1 = self.split_by_comma(expression1)
+ expression2 = self.split_by_comma(expression2)
+
+ temp_list1 = self.trans_plus_minus_sign(expression1)
+ temp_list2 = self.trans_plus_minus_sign(expression2)
+
+ # Set up a list for allowed errors
+ if len(precision) <= 1:
+ precision = precision * len(temp_list1)
+
+ if len(temp_list1) != len(temp_list2):
+ return False
+
+ # Check if elements in both lists can be paired and are equal
+ idx = -1
+ while len(temp_list1) != 0:
+ idx = (idx + 1) % len(temp_list1)
+
+ item1 = temp_list1[idx]
+ self.precision = precision[idx]
+
+ for item2 in temp_list2:
+ try:
+ if self.is_equal(item1, item2):
+ temp_list1.remove(item1)
+ temp_list2.remove(item2)
+ precision.remove(self.precision)
+ break
+ except Exception as err:
+ logging.warning(f'{type(err)}: {err}')
+ continue
+ else:
+ # If no match was found, return False
+ return False
+
+ # If all elements are matched, return True
+ return True
+
+ def is_interval(self, expr):
+ # Checks if an expression is an interval
+ return expr.startswith(("(", "[")) and expr.endswith((")", "]"))
+
+ def is_two_greater_sign(self, expr):
+ match = re.findall(r'<', expr)
+ return len(match) == 2
+
+ def sympy_sub_pi(self, expression_sympy):
+ # Replaces the symbol for pi in sympy expressions with its numerical value
+ return expression_sympy.subs(self.pi, math.pi)
+
+ # Set timeout to 30 seconds for is_equal
+ @timeout_decorator.timeout(30)
+ def is_equal(self, expression1, expression2):
+ # Default first expression is ground truth. Check if expressions are equal in different aspects
+ if expression1 == expression2 and expression1 != "" and expression2 != "":
+ # print("Equivalent natively")
+ return True
+
+ # First check if both are intervals
+ if self.is_interval(expression1) and self.is_interval(expression2):
+ try:
+ if self.interval_equal(expression1, expression2):
+ # print("Interval equivalent")
+ return True
+ except:
+ return False
+
+ # Then check for numerical equality
+ try:
+ if self.numerical_equal(expression1, expression2):
+ # print("Numerically equivalent")
+ return True
+ except:
+ pass
+ # Then check if expressions are mathematically equal
+ try:
+ if self.expression_equal(expression1, expression2) and not ("=" in expression1 and "=" in expression2):
+ # print("Expression equivalent")
+ return True
+ except:
+ pass
+
+ # Lastly, check for equation equality
+ try:
+ if self.equation_equal(expression1, expression2):
+ # print("Equation equivalent")
+ return True
+ except:
+ pass
+
+ return False
+
+ def numerical_equal(self, expression1: str, expression2: str, include_percentage: bool = True):
+ # Check if two numerical values are equal within an allowed error range
+ # Includes possible percentage cases
+ reference = float(expression1)
+ prediction = float(expression2)
+
+ if include_percentage:
+ gt_result = [reference / 100, reference, reference * 100]
+ else:
+ gt_result = [reference]
+
+ for item in gt_result:
+ if abs(item - prediction) <= self.precision * 1.01:
+ return True
+ return False
+
+ def expression_equal(self, exp1, exp2):
+ # Check if two expressions are mathematically equivalent
+ # Extract expression and use sympy for equivalence checking
+ def extract_expression(expression):
+ if "=" in expression:
+ expression = expression.split("=")[1]
+ return expression.strip()
+
+ exp1 = extract_expression(exp1)
+ exp2 = extract_expression(exp2)
+
+ exp_too_long = len(exp1) > 300 or len(exp2) > 300
+
+ expr1_sym = sympify(parse_latex(exp1))
+ expr2_sym = sympify(parse_latex(exp2))
+ if expr1_sym == expr2_sym:
+ return True
+ else:
+ expr1_sym = self.sympy_sub_pi(expr1_sym)
+ expr2_sym = self.sympy_sub_pi(expr2_sym)
+
+ if (expr1_sym.has(sp.Symbol) and not expr2_sym.has(sp.Symbol)) or \
+ (not expr1_sym.has(sp.Symbol) and expr2_sym.has(sp.Symbol)):
+ return False
+ elif not expr1_sym.has(sp.Symbol) and not expr2_sym.has(sp.Symbol):
+ try:
+ if not (self.can_compute_power(expr1_sym) and self.can_compute_power(expr2_sym)):
+ print("These two numbers cannot be calculated by the current computer for: "
+ f"\"{str(expr1_sym)}\" and \"{str(expr2_sym)}\"")
+ return False
+ if exp_too_long:
+ print(f'Expression {exp1} or {exp2} is too long to compute. ')
+ return False
+ if abs(expr1_sym.evalf() - expr2_sym.evalf()) <= self.precision * 1.01:
+ return True
+ else:
+ return False
+ except:
+ return False
+ elif exp_too_long:
+ print(f'Expression {exp1} or {exp2} is too long to compute. ')
+ return False
+ else:
+ try:
+ simplified_expr = simplify(expr1_sym - expr2_sym)
+ num_value = simplified_expr.evalf()
+ return abs(num_value) < 1e-3
+ except:
+ return False
+
+ def equation_equal(self, expression1, expression2):
+ # Check if two equations are mathematically equivalent
+ # Simplify equations and use sympy for equivalence checking
+ def simplify_equation(latex_eq):
+ lhs, rhs = latex_eq.split('=')
+
+ lhs_expr = parse_latex(lhs)
+ rhs_expr = parse_latex(rhs)
+
+ equation = Eq(lhs_expr, rhs_expr)
+
+ simplified_eq = simplify(equation.lhs - equation.rhs)
+
+ return simplified_eq
+
+ expr1_sym = simplify_equation(expression1)
+ expr2_sym = simplify_equation(expression2)
+
+ division_result_1 = simplify(expr1_sym / expr2_sym)
+ division_result_2 = simplify(expr2_sym / expr1_sym)
+
+ if ((division_result_1.is_Integer and division_result_1 != 0) or # noqa: W504
+ (division_result_2.is_Integer and division_result_2 != 0)):
+ return True
+ else:
+ return False
+
+ def interval_equal(self, expression1, expression2):
+ # Check if two intervals are mathematically equivalent
+ def compare_two_interval(inter1, inter2):
+ if inter1[0] != inter2[0] or inter1[-1] != inter2[-1]:
+ return False
+
+ inter1 = inter1.strip('[]()')
+ inter2 = inter2.strip('[]()')
+
+ items_1 = inter1.split(',')
+ items_2 = inter2.split(',')
+
+ for item_1, item_2 in zip(items_1, items_2):
+ if not self.expression_equal(item_1, item_2):
+ return False
+ return True
+
+ interval1 = expression1
+ interval2 = expression2
+
+ if interval1 == interval2:
+ return True
+ else:
+ inter_list1 = interval1.split("\\cup")
+ inter_list2 = interval2.split("\\cup")
+
+ if len(inter_list1) != len(inter_list2):
+ return False
+ else:
+ for inter1, inter2 in zip(inter_list1, inter_list2):
+ if not compare_two_interval(inter1, inter2):
+ return False
+ return True
+
+ def preprocess(self, expression1, expression2):
+ # Preprocess expressions to extract and replace special symbols
+ def extract_boxed_content(latex_str):
+ boxed_matches = re.finditer(r'\\boxed{', latex_str)
+ results = ""
+
+ for match in boxed_matches:
+ start_index = match.end()
+ end_index = start_index
+ stack = 1
+
+ while stack > 0 and end_index < len(latex_str):
+ if latex_str[end_index] == '{':
+ stack += 1
+ elif latex_str[end_index] == '}':
+ stack -= 1
+ end_index += 1
+
+ if stack == 0:
+ content = latex_str[start_index:end_index - 1]
+ results += content + ","
+ else:
+ raise ValueError("Mismatched braces in LaTeX string.")
+
+ if results == "":
+ last_line_ans = latex_str.strip().split("\n")[-1]
+ dollar_pattern = r"\$(.*?)\$"
+ answers = re.findall(dollar_pattern, last_line_ans)
+
+ if answers:
+ for ans in answers:
+ results += ans + ","
+ else:
+ results = latex_str
+
+ return results
+
+ def sepcial_symbol_replace(expression):
+
+ expression = expression.replace("\\text{cm}^2", '').replace("\\text{cm}", "").replace("\\,cm", '').replace("\\text{ cm}", '').replace("cm", '').replace("\\text{分米}^2", '').replace("cm^{2}", '').replace("60 \\text{ cm}^2",'').replace("\\ \\text{m}", "").replace("\\text{米}","").strip() # noqa: E501
+
+ expression = re.sub(r"(.+)m$", r"\1", expression)
+
+ if "\\in " in expression:
+ expression = expression.split("\\in ")[1]
+
+ for signal in self.special_signal_map:
+ expression = expression.replace(signal, self.special_signal_map[signal])
+
+ expression = re.sub(r'(\\sin|\\cos|\\tan)(\d+)', r'\1((\2/180)\\pi)', expression)
+
+ expression = expression.strip("\n,.:;^_=+`!@#%^&*~，。")
+
+ pattern = r'\\(?:mathrm|mathbf)\{~?([^}]*)\}'
+ expression = re.sub(pattern, r'\1', expression)
+
+ return expression
+
+ exp1, exp2 = extract_boxed_content(expression1), extract_boxed_content(expression2)
+
+ exp1, exp2 = sepcial_symbol_replace(exp1), sepcial_symbol_replace(exp2)
+
+ return exp1, exp2
+
+ def can_compute_power(self, expr):
+ # Checks if a power expression can be computed
+ if isinstance(expr, Pow):
+ base, exp = expr.as_base_exp()
+ if base.is_number and exp.is_number:
+ MAX_EXP = 1000 # Adjust based on computing environment
+ if abs(exp.evalf()) > MAX_EXP:
+ return False
+ else:
+ return True
+ else:
+ return False
+ else:
+ return True # Not a power expression, can compute
+
+
+class MMMath(ImageBaseDataset):
+
+ TYPE = 'VQA'
+
+ DATASET_URL = {
+ 'MM-Math': 'https://opencompass.openxlab.space/utils/VLMEval/MM-Math.tsv',
+ }
+ DATASET_MD5 = {
+ 'MM-Math': '1f064ed7c4e0e8926a3fa65849419ca5',
+ }
+
+ @classmethod
+ def evaluate(self, eval_file, **kwargs):
+
+ data = load(eval_file)
+ judger = AutoScoringJudge()
+ func = judger.judge
+
+ tups = [dict(expression1=x, expression2=y) for x, y in zip(data['answer'], data['prediction'])]
+
+ res = track_progress_rich(func, tups, nproc=16)
+ data['hit'] = res
+ dump(data, eval_file)
+
+ score_file = eval_file.replace('.xlsx', '_score.json')
+ score = {}
+ score['overall'] = np.mean(data['hit'])
+ # Results by Difficulty
+ difficulties = set(data['difficulty'])
+ for d in difficulties:
+ score[f'Difficulty-{d}'] = np.mean(data[data['difficulty'] == d]['hit'])
+
+ # Results by Year
+ years = set(data['year'])
+ for y in years:
+ score[f'Year-{y}'] = np.mean(data[data['year'] == y]['hit'])
+
+ # Results by Knowledge-L1
+ points = set(data['knowledge_l1'])
+ for p in points:
+ score[f'Knowledge-L1-{p}'] = np.mean(data[data['knowledge_l1'] == p]['hit'])
+
+ # Results by Knowledge-L2
+ points = set(data['knowledge_l2'])
+ for p in points:
+ score[f'Knowledge-L2-{p}'] = np.mean(data[data['knowledge_l2'] == p]['hit'])
+
+ dump(score, score_file)
+ return score
diff --git a/vlmeval/dataset/moat.py b/vlmeval/dataset/moat.py
new file mode 100644
index 0000000000000000000000000000000000000000..c35ab33c88c2fa823c25ae00f1592d854092829e
--- /dev/null
+++ b/vlmeval/dataset/moat.py
@@ -0,0 +1,166 @@
+from vlmeval.dataset.utils import build_judge
+from vlmeval.smp import *
+from .image_base import ImageBaseDataset
+from ..utils import track_progress_rich
+from ..smp import load, dump, decode_base64_to_image
+from .utils import DEBUG_MESSAGE
+
+import zipfile
+from random import shuffle, seed
+
+
+RANDOM_SEED = 0
+
+VQA_SYSTEM_PROMPT = json.dumps({
+ 'task': 'Answer the question presented to you truthfully.',
+ 'requirements': [
+ 'Analyze the image(s) first, then answer the question. If you are given a list of possible answers, you must choose from it.', # noqa: E501
+ 'You must answer in the following json format: {"analysis": "(write your analysis here)", "answer": "(your answer)"}' # noqa: E501
+ ]
+})
+
+EVAL_SYSTEM_PROMPT = json.dumps({
+ 'task': 'Evaluate whether the answer to a question is correct.',
+ 'requirements': [
+ 'Compare an answer to a question with the ground truth answer. Determine whether it is correct.',
+ 'You must ignore any analysis of the problem if present. You must focus only on the final answer.',
+ 'You must answer in the following json format: {"verdict": "(1 for correct, 0 for incorrect)"}'
+ ]
+})
+
+def str2json(s: str):
+ try:
+ return json.loads(s)
+ except:
+ if s.startswith('```json') and s.endswith('```'):
+ return json.loads(s[6:-3])
+ return s
+
+class MOAT(ImageBaseDataset):
+ TYPE = 'VQA'
+ DATASET_URL = {
+ 'MOAT': "https://huggingface.co/datasets/waltsun/MOAT/resolve/main/MOAT.tsv",
+ }
+ DATASET_MD5 = {
+ 'MOAT': '803b5a176a5b01aa1b8094fae73532a2',
+ }
+
+ def __init__(self, dataset, **kwargs):
+ super().__init__(dataset, **kwargs)
+ seed(RANDOM_SEED) # seed the random number generator to ensure reproducibility
+
+ def post_build(self, dataset):
+ assert dataset == "MOAT", f"Wrong dataset name {dataset}"
+ ROOT = LMUDataRoot()
+ os.makedirs(ROOT, exist_ok=True)
+
+ # Download images zip file
+ zip_url = "https://huggingface.co/datasets/waltsun/MOAT/resolve/main/MOAT_images.zip"
+ zip_md5 = 'c0818a3e0a3f0bc7ee2be89ff04d73a6'
+ zip_path = osp.join(ROOT, "MOAT_images.zip")
+ if osp.exists(zip_path) and md5(zip_path) == zip_md5:
+ pass
+ else:
+ warnings.warn('The dataset tsv is not downloaded')
+ download_file(zip_url, zip_path)
+
+ # Extract images
+ self.img_root = osp.join(ROOT, 'MOAT_images')
+ if not osp.exists(self.img_root):
+ with zipfile.ZipFile(osp.join(ROOT, 'MOAT_images.zip'), 'r') as zip_ref:
+ zip_ref.extractall(self.img_root)
+
+ def build_prompt(self, line):
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ question, choices, images, outside_knowledge_text, outside_knowledge_images = line['question'], line['choices'], line['images'], line['outside_knowledge_text'], line['outside_knowledge_images'] # noqa: E501
+ choices, images, outside_knowledge_images = toliststr(choices), toliststr(images), toliststr(outside_knowledge_images) # noqa: E501
+
+ if len(choices):
+ shuffle(choices) # shuffle the choices to avoid bias
+ question += f'\nThe choices are: {choices}'
+ msgs = [
+ {
+ 'type': 'text',
+ 'value': VQA_SYSTEM_PROMPT + '\n' + question,
+ },
+ ]
+ for img in images:
+ msgs.append({'type': 'image', 'value': osp.join(self.img_root, img)})
+ if not pd.isna(outside_knowledge_text):
+ msgs.append({'type': 'text', 'value': 'Hint:\n' + outside_knowledge_text})
+ for img in outside_knowledge_images:
+ msgs.append({'type': 'image', 'value': osp.join(self.img_root, img)})
+ return msgs
+
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ model = judge_kwargs['model']
+ suffix = eval_file.split('.')[-1]
+ result_path = eval_file.replace(f'.{suffix}', f"_{model}.xlsx")
+ nproc = judge_kwargs.pop('nproc', 4)
+
+ if not osp.exists(result_path):
+ data = load(eval_file)
+ model = build_judge(**judge_kwargs)
+ assert model.working(), ('MOAT evaluation requires a working OPENAI API\n' + DEBUG_MESSAGE)
+
+ def extract_prediction(s: str):
+ try:
+ return json.loads(s)['answer']
+ except:
+ pass
+ try:
+ if s.startswith('```json') and s.endswith('```'):
+ return json.loads(s[7:-3])['answer']
+ except:
+ print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ", s)
+ return s
+
+ def extract_verdict(s: str):
+ try:
+ return json.loads(s)['verdict']
+ except:
+ if s.startswith('```json') and s.endswith('```'):
+ return json.loads(s[7:-3])['verdict']
+ raise
+
+ def verdict_one(model, line):
+ prediction = extract_prediction(line['prediction'])
+ answer = line['answer']
+ prompt = EVAL_SYSTEM_PROMPT + '\n' + f'The answer to evaluate is {prediction}\nThe ground truth answer is {answer}'
+ res = model.generate(prompt)
+ return extract_verdict(res)
+
+ verdict_list = track_progress_rich(
+ lambda line: verdict_one(model, line),
+ [data.iloc[i] for i in range(len(data))],
+ nproc=nproc,
+ chunksize=nproc,
+ )
+ data['verdict'] = verdict_list
+ dump(data, result_path)
+
+ data = load(result_path)
+ overall_acc = data['verdict'].mean()
+ capability_set = set()
+ for i in range(len(data)):
+ capability_set.update(toliststr(data.iloc[i]['capability']))
+ capability_score_map = {capability: (0, 0) for capability in capability_set}
+ for i in range(len(data)):
+ line = data.iloc[i]
+ capabilities = toliststr(line['capability'])
+ verdict = line['verdict']
+ for capability in capabilities:
+ capability_score_map[capability] = (capability_score_map[capability][0] + verdict, capability_score_map[capability][1] + 1)
+ capability_score_map = {capability: score[0] / score[1] for capability, score in capability_score_map.items()}
+ metrics = {
+ 'overall_acc': overall_acc,
+ 'result_path': result_path,
+ 'capability_acc': capability_score_map,
+ }
+ score_pth = eval_file.replace(f'.{suffix}', f"_score.json")
+ dump(metrics, score_pth)
+
+ return metrics
diff --git a/vlmeval/dataset/moviechat1k.py b/vlmeval/dataset/moviechat1k.py
new file mode 100644
index 0000000000000000000000000000000000000000..61390bed0eea0809b33fb72d6291f930455cd77e
--- /dev/null
+++ b/vlmeval/dataset/moviechat1k.py
@@ -0,0 +1,264 @@
+from huggingface_hub import snapshot_download
+from ..smp import *
+from .video_base import VideoBaseDataset
+from .utils import build_judge, DEBUG_MESSAGE
+from ..utils import track_progress_rich
+import random
+import json
+import ast
+from glob import glob
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+class MovieChat1k(VideoBaseDataset):
+
+ MD5 = '7c0aa7e10de1cddb37af42b4abc9a2dd'
+
+ TYPE = 'Video-VQA'
+
+ def __init__(self, dataset='MovieChat1k', pack=False, nframe=0, fps=-1, subset='all', limit=1.0):
+ super().__init__(dataset=dataset, pack=pack, nframe=nframe, fps=fps)
+
+ if subset == 'all':
+ pass
+ elif subset == 'global':
+ self.data = self.data[self.data['mode'] == 'global']
+ elif subset == 'breakpoint':
+ self.data = self.data[self.data['mode'] == 'breakpoint']
+ else:
+ raise ValueError(f'Invalid subset: {subset}')
+
+ if limit <= 1.0 and limit > 0:
+ sample_num = int(limit * len(self.data))
+ self.data = self.data.iloc[:sample_num]
+ elif limit > 1.0 and limit < len(self.data):
+ self.data = self.data.iloc[:limit]
+ else:
+ raise ValueError(f'Invalid limit: {limit}')
+
+
+ @classmethod
+ def supported_datasets(cls):
+ return ['MovieChat1k']
+
+ def prepare_dataset(self, dataset_name='MovieChat1k', repo_id='Enxin/VLMEval-MovieChat1k'):
+ def check_integrity(pth):
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+ if md5(data_file) != self.MD5:
+ return False
+ data = load(data_file)
+ for video_pth in data['video']:
+ if not osp.exists(osp.join(pth, video_pth)):
+ return False
+ return True
+
+ if os.path.exists(repo_id):
+ dataset_path = repo_id
+ else:
+ cache_path = get_cache_path(repo_id)
+ if cache_path is not None and check_integrity(cache_path):
+ dataset_path = cache_path
+ else:
+ cache_path = snapshot_download(repo_id=repo_id, repo_type="dataset")
+ if not glob(osp.join(cache_path, "video")):
+ tar_files = glob(osp.join(cache_path, "**/*.tar*"), recursive=True)
+
+ def untar_video_data(tar_file, cache_dir):
+ import tarfile
+ with tarfile.open(tar_file, "r") as tar_ref:
+ tar_ref.extractall(cache_dir)
+ print(f"Extracted all files from {tar_file} to {cache_dir}")
+
+ def concat_tar_parts(tar_parts, output_tar):
+ with open(output_tar, "wb") as out_tar:
+ from tqdm import tqdm
+ for part in tqdm(sorted(tar_parts)):
+ with open(part, "rb") as part_file:
+ out_tar.write(part_file.read())
+ print(f"Concatenated parts {tar_parts} into {output_tar}")
+
+ tar_parts_dict = {}
+
+ # Group tar parts together
+ for tar_file in tar_files:
+ base_name = tar_file.split(".tar")[0]
+ if base_name not in tar_parts_dict:
+ tar_parts_dict[base_name] = []
+ tar_parts_dict[base_name].append(tar_file)
+
+ # Concatenate and untar split parts
+ for base_name, parts in tar_parts_dict.items():
+ print(f"Extracting following tar files: {parts}")
+ output_tar = base_name + ".tar"
+ if not osp.exists(output_tar):
+ print('Start concatenating tar files')
+
+ concat_tar_parts(parts, output_tar)
+ print('Finish concatenating tar files')
+
+ if not osp.exists(osp.join(cache_path, 'videos')):
+ untar_video_data(output_tar, cache_path)
+ dataset_path = cache_path
+ self.video_path = osp.join(dataset_path, 'videos/')
+ data_file = osp.join(dataset_path, f'{dataset_name}.tsv')
+
+ return dict(data_file=data_file, root=osp.join(dataset_path, 'videos'))
+
+ def build_prompt_pack(self, line):
+ if isinstance(line, int):
+ assert line < len(self)
+ video = self.videos[line]
+ elif isinstance(line, pd.Series):
+ video = line['video']
+ elif isinstance(line, str):
+ video = line
+
+ frames = self.save_video_frames(video)
+ message = []
+ for im in frames:
+ message.append(dict(type='image', value=im))
+
+ message.append(dict(type='text', value=line['question'], role='user'))
+ return message
+
+ def build_prompt_nopack(self, line, video_llm):
+ """Build prompt for a single line without packing"""
+ if isinstance(line, int):
+ assert line < len(self)
+ line = self.data.iloc[line]
+
+ if video_llm:
+ video_path = os.path.join(self.video_path, line['video'])
+ return [
+ dict(type='video', value=video_path),
+ dict(type='text', value=line['question'])
+ ]
+ else:
+ frames = self.save_video_frames(line['video'])
+ message = []
+ for im in frames:
+ message.append(dict(type='image', value=im))
+ message.append(dict(type='text', value=line['question']))
+ return message
+
+ def build_prompt(self, line, video_llm):
+ if self.pack and not video_llm:
+ return self.build_prompt_pack(line)
+ else:
+ return self.build_prompt_nopack(line, video_llm)
+
+ @staticmethod
+ def remove_side_quote(s, syms=[',', '"', "'"]):
+ if np.all([x in syms for x in s]):
+ return ''
+ while s[0] in syms:
+ s = s[1:]
+ while s[-1] in syms:
+ s = s[:-1]
+ return s
+
+ @staticmethod
+ def robust_json_load(s):
+ try:
+ jsons = list(extract_json_objects(s))
+ assert len(jsons) == 1
+ return jsons[0]
+ except:
+ if '{' in s and s.find('{') == s.rfind('{'):
+ sub_str = s[s.find('{') + 1:].strip()
+ lines = sub_str.split('\n')
+ res = {}
+ for l in lines:
+ l = l.strip()
+ if ': ' in l:
+ key = l.split(': ')[0].strip()
+ val = l.split(': ')[1].strip()
+ key = MovieChat1k.remove_side_quote(key)
+ val = MovieChat1k.remove_side_quote(val)
+ if len(key) and len(val):
+ res[key] = val
+ return res
+ return None
+
+ def load_pack_answers(self, data_raw):
+ vstats = defaultdict(lambda: 0)
+ data = defaultdict(lambda: {})
+
+ for k in data_raw:
+ ans = data_raw[k].strip()
+ if FAIL_MSG in ans:
+ vstats['GEN_FAIL'] += 1
+ continue
+ res = self.robust_json_load(ans)
+ if res is not None:
+ data[k] = res
+ vstats['PARSE_OK'] += 1
+ else:
+ vstats['PARSE_FAIL'] += 1
+
+ # return data
+ meta = cp.deepcopy(self.data)
+ lt = len(meta)
+ prediction = []
+ for i in range(lt):
+ line = meta.iloc[i]
+ vid = line['video']
+ idx = str(line['index'])
+ prediction.append(data[vid][idx] if idx in data[vid] else None)
+ meta['prediction'] = prediction
+ vstats['VALIDQ'] = len([x for x in prediction if x is not None])
+ vstats['INVALIDQ'] = len([x for x in prediction if x is None])
+ return meta, vstats
+
+ # It returns a dictionary
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.moviechat1k import get_dimension_rating, prepare_score_prompt
+
+ assert eval_file.endswith('.xlsx'), 'data file should be an xlsx file'
+ judge = judge_kwargs.setdefault('model', 'chatgpt-0125')
+ assert judge in ['chatgpt-0125'], f'Invalid judge model for MovieChat1k: {judge}'
+ nproc = judge_kwargs.pop('nproc', 4)
+ _ = judge_kwargs.pop('verbose', None)
+ _ = judge_kwargs.pop('retry', None)
+
+ tmp_file = eval_file.replace('.xlsx', f'_{judge}_tmp.pkl')
+ tgt_file = eval_file.replace('.xlsx', f'_{judge}_rating.json')
+ score_file = eval_file.replace('.xlsx', f'_{judge}_score.xlsx')
+
+ model = build_judge(**judge_kwargs)
+
+ if not osp.exists(score_file):
+ res = {} if not osp.exists(tmp_file) else load(tmp_file)
+ res = {k: v for k, v in res.items() if model.fail_msg not in v}
+
+ data = load(eval_file)
+ data_un = data[~data['index'].isin(res)]
+ data_un = data_un[~pd.isna(data_un['prediction'])]
+ lt = len(data_un)
+ prompts = [prepare_score_prompt(data_un.iloc[i]) for i in range(lt)]
+ indices = [data_un.iloc[i]['index'] for i in range(lt)]
+ if len(prompts):
+ _ = track_progress_rich(
+ model.generate,
+ prompts,
+ keys=indices,
+ save=tmp_file,
+ nproc=nproc,
+ chunksize=nproc
+ )
+ score_map = load(tmp_file)
+ data['score'] = [score_map[idx] if idx in score_map else -1 for idx in data['index']]
+ rejected = [x for x in score_map.values() if FAIL_MSG in x]
+ print(
+ f'Among {len(data)} questions, failed to obtain prediction for {len(data) - len(score_map)} questions, '
+ f'failed to obtain the score for another {len(rejected)} questions. '
+ f'Those questions will be counted as 0 score in ALL rating, and will not be counted in VALID rating.'
+ )
+
+ dump(data, score_file)
+
+ rating = get_dimension_rating(score_file)
+ dump(rating, tgt_file)
+ return rating
diff --git a/vlmeval/dataset/mvbench.py b/vlmeval/dataset/mvbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..f10a709cf1b46a27861dea028f3921996f862e17
--- /dev/null
+++ b/vlmeval/dataset/mvbench.py
@@ -0,0 +1,666 @@
+import huggingface_hub
+from huggingface_hub import snapshot_download
+from ..smp import *
+from .video_base import VideoBaseDataset
+from .utils import build_judge, DEBUG_MESSAGE
+from ..utils import track_progress_rich
+import torchvision.transforms as T
+from torchvision import transforms
+from torchvision.transforms.functional import InterpolationMode
+from decord import VideoReader, cpu
+import imageio
+import cv2
+import zipfile
+import os
+import glob
+from .utils.mvbench import *
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+class MVBench(VideoBaseDataset):
+
+ MD5 = 'fd21d36522cdedd46d84dc46715ad832'
+ SYS = """Carefully watch the video and pay attention to the cause and sequence of events, \
+the detail and movement of objects, and the action and pose of persons. \
+Based on your observations, select the best option that accurately addresses the question.
+"""
+
+ TYPE = 'Video-MCQ'
+
+ def __init__(self, dataset='MVBench', nframe=0, fps=-1):
+ self.type_data_list = {
+ 'Action Sequence': ('action_sequence.json',
+ 'your_data_path/star/Charades_v1_480/', 'video', True), # has start & end
+ 'Action Prediction': ('action_prediction.json',
+ 'your_data_path/star/Charades_v1_480/', 'video', True), # has start & end
+ 'Action Antonym': ('action_antonym.json',
+ 'your_data_path/ssv2_video/', 'video', False),
+ 'Fine-grained Action': ('fine_grained_action.json',
+ 'your_data_path/Moments_in_Time_Raw/videos/', 'video', False),
+ 'Unexpected Action': ('unexpected_action.json',
+ 'your_data_path/FunQA_test/test/', 'video', False),
+ 'Object Existence': ('object_existence.json',
+ 'your_data_path/clevrer/video_validation/', 'video', False),
+ 'Object Interaction': ('object_interaction.json',
+ 'your_data_path/star/Charades_v1_480/', 'video', True), # has start & end
+ 'Object Shuffle': ('object_shuffle.json',
+ 'your_data_path/perception/videos/', 'video', False),
+ 'Moving Direction': ('moving_direction.json',
+ 'your_data_path/clevrer/video_validation/', 'video', False),
+ 'Action Localization': ('action_localization.json',
+ 'your_data_path/sta/sta_video/', 'video', True), # has start & end
+ 'Scene Transition': ('scene_transition.json',
+ 'your_data_path/scene_qa/video/', 'video', False),
+ 'Action Count': ('action_count.json',
+ 'your_data_path/perception/videos/', 'video', False),
+ 'Moving Count': ('moving_count.json',
+ 'your_data_path/clevrer/video_validation/', 'video', False),
+ 'Moving Attribute': ('moving_attribute.json',
+ 'your_data_path/clevrer/video_validation/', 'video', False),
+ 'State Change': ('state_change.json',
+ 'your_data_path/perception/videos/', 'video', False),
+ 'Fine-grained Pose': ('fine_grained_pose.json',
+ 'your_data_path/nturgbd/', 'video', False),
+ 'Character Order': ('character_order.json',
+ 'your_data_path/perception/videos/', 'video', False),
+ 'Egocentric Navigation': ('egocentric_navigation.json',
+ 'your_data_path/vlnqa/', 'video', False),
+ 'Episodic Reasoning': ('episodic_reasoning.json',
+ 'your_data_path/tvqa/frames_fps3_hq/', 'frame', True), # has start & end, read frame
+ 'Counterfactual Inference': ('counterfactual_inference.json',
+ 'your_data_path/clevrer/video_validation/', 'video', False),
+ }
+ super().__init__(dataset=dataset, nframe=nframe, fps=fps)
+
+ @classmethod
+ def supported_datasets(cls):
+ return ['MVBench']
+
+ def prepare_dataset(self, dataset_name='MVBench', repo_id='OpenGVLab/MVBench'):
+ def check_integrity(pth):
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+
+ if not os.path.exists(data_file):
+ return False
+
+ if md5(data_file) != self.MD5:
+ return False
+
+ data = load(data_file)
+ for idx, item in data.iterrows():
+ if not osp.exists(osp.join(pth, item['prefix'], item['video'])):
+ return False
+ return True
+
+ if modelscope_flag_set():
+ repo_id = 'modelscope/MVBench'
+
+ cache_path = get_cache_path(repo_id, branch='main')
+ if cache_path is not None and check_integrity(cache_path):
+ dataset_path = cache_path
+ else:
+ def unzip_hf_zip(pth):
+ pth = os.path.join(pth, 'video/')
+ for filename in os.listdir(pth):
+ if filename.endswith('.zip'):
+ # 构建完整的文件路径
+ zip_path = os.path.join(pth, filename)
+
+ # 解压 ZIP 文件
+ with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+ zip_ref.extractall(pth)
+
+ def generate_tsv(pth):
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+ if os.path.exists(data_file) and md5(data_file) == self.MD5:
+ return
+ json_data_dir = os.path.join(pth, 'json')
+ self.data_list = []
+ for k, v in self.type_data_list.items():
+ with open(os.path.join(json_data_dir, v[0]), 'r') as f:
+ json_data = json.load(f)
+ for data in json_data:
+ if os.path.exists(os.path.join(pth, v[1].replace('your_data_path', 'video'), data['video'])):
+ self.data_list.append({
+ 'task_type': k,
+ 'prefix': v[1].replace('your_data_path', 'video'),
+ 'data_type': v[2],
+ 'bound': v[3],
+ 'start': data['start'] if 'start' in data.keys() else None,
+ 'end': data['end'] if 'end' in data.keys() else None,
+ 'video': data['video'],
+ 'question': data['question'],
+ 'answer': data['answer'],
+ 'candidates': data['candidates']
+ })
+ else:
+ print(
+ 'NTURGB-D zip file is removed according to MVBench, you can view it at '
+ 'https://huggingface.co/datasets/OpenGVLab/MVBench for detailed reason.'
+ )
+ raise Exception(
+ f"{os.path.join(v[1].replace('your_data_path', 'video'), data['video'])} does not exist"
+ )
+
+ data_df = pd.DataFrame(self.data_list)
+ data_df = data_df.assign(index=range(len(data_df)))
+ data_df.to_csv(data_file, sep='\t', index=False)
+
+ def move_files(pth):
+ src_folder = os.path.join(pth, 'video/data0613')
+ if not os.path.exists(src_folder):
+ return
+ for subdir in os.listdir(src_folder):
+ subdir_path = os.path.join(src_folder, subdir)
+ if os.path.isdir(subdir_path):
+ for subsubdir in os.listdir(subdir_path):
+ subsubdir_path = os.path.join(subdir_path, subsubdir)
+ if os.path.isdir(subsubdir_path):
+ for item in os.listdir(subsubdir_path):
+ item_path = os.path.join(subsubdir_path, item)
+ target_folder = os.path.join(pth, 'video', subdir, subsubdir)
+ if not os.path.exists(target_folder):
+ os.makedirs(target_folder)
+ target_path = os.path.join(target_folder, item)
+ try:
+ shutil.move(item_path, target_path)
+ except Exception as e:
+ print(f"Error moving {item_path} to {target_path}: {e}")
+
+ if modelscope_flag_set():
+ from modelscope import dataset_snapshot_download
+ dataset_path = dataset_snapshot_download(dataset_id=repo_id, revision='master')
+ else:
+ hf_token = os.environ.get('HUGGINGFACE_TOKEN')
+ huggingface_hub.login(hf_token)
+ dataset_path = snapshot_download(repo_id=repo_id, repo_type='dataset')
+ unzip_hf_zip(dataset_path)
+ move_files(dataset_path)
+ generate_tsv(dataset_path)
+
+ data_file = osp.join(dataset_path, f'{dataset_name}.tsv')
+
+ self.decord_method = {
+ 'video': self.read_video,
+ 'gif': self.read_gif,
+ 'frame': self.read_frame,
+ }
+
+ self.nframe = 8
+ self.frame_fps = 3
+
+ # transform
+ self.transform = T.Compose([
+ Stack(),
+ ToTorchFormatTensor()
+ ])
+
+ return dict(root=dataset_path, data_file=data_file)
+
+ def get_index(self, bound, fps, max_frame, first_idx=0):
+ if bound:
+ start, end = bound[0], bound[1]
+ else:
+ start, end = -100000, 100000
+ start_idx = max(first_idx, round(start * fps))
+ end_idx = min(round(end * fps), max_frame)
+ seg_size = float(end_idx - start_idx) / self.num_segments
+ frame_indices = np.array([
+ int(start_idx + (seg_size / 2) + np.round(seg_size * idx))
+ for idx in range(self.num_segments)
+ ])
+ return frame_indices
+
+ def read_video(self, video_path, bound=None):
+ vr = VideoReader(video_path, ctx=cpu(0), num_threads=1)
+ max_frame = len(vr) - 1
+ fps = float(vr.get_avg_fps())
+
+ images_group = list()
+ frame_indices = self.get_index(bound, fps, max_frame, first_idx=0)
+ for frame_index in frame_indices:
+ img = Image.fromarray(vr[frame_index].asnumpy())
+ images_group.append(img)
+ torch_imgs = self.transform(images_group)
+ return torch_imgs
+
+ def read_gif(self, video_path, bound=None, fps=25):
+ gif = imageio.get_reader(video_path)
+ max_frame = len(gif) - 1
+
+ images_group = list()
+ frame_indices = self.get_index(bound, fps, max_frame, first_idx=0)
+ for index, frame in enumerate(gif):
+ if index in frame_indices:
+ img = cv2.cvtColor(frame, cv2.COLOR_RGBA2RGB)
+ img = Image.fromarray(img)
+ images_group.append(img)
+ torch_imgs = self.transform(images_group)
+ return torch_imgs
+
+ def read_frame(self, video_path, bound=None, fps=3):
+ max_frame = len(os.listdir(video_path))
+ images_group = list()
+ frame_indices = self.get_index(bound, fps, max_frame, first_idx=1) # frame_idx starts from 1
+ for frame_index in frame_indices:
+ img = Image.open(os.path.join(video_path, f'{frame_index:05d}.jpg'))
+ images_group.append(img)
+ torch_imgs = self.transform(images_group)
+ return torch_imgs
+
+ def save_video_frames(self, imgs, video_name, frames):
+
+ frame_paths = self.frame_paths(video_name)
+ flag = np.all([osp.exists(p) for p in frame_paths])
+
+ if not flag:
+ block_size = imgs.size(0) // frames
+ split_tensors = torch.split(imgs, block_size)
+ to_pil = transforms.ToPILImage()
+ images = [to_pil(arr) for arr in split_tensors]
+ for im, pth in zip(images, frame_paths):
+ if not osp.exists(pth):
+ im.save(pth)
+
+ return frame_paths
+
+ def qa_template(self, data):
+ question = f"Question: {data['question']}\n"
+ question += 'Options:\n'
+ answer = data['answer']
+ answer_idx = -1
+ for idx, c in enumerate(eval(data['candidates'])):
+ question += f"({chr(ord('A') + idx)}) {c}\n"
+ if c == answer:
+ answer_idx = idx
+ question = question.rstrip()
+ answer = f"({chr(ord('A') + answer_idx)}) {answer}"
+ return question, answer
+
+ def load_into_video_and_process(self, line):
+ try:
+ from moviepy.editor import VideoFileClip, ImageSequenceClip
+ except:
+ raise ImportError(
+ 'MoviePy is not installed, please install it by running "pip install moviepy==1.0.3"'
+ )
+ video_path = os.path.join(self.data_root, line['prefix'], line['video'])
+
+ if line['data_type'] in ['gif'] or os.path.splitext(video_path)[1] in ['.webm']:
+ processed_video_path = video_path.replace(os.path.splitext(video_path)[1], '.mp4')
+ if not os.path.exists(processed_video_path):
+ # using MoviePy to transform GIF, webm into mp4 format
+ gif_clip = VideoFileClip(video_path)
+ gif_clip.write_videofile(processed_video_path, codec='libx264')
+ gif_clip.close()
+ elif line['data_type'] in ['frame']:
+ input_images = os.path.join(video_path, '*.jpg')
+ processed_video_path = f'{video_path}.mp4'
+ if not os.path.exists(processed_video_path):
+ # using MoviePy to transform images into mp4
+ image_files = sorted(glob.glob(input_images))
+ image_clip = ImageSequenceClip(image_files, fps=self.frame_fps)
+ image_clip.write_videofile(processed_video_path, codec='libx264')
+ image_clip.close()
+ else:
+ processed_video_path = video_path
+
+ if line['bound']:
+ base_name, suffix = os.path.splitext(processed_video_path)
+ output_video_path = f'{base_name}_processed{suffix}'
+ if not os.path.exists(output_video_path):
+ video_clip = VideoFileClip(processed_video_path)
+ clip = video_clip.subclip(line['start'], min(line['end'], video_clip.duration))
+ clip.write_videofile(output_video_path)
+ clip.close()
+ else:
+ output_video_path = processed_video_path
+
+ return output_video_path
+
+ def save_video_into_images(self, line):
+ bound = None
+ if line['bound']:
+ bound = (
+ line['start'],
+ line['end'],
+ )
+ video_path = os.path.join(self.data_root, line['prefix'], line['video'])
+ decord_method = self.decord_method[line['data_type']]
+ self.num_segments = self.nframe
+ torch_imgs = decord_method(video_path, bound)
+ img_frame_paths = self.save_video_frames(torch_imgs, line['video'], self.num_segments)
+ return img_frame_paths
+
+ def build_prompt(self, line, video_llm):
+ if self.fps > 0:
+ raise ValueError('MVBench does not support fps setting, please transfer to MVBench_MP4!')
+ if isinstance(line, int):
+ assert line < len(self)
+ line = self.data.iloc[line]
+
+ question, answer = self.qa_template(line)
+ message = [dict(type='text', value=self.SYS, role='system')]
+ message.append(dict(type='text', value=question))
+ if video_llm:
+ new_video_path = self.load_into_video_and_process(line)
+ message.append(dict(type='video', value=new_video_path))
+ else:
+ img_frame_paths = self.save_video_into_images(line)
+ for im in img_frame_paths:
+ message.append(dict(type='image', value=im))
+ message.append(dict(type='text', value='\nOnly give the best option.'))
+ message.append(dict(type='text', value='Best option:(', role='assistant'))
+ return message
+
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+
+ assert eval_file.endswith('.xlsx'), 'data file should be an xlsx file'
+
+ tmp_file = eval_file.replace('.xlsx', '_tmp.pkl')
+ tgt_file = eval_file.replace('.xlsx', '_rating.json')
+ score_file = eval_file.replace('.xlsx', '_score.xlsx')
+
+ if not osp.exists(score_file):
+ model = judge_kwargs.setdefault('model', 'chatgpt-0125')
+ assert model in ['chatgpt-0125', 'exact_matching', 'gpt-4-0125']
+
+ if model == 'exact_matching':
+ model = None
+ elif gpt_key_set():
+ model = build_judge(**judge_kwargs)
+ if not model.working():
+ warnings.warn('OPENAI API is not working properly, will use exact matching for evaluation')
+ warnings.warn(DEBUG_MESSAGE)
+ model = None
+ else:
+ warnings.warn('OPENAI_API_KEY is not set properly, will use exact matching for evaluation')
+ model = None
+ res = {} if not osp.exists(tmp_file) else load(tmp_file)
+ res = {k: v for k, v in res.items() if FAIL_MSG not in v}
+
+ data = load(eval_file)
+ data_un = data[~pd.isna(data['prediction'])]
+
+ for idx in data_un['index']:
+ ans = data.loc[data['index'] == idx, 'answer'].values[0]
+ pred = data.loc[data['index'] == idx, 'prediction'].values[0]
+ options = eval(data.loc[data['index'] == idx, 'candidates'].values[0])
+ answer_idx = -1
+ for id, c in enumerate(options):
+ if c == ans:
+ answer_idx = id
+ ans = f"({chr(ord('A') + answer_idx)}) {ans}"
+ input_item = data.loc[data['index'] == idx].to_dict(orient='records')[0]
+ for id, option_content in enumerate(eval(input_item['candidates'])):
+ input_item[chr(ord('A') + id)] = option_content
+ if option_content == input_item['answer']:
+ input_item['answer'] = chr(ord('A') + id)
+
+ if FAIL_MSG in pred:
+ data.loc[idx, 'score'] = -1
+ else:
+ data.loc[idx, 'score'] = int(check_ans_with_model(
+ pred, ans, model,
+ input_item,
+ 'MVBench'
+ ))
+
+ rejected = [x for x in data['score'] if x == -1]
+
+ print(
+ f'Among {len(data)} questions, failed to obtain prediction for {len(data) - len(data_un)} questions, '
+ f'failed to obtain the score for another {len(rejected)} questions. '
+ f'Those questions will be counted as -1 score in ALL rating, and will not be counted in VALID rating.'
+ )
+
+ dump(data, score_file)
+
+ rating = get_dimension_rating(score_file)
+ dump(rating, tgt_file)
+ return rating
+
+
+class MVBench_MP4(VideoBaseDataset):
+
+ MP4_MD5 = '5c8c6f8b7972c2de65a629590f7c42f5'
+ SYS = """Carefully watch the video and pay attention to the cause and sequence of events, \
+the detail and movement of objects, and the action and pose of persons. \
+Based on your observations, select the best option that accurately addresses the question.
+"""
+ TYPE = 'Video-MCQ'
+
+ def __init__(self, dataset='MVBench_MP4', nframe=0, fps=-1):
+ super().__init__(dataset=dataset, nframe=nframe, fps=fps)
+
+ @classmethod
+ def supported_datasets(cls):
+ return ['MVBench_MP4']
+
+ def prepare_dataset(self, dataset_name='MVBench_MP4', repo_id='OpenGVLab/MVBench'):
+ def check_integrity(pth):
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+
+ if not os.path.exists(data_file):
+ return False
+
+ if md5(data_file) != self.MP4_MD5:
+ return False
+
+ data = load(data_file)
+ for idx, item in data.iterrows():
+ if not osp.exists(osp.join(pth, item['prefix'], item['video'])):
+ return False
+ return True
+
+ if modelscope_flag_set():
+ repo_id = 'modelscope/MVBench'
+
+ cache_path = get_cache_path(repo_id, branch='video')
+ if cache_path is not None and check_integrity(cache_path):
+ dataset_path = cache_path
+ else:
+ def generate_tsv(pth):
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+ if os.path.exists(data_file) and md5(data_file) == self.MP4_MD5:
+ return
+ json_data_path = os.path.join(dataset_path, 'test.json')
+ json_data = load(json_data_path)
+ root_data_dict = json_data['root']
+ self.data_list = []
+ for k, v in json_data['meta'].items():
+ for item in v:
+ self.data_list.append({
+ 'task_type': k,
+ 'prefix': root_data_dict[k],
+ 'video': item['video'],
+ 'question': item['question'],
+ 'answer': item['answer'],
+ 'candidates': item['candidates']
+ })
+ data_df = pd.DataFrame(self.data_list)
+ data_df = data_df.assign(index=range(len(data_df)))
+ data_df.to_csv(data_file, sep='\t', index=False)
+
+ if modelscope_flag_set():
+ from modelscope import dataset_snapshot_download
+ dataset_path = dataset_snapshot_download(dataset_id=repo_id, revision='video')
+ else:
+ hf_token = os.environ.get('HUGGINGFACE_TOKEN')
+ huggingface_hub.login(hf_token)
+ dataset_path = snapshot_download(repo_id=repo_id, repo_type='dataset', revision='video')
+ generate_tsv(dataset_path)
+
+ data_file = osp.join(dataset_path, f'{dataset_name}.tsv')
+
+ # transform
+ self.transform = T.Compose([
+ Stack(),
+ ToTorchFormatTensor()
+ ])
+
+ return dict(root=dataset_path, data_file=data_file)
+
+ def qa_template(self, data):
+ question = f"Question: {data['question']}\n"
+ question += 'Options:\n'
+ answer = data['answer']
+ answer_idx = -1
+ for idx, c in enumerate(eval(data['candidates'])):
+ question += f"({chr(ord('A') + idx)}) {c}\n"
+ if c == answer:
+ answer_idx = idx
+ question = question.rstrip()
+ answer = f"({chr(ord('A') + answer_idx)}) {answer}"
+ return question, answer
+
+ def get_index_by_frame(self, max_frame):
+ seg_size = float(max_frame) / self.num_segments
+ frame_indices = np.array([
+ int((seg_size / 2) + np.round(seg_size * idx))
+ for idx in range(self.num_segments)
+ ])
+ return frame_indices
+
+ def get_index_by_fps(self, vid, fps):
+ total_frames = len(vid)
+ video_fps = vid.get_avg_fps()
+ total_duration = total_frames / video_fps
+ required_frames = int(total_duration * fps)
+ step_size = video_fps / fps
+ frame_indices = np.array([int(i * step_size) for i in range(required_frames)])
+ self.num_segments = len(frame_indices)
+ return frame_indices
+
+ def read_video(self, video_path):
+ vr = VideoReader(video_path, ctx=cpu(0), num_threads=1)
+ max_frame = len(vr) - 1
+
+ images_group = list()
+ if self.fps < 0:
+ frame_indices = self.get_index_by_frame(max_frame)
+ else:
+ frame_indices = self.get_index_by_fps(vr, self.fps)
+
+ for frame_index in frame_indices:
+ img = Image.fromarray(vr[frame_index].asnumpy())
+ images_group.append(img)
+ torch_imgs = self.transform(images_group)
+ return torch_imgs
+
+ def save_video_frames(self, imgs, video_name, frames):
+ if self.fps > 0:
+ frame_paths = self.frame_paths_fps(video_name, frames)
+ else:
+ frame_paths = self.frame_paths(video_name)
+ flag = np.all([osp.exists(p) for p in frame_paths])
+
+ if not flag:
+ block_size = imgs.size(0) // frames
+ split_tensors = torch.split(imgs, block_size)
+ to_pil = transforms.ToPILImage()
+ images = [to_pil(arr) for arr in split_tensors]
+ for im, pth in zip(images, frame_paths):
+ if not osp.exists(pth):
+ im.save(pth)
+
+ return frame_paths
+
+ def save_video_into_images(self, line):
+ video_path = os.path.join(self.data_root, line['prefix'], line['video'])
+ if self.fps <= 0:
+ self.num_segments = self.nframe
+ else:
+ self.num_segments = 0
+ torch_imgs = self.read_video(video_path)
+ img_frame_paths = self.save_video_frames(torch_imgs, line['video'], self.num_segments)
+ return img_frame_paths
+
+ def build_prompt(self, line, video_llm):
+ if isinstance(line, int):
+ assert line < len(self)
+ line = self.data.iloc[line]
+
+ question, answer = self.qa_template(line)
+ message = [dict(type='text', value=self.SYS, role='system')]
+ message.append(dict(type='text', value=question))
+ video_path = os.path.join(self.data_root, line['prefix'], line['video'])
+ if video_llm:
+ message.append(dict(type='video', value=video_path))
+ else:
+ img_frame_paths = self.save_video_into_images(line)
+ for im in img_frame_paths:
+ message.append(dict(type='image', value=im))
+ message.append(dict(type='text', value='\nOnly give the best option.'))
+ message.append(dict(type='text', value='Best option:(', role='assistant'))
+ return message
+
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+
+ assert eval_file.endswith('.xlsx'), 'data file should be an xlsx file'
+
+ tmp_file = eval_file.replace('.xlsx', '_tmp.pkl')
+ tgt_file = eval_file.replace('.xlsx', '_rating.json')
+ score_file = eval_file.replace('.xlsx', '_score.xlsx')
+
+ if not osp.exists(score_file):
+ model = judge_kwargs.setdefault('model', 'chatgpt-0125')
+ assert model in ['chatgpt-0125', 'exact_matching', 'gpt-4-0125']
+
+ if model == 'exact_matching':
+ model = None
+ elif gpt_key_set():
+ model = build_judge(**judge_kwargs)
+ if not model.working():
+ warnings.warn('OPENAI API is not working properly, will use exact matching for evaluation')
+ warnings.warn(DEBUG_MESSAGE)
+ model = None
+ else:
+ warnings.warn('OPENAI_API_KEY is not set properly, will use exact matching for evaluation')
+ model = None
+ res = {} if not osp.exists(tmp_file) else load(tmp_file)
+ res = {k: v for k, v in res.items() if FAIL_MSG not in v}
+
+ data = load(eval_file)
+ data_un = data[~pd.isna(data['prediction'])]
+
+ for idx in data_un['index']:
+ ans = data.loc[data['index'] == idx, 'answer'].values[0]
+ pred = data.loc[data['index'] == idx, 'prediction'].values[0]
+ options = eval(data.loc[data['index'] == idx, 'candidates'].values[0])
+ answer_idx = -1
+ for id, c in enumerate(options):
+ if c == ans:
+ answer_idx = id
+ ans = f"({chr(ord('A') + answer_idx)}) {ans}"
+ input_item = data.loc[data['index'] == idx].to_dict(orient='records')[0]
+ for id, option_content in enumerate(eval(input_item['candidates'])):
+ input_item[chr(ord('A') + id)] = option_content
+ if option_content == input_item['answer']:
+ input_item['answer'] = chr(ord('A') + id)
+
+ if FAIL_MSG in pred:
+ data.loc[idx, 'score'] = -1
+ else:
+ data.loc[idx, 'score'] = int(check_ans_with_model(
+ pred, ans, model,
+ input_item,
+ 'MVBench_MP4'
+ ))
+
+ rejected = [x for x in data['score'] if x == -1]
+
+ print(
+ f'Among {len(data)} questions, failed to obtain prediction for {len(data) - len(data_un)} questions, '
+ f'failed to obtain the score for another {len(rejected)} questions. '
+ f'Those questions will be counted as -1 score in ALL rating, and will not be counted in VALID rating.'
+ )
+
+ dump(data, score_file)
+
+ rating = get_dimension_rating(score_file)
+ dump(rating, tgt_file)
+ return rating
diff --git a/vlmeval/dataset/qbench_video.py b/vlmeval/dataset/qbench_video.py
new file mode 100644
index 0000000000000000000000000000000000000000..db7eb9340b1bf51133a996909a7688488b3f1f30
--- /dev/null
+++ b/vlmeval/dataset/qbench_video.py
@@ -0,0 +1,352 @@
+import huggingface_hub
+from huggingface_hub import snapshot_download
+from ..smp import *
+from .video_concat_dataset import ConcatVideoDataset
+from .video_base import VideoBaseDataset
+from .utils import build_judge, DEBUG_MESSAGE
+from ..utils import track_progress_rich
+import torchvision.transforms as T
+from torchvision import transforms
+from torchvision.transforms.functional import InterpolationMode
+from decord import VideoReader, cpu
+import pandas as pd
+import imageio
+import cv2
+import zipfile
+import os
+import glob
+from .utils.qbench_video import *
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+class QBench_Video(ConcatVideoDataset):
+ def __init__(self, dataset='QBench_Video', nframe=0, fps=-1):
+ self.DATASET_SETS[dataset] = ['QBench_Video_MCQ','QBench_Video_VQA']
+ super().__init__(dataset=dataset, nframe=nframe, fps=fps)
+
+ @classmethod
+ def supported_datasets(cls):
+ return ['QBench_Video']
+
+ def evaluate(self, eval_file, **judge_kwargs):
+ result = super().evaluate(eval_file=eval_file, **judge_kwargs)
+ suffix = eval_file.split('.')[-1]
+ score_file = eval_file.replace(f'.{suffix}', '_acc.csv')
+ result.at['open_ended', 'acc'] /= 2
+ dump(result, score_file)
+ return result
+
+
+class QBench_Video_MCQ(VideoBaseDataset):
+
+ MD5 = '9d6760d75fa80aa9fd5e5cf1ea274ace'
+
+ FRAMES_TMPL_SYS = """
+You will receive {} distinct frames that have been uniformly sampled from a video sequence, arranged in the same temporal order as they appear in the video.
+Please analyze these frames and answer the question based on your observations.
+"""
+
+ FRAMES_TMPL_SYS_4VIDEO_LLM = """
+You will receive several distinct frames that have been uniformly sampled from a video sequence, arranged in the same temporal order as they appear in the video.
+Please analyze these frames and answer the question based on your observations.
+"""
+
+ POST_PROMPT = """
+Please answer the question in the following format: the uppercase letter of the correct answer option itself.
+Please do not add any other answers beyond this.
+"""
+
+ TYPE = 'Video-MCQ'
+
+ def __init__(self, dataset='qbenchvideo_single_MCQ', nframe=0, fps=-1):
+ dataset_tsv_name = 'qbenchvideo_single_MCQ'
+ super().__init__(dataset=dataset_tsv_name, nframe=nframe, fps=fps)
+
+ @classmethod
+ def supported_datasets(cls):
+ return ['QBench_Video_MCQ']
+
+ def prepare_dataset(self, dataset_name='qbenchvideo_single_MCQ', repo_id='zhangzicheng/Q-Bench-Video'):
+ def check_integrity(pth):
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+
+ if not os.path.exists(data_file):
+ return False
+
+ if md5(data_file) != self.MD5:
+ return False
+
+ data = load(data_file)
+ for idx, item in data.iterrows():
+ if not osp.exists(os.path.normpath(osp.join(pth, item['video_path']))):
+ return False
+ return True
+
+
+ cache_path = get_cache_path(repo_id)
+ if cache_path is not None and check_integrity(cache_path):
+ dataset_path = cache_path
+ else:
+ def unzip_videos(pth):
+ import zipfile
+ if not osp.exists(osp.join(pth, 'video')):
+ zip_file = osp.join(pth, 'video.zip')
+ with zipfile.ZipFile(zip_file, 'r') as zip_ref:
+ zip_ref.extractall(pth)
+ dataset_path = snapshot_download(repo_id=repo_id, repo_type='dataset')
+ unzip_videos(dataset_path)
+
+ data_file = osp.join(dataset_path, f'{dataset_name}.tsv')
+ return dict(root=dataset_path, data_file=data_file)
+
+ def save_video_frames(self, line):
+ video = line['video']
+ vid_path = os.path.normpath(os.path.join(self.data_root, line['video_path']))
+ vid = decord.VideoReader(vid_path)
+ video_info = {
+ 'fps': vid.get_avg_fps(),
+ 'n_frames': len(vid),
+ }
+ if self.nframe > 0 and self.fps < 0:
+ step_size = len(vid) / (self.nframe + 1)
+ indices = [int(i * step_size) for i in range(1, self.nframe + 1)]
+ frame_paths = self.frame_paths(video)
+ elif self.fps > 0:
+ # not constrained by num_frames, get frames by fps
+ total_duration = video_info['n_frames'] / video_info['fps']
+ required_frames = int(total_duration * self.fps)
+ step_size = video_info['fps'] / self.fps
+ indices = [int(i * step_size) for i in range(required_frames)]
+ frame_paths = self.frame_paths_fps(video, len(indices))
+
+ flag = np.all([osp.exists(p) for p in frame_paths])
+
+ if not flag:
+ images = [vid[i].asnumpy() for i in indices]
+ images = [Image.fromarray(arr) for arr in images]
+ for im, pth in zip(images, frame_paths):
+ if not osp.exists(pth):
+ im.save(pth)
+
+ return frame_paths
+
+ def save_video_into_images(self, line):
+ frame_paths = self.save_video_frames(line)
+ return frame_paths
+
+ def build_prompt(self, line, video_llm):
+ if isinstance(line, int):
+ assert line < len(self)
+ line = self.data.iloc[line]
+
+ # message = [dict(type='text', value=line['question'])]
+ video_path = os.path.normpath(os.path.join(self.data_root, line['video_path']))
+ if video_llm:
+ message = [dict(type='text', value=self.FRAMES_TMPL_SYS_4VIDEO_LLM)]
+ message.append(dict(type='text', value=line['question']))
+ message.append(dict(type='video', value=video_path))
+ else:
+ img_frame_paths = self.save_video_into_images(line)
+ message = [dict(type='text', value=self.FRAMES_TMPL_SYS.format(len(img_frame_paths)))]
+ message.append(dict(type='text', value=line['question']))
+ for im in img_frame_paths:
+ message.append(dict(type='image', value=im))
+ message.append(dict(type='text', value=self.POST_PROMPT))
+ return message
+
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ assert eval_file.endswith('.xlsx'), 'data file should be an xlsx file'
+
+ tmp_file = eval_file.replace('.xlsx', '_tmp.pkl')
+ score_file = eval_file.replace('.xlsx', '_score.xlsx')
+
+ if not osp.exists(score_file):
+ model = judge_kwargs.setdefault('model', 'exact_matching')
+ assert model in ['exact_matching']
+
+ res = {} if not osp.exists(tmp_file) else load(tmp_file)
+ res = {k: v for k, v in res.items() if FAIL_MSG not in v}
+
+ data = load(eval_file)
+ data_un = data[~pd.isna(data['prediction'])]
+
+ for idx in data['index']:
+ ans = data.loc[data['index'] == idx, 'answer'].values[0]
+ pred = data.loc[data['index'] == idx, 'prediction'].values[0]
+ correct_choice = ans.split('.')[0].strip()
+ correct_answer = ans.split('.')[1].strip()
+
+ if FAIL_MSG in pred:
+ data.loc[idx, 'score'] = -1
+ else:
+ data.loc[idx, 'score'] = int(check_ans_mcq(
+ pred, ans, correct_choice, correct_answer
+ ))
+
+ rejected = [x for x in data['score'] if x == -1]
+
+ print(
+ f'Among {len(data)} questions, failed to obtain prediction for {len(data) - len(data_un)} questions, '
+ f'failed to obtain the score for another {len(rejected)} questions. '
+ f'Those questions will be counted as -1 score in ALL rating, and will not be counted in VALID rating.'
+ )
+
+ dump(data, score_file)
+
+ rating = get_dimension_rating(score_file)
+ return rating
+
+
+class QBench_Video_VQA(VideoBaseDataset):
+
+ MD5 = '49e6181b341c934d0b33ec78bdcc0a3d'
+
+ FRAMES_TMPL_SYS = """
+You will receive {} distinct frames that have been uniformly sampled from a video sequence, arranged in the same temporal order as they appear in the video.
+Please analyze these frames and provide a detailed and accurate answer from the perspective of visual quality based on your observations.
+"""
+
+ FRAMES_TMPL_SYS_4VIDEO_LLM = """
+You will receive several distinct frames that have been uniformly sampled from a video sequence, arranged in the same temporal order as they appear in the video.
+Please analyze these frames and provide a detailed and accurate answer from the perspective of visual quality based on your observations.
+"""
+
+
+ TYPE = 'Video-VQA'
+
+ def __init__(self, dataset='qbenchvideo_single_VQA', nframe=0, fps=-1):
+ dataset_tsv_name = 'qbenchvideo_single_VQA'
+ super().__init__(dataset=dataset_tsv_name, nframe=nframe, fps=fps)
+
+ @classmethod
+ def supported_datasets(cls):
+ return ['QBench_Video_VQA']
+
+ def prepare_dataset(self, dataset_name='qbenchvideo_single_VQA', repo_id='zhangzicheng/Q-Bench-Video'):
+ def check_integrity(pth):
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+
+ if not os.path.exists(data_file):
+ return False
+
+ if md5(data_file) != self.MD5:
+ return False
+
+ data = load(data_file)
+ for idx, item in data.iterrows():
+ if not osp.exists(os.path.normpath(osp.join(pth, item['video_path']))):
+ return False
+ return True
+
+
+ cache_path = get_cache_path(repo_id)
+ if cache_path is not None and check_integrity(cache_path):
+ dataset_path = cache_path
+ else:
+ def unzip_videos(pth):
+ import zipfile
+ if not osp.exists(osp.join(pth, 'video')):
+ zip_file = osp.join(pth, 'video.zip')
+ with zipfile.ZipFile(zip_file, 'r') as zip_ref:
+ zip_ref.extractall(pth)
+ dataset_path = snapshot_download(repo_id=repo_id, repo_type='dataset')
+ unzip_videos(dataset_path)
+
+ data_file = osp.join(dataset_path, f'{dataset_name}.tsv')
+ return dict(root=dataset_path, data_file=data_file)
+
+ def save_video_frames(self, line):
+ video = line['video']
+ vid_path = os.path.normpath(os.path.join(self.data_root, line['video_path']))
+ vid = decord.VideoReader(vid_path)
+ video_info = {
+ 'fps': vid.get_avg_fps(),
+ 'n_frames': len(vid),
+ }
+ if self.nframe > 0 and self.fps < 0:
+ step_size = len(vid) / (self.nframe + 1)
+ indices = [int(i * step_size) for i in range(1, self.nframe + 1)]
+ frame_paths = self.frame_paths(video)
+ elif self.fps > 0:
+ # not constrained by num_frames, get frames by fps
+ total_duration = video_info['n_frames'] / video_info['fps']
+ required_frames = int(total_duration * self.fps)
+ step_size = video_info['fps'] / self.fps
+ indices = [int(i * step_size) for i in range(required_frames)]
+ frame_paths = self.frame_paths_fps(video, len(indices))
+
+ flag = np.all([osp.exists(p) for p in frame_paths])
+
+ if not flag:
+ images = [vid[i].asnumpy() for i in indices]
+ images = [Image.fromarray(arr) for arr in images]
+ for im, pth in zip(images, frame_paths):
+ if not osp.exists(pth):
+ im.save(pth)
+
+ return frame_paths
+
+ def save_video_into_images(self, line):
+ frame_paths = self.save_video_frames(line)
+ return frame_paths
+
+ def build_prompt(self, line, video_llm):
+ if isinstance(line, int):
+ assert line < len(self)
+ line = self.data.iloc[line]
+
+ video_path = os.path.normpath(os.path.join(self.data_root, line['video_path']))
+ if video_llm:
+ message = [dict(type='text', value=self.FRAMES_TMPL_SYS_4VIDEO_LLM)]
+ message.append(dict(type='text', value=line['question']))
+ message.append(dict(type='video', value=video_path))
+ else:
+ img_frame_paths = self.save_video_into_images(line)
+ message = [dict(type='text', value=self.FRAMES_TMPL_SYS.format(len(img_frame_paths)))]
+ message.append(dict(type='text', value=line['question']))
+ for im in img_frame_paths:
+ message.append(dict(type='image', value=im))
+ return message
+
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ model = judge_kwargs.setdefault('model', 'gpt-4o-0806')
+ assert model in ['gpt-4o-0806', 'gpt-4o']
+
+ suffix = eval_file.split('.')[-1]
+ score_file = eval_file.replace(f'.{suffix}', f'_{model}_score.xlsx')
+ tmp_file = eval_file.replace(f'.{suffix}', f'_{model}.pkl')
+ nproc = judge_kwargs.pop('nproc', 4)
+
+ if not osp.exists(score_file):
+ data = load(eval_file)
+ model = build_judge(system_prompt=VQA_JUDGE_SYS_PROMPT, **judge_kwargs)
+ lt = len(data)
+ lines = [data.iloc[i] for i in range(lt)]
+ tups = [(model, line) for line in lines]
+ indices = [line['index'] for line in lines]
+
+ ans = {}
+ if osp.exists(tmp_file):
+ ans = load(tmp_file)
+ tups = [x for x, i in zip(tups, indices) if i not in ans]
+ indices = [i for i in indices if i not in ans]
+
+ if len(indices):
+ _ = track_progress_rich(
+ check_ans_vqa,
+ tups,
+ nproc=nproc,
+ chunksize=nproc,
+ keys=indices,
+ save=tmp_file,
+ )
+ ans = load(tmp_file)
+ for idx in ans:
+ data.loc[data['index'] == idx, 'score'] = int(ans[idx].replace('Score:', '').strip())
+ dump(data, score_file)
+
+ rating = get_dimension_rating(score_file)
+ return rating
diff --git a/vlmeval/dataset/slidevqa.py b/vlmeval/dataset/slidevqa.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae7104d43f803a58eb6d6576cb50a0094949c117
--- /dev/null
+++ b/vlmeval/dataset/slidevqa.py
@@ -0,0 +1,189 @@
+import re
+import math
+from typing import List
+
+from vlmeval.dataset.utils.judge_util import build_judge
+from vlmeval.smp import *
+from .image_base import ImageBaseDataset
+from .mmlongbench import concat_images, MMLongBench_auxeval, anls_compute
+
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+def get_f1(gt, pred):
+ gt_bow, pred_bow = gt.strip().split(), pred.strip().split()
+ if not gt_bow or not pred_bow:
+ return 0.0
+
+ recall = len([pred_e for pred_e in pred_bow if pred_e in gt_bow]) / len(gt_bow)
+ precision = len([pred_e for pred_e in pred_bow if pred_e in gt_bow]) / len(pred_bow)
+ f1 = 2 * recall * precision / (recall + precision) if (recall + precision) > 1e-4 else 0.0
+ return f1
+
+
+def SlideVQA_acc(result_file):
+ data = load(result_file)
+ anls_list, em_list, f1_list = list(), list(), list()
+ for i in range(len(data)):
+ item = data.iloc[i]
+ if isinstance(item['answer'], float) and math.isnan(item['answer']):
+ item['answer'] = 'Not answerable'
+
+ item['answer'] = re.sub('\n', '', item['answer']).lower()
+ item['pred'] = str(item['pred']).lower()
+ anls_score = anls_compute(item['answer'], item['pred'])
+ em_score = (item['answer'].strip() == item['pred'].strip())
+ f1_score = get_f1(item['answer'], item['pred'])
+ anls_list.append(anls_score)
+ em_list.append(em_score)
+ f1_list.append(f1_score)
+ print('---------------------')
+ print(item['answer'], item['pred'], anls_score, em_score, f1_score)
+
+ data['anls'] = anls_list
+ data['em'] = em_list
+ data['f1'] = f1_list
+ dump(data, result_file)
+
+ res = dict()
+ res['category'], res['num'] = ['anls', 'EM', 'F1'], [len(data), len(data), len(data)]
+ res['avg'] = [sum(anls_list) / len(data), sum(em_list) / len(data), sum(f1_list) / len(data)]
+ res = pd.DataFrame(res)
+ return res
+
+
+class SlideVQA(ImageBaseDataset):
+
+ TYPE = 'VQA'
+
+ DATASET_URL = {
+ 'SLIDEVQA_MINI': 'https://opencompass.openxlab.space/utils/VLMEval/SLIDEVQA_MINI.tsv',
+ 'SLIDEVQA': 'https://opencompass.openxlab.space/utils/VLMEval/SLIDEVQA.tsv',
+ }
+ DATASET_MD5 = {
+ 'SLIDEVQA_MINI': '6d9a8d8814fa5b7669deb2af3a3208eb',
+ 'SLIDEVQA': '5e822c2f800e94c1e23badfd478326b6',
+ }
+
+ SUPPORTED_MODELS = {
+ 'GPT4': (1, 1),
+ 'GPT4V': (1, 1),
+ 'GPT4V_HIGH': (1, 1),
+ 'GPT4o': (1, 1),
+ 'GPT4o_HIGH': (1, 1),
+ 'GPT4o_MINI': (1, 1),
+ 'XComposer2d5': (1, -1),
+ 'XComposer2_4KHD': (1, -1),
+ 'MiniCPM-Llama3-V-2_5': (1, 5),
+ 'InternVL-Chat-V1-5': (5, 2),
+ }
+
+ def __init__(self, dataset, **kwargs):
+ self.model_list = list(self.SUPPORTED_MODELS.keys())
+ model_name = kwargs['model']
+ if not listinstr(self.model_list, model_name):
+ raise AssertionError("{} doesn't support the evaluation on SlideVQA.".format(model_name))
+ super(SlideVQA, self).__init__(dataset)
+
+ self.is_api = True if listinstr(['GPT4'], model_name) else False
+ self.max_pages = 120
+ concat_num, column_num = self.SUPPORTED_MODELS.get(model_name)
+ self.concat_num = concat_num
+ self.column_num = column_num
+
+ def dump_image(self, origin_line):
+ os.makedirs(self.img_root, exist_ok=True)
+
+ line = origin_line.copy()
+ if not isinstance(line['image_path'], List):
+ line['image_path'] = [line['image_path']]
+ line['image_path'] = line['image_path'][:self.max_pages]
+
+ if 'image' in line:
+ if isinstance(line['image'], list):
+ tgt_path = []
+ assert 'image_path' in line
+ for img, im_name in zip(line['image'], line['image_path']):
+ path = osp.join(self.img_root, im_name)
+ if not read_ok(path):
+ decode_base64_to_image_file(img, path)
+ tgt_path.append(path)
+ else:
+ tgt_path = osp.join(self.img_root, f"{line['index']}.jpg")
+ if not read_ok(tgt_path):
+ decode_base64_to_image_file(line['image'], tgt_path)
+ tgt_path = [tgt_path]
+ else:
+ assert 'image_path' in line
+ tgt_path = toliststr(line['image_path'])
+
+ if self.concat_num > 0 and not self.is_api:
+ concatenated_images = concat_images(tgt_path, max_concat=self.concat_num, column_num=self.column_num)
+
+ old_tgt_path = tgt_path
+ assert isinstance(old_tgt_path, list)
+ if self.column_num != -1:
+ tgt_path = [
+ '_'.join(old_tgt_path[0].split('_')[:-1]) + '_concat{}_{}.jpg'.format(self.concat_num, i)
+ for i in range(len(concatenated_images))
+ ]
+ else:
+ tgt_path = ['_'.join(old_tgt_path[0].split('_')[:-1]) + '_concat_all.jpg']
+
+ for path, concatenated_image in zip(tgt_path, concatenated_images):
+ if not read_ok(path):
+ decode_base64_to_image_file(encode_image_to_base64(concatenated_image), path)
+ num_images, image_size = len(old_tgt_path), concatenated_image.size
+ print('concat {} images to a new one with size {}. save at {}'.format(num_images, image_size, path))
+ return tgt_path
+
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ logger = get_logger('Evaluation')
+ model = judge_kwargs['model']
+
+ suffix = eval_file.split('.')[-1]
+ storage = eval_file.replace(f'.{suffix}', f'_{model}.xlsx')
+ tmp_file = eval_file.replace(f'.{suffix}', f'_{model}.pkl')
+
+ if osp.exists(storage):
+ logger.warning(f'GPT scoring file {storage} already exists, will reuse it in SlideVQA_eval. ')
+ else:
+ data = load(eval_file)
+ model = build_judge(max_tokens=128, **judge_kwargs)
+ lt = len(data)
+ lines = [data.iloc[i] for i in range(lt)]
+ tups = [(model, line) for line in lines]
+ indices = [line['index'] for line in lines]
+
+ ans = {}
+ if osp.exists(tmp_file):
+ ans = load(tmp_file)
+ tups = [x for x, i in zip(tups, indices) if i not in ans]
+ indices = [i for i in indices if i not in ans]
+
+ if len(indices):
+ new_results = list()
+ for model, line in tqdm(tups):
+ res = MMLongBench_auxeval(model, line)
+ new_results.append(res)
+
+ log_map, res_map, pred_map = {}, {}, {}
+ all_inds = [line['index'] for line in lines]
+ for k, v in zip(all_inds, new_results):
+ log_map[k] = v['log']
+ res_map[k] = v['res']
+ pred_map[k] = v['pred']
+ data['res'] = [res_map[idx] for idx in data['index']]
+ data['log'] = [log_map[idx] for idx in data['index']]
+ data['pred'] = [pred_map[idx] for idx in data['index']]
+ dump(data, storage)
+
+ score = SlideVQA_acc(storage)
+ score_pth = storage.replace('.xlsx', '_score.csv')
+
+ dump(score, score_pth)
+ logger.info(f'SlideVQA successfully finished evaluating {eval_file}, results saved in {score_pth}')
+ logger.info('Score: ')
+ logger.info(score)
diff --git a/vlmeval/dataset/tamperbench.py b/vlmeval/dataset/tamperbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..d226ba156a6ff10b35d5b081018a9042547c6243
--- /dev/null
+++ b/vlmeval/dataset/tamperbench.py
@@ -0,0 +1,534 @@
+import huggingface_hub
+from huggingface_hub import snapshot_download
+from ..smp import *
+from .video_base import VideoBaseDataset
+from .utils import build_judge, DEBUG_MESSAGE
+import torchvision.transforms as T
+from torchvision import transforms
+from decord import VideoReader, cpu
+import imageio
+import cv2
+import zipfile
+import os
+import glob
+from .utils.tamperbench import *
+
+# constants
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+class MVTamperBench(VideoBaseDataset):
+
+ BASENAME = "MVTamperBench"
+ MD5 = {
+ 'MVTamperBench': '3557260881ba47db8add440c5edb742a',
+ 'MVTamperBenchStart': 'c1d3c299ddbff6000f0d9cad820187b8',
+ 'MVTamperBenchEnd': 'aa2c19dd02e1b006ee2d4be9f6f2b62b',
+ }
+ SYS = """Carefully watch the video and pay attention to the cause and sequence of events, \
+the detail and movement of objects, and the action and pose of persons. \
+Based on your observations, select the best option that accurately addresses the question.
+"""
+
+ TYPE = 'Video-MCQ'
+
+ def __init__(self, dataset='MVTamperBench', nframe=0, fps=-1):
+ self.dataset_name = dataset
+ self.type_data_list = {
+ 'Action Sequence': ('action_sequence.json',
+ 'your_data_path/star/Charades_v1_480/', 'video', False), # has start & end
+ 'Action Prediction': ('action_prediction.json',
+ 'your_data_path/star/Charades_v1_480/', 'video', False), # has start & end
+ 'Action Antonym': ('action_antonym.json',
+ 'your_data_path/ssv2_video/', 'video', False),
+ 'Fine-grained Action': ('fine_grained_action.json',
+ 'your_data_path/Moments_in_Time_Raw/videos/', 'video', False),
+ 'Unexpected Action': ('unexpected_action.json',
+ 'your_data_path/FunQA_test/test/', 'video', False),
+ 'Object Existence': ('object_existence.json',
+ 'your_data_path/clevrer/video_validation/', 'video', False),
+ 'Object Interaction': ('object_interaction.json',
+ 'your_data_path/star/Charades_v1_480/', 'video', False), # has start & end
+ 'Object Shuffle': ('object_shuffle.json',
+ 'your_data_path/perception/videos/', 'video', False),
+ 'Moving Direction': ('moving_direction.json',
+ 'your_data_path/clevrer/video_validation/', 'video', False),
+ 'Action Localization': ('action_localization.json',
+ 'your_data_path/sta/sta_video/', 'video', False), # has start & end
+ 'Scene Transition': ('scene_transition.json',
+ 'your_data_path/scene_qa/video/', 'video', False),
+ 'Action Count': ('action_count.json',
+ 'your_data_path/perception/videos/', 'video', False),
+ 'Moving Count': ('moving_count.json',
+ 'your_data_path/clevrer/video_validation/', 'video', False),
+ 'Moving Attribute': ('moving_attribute.json',
+ 'your_data_path/clevrer/video_validation/', 'video', False),
+ 'State Change': ('state_change.json',
+ 'your_data_path/perception/videos/', 'video', False),
+ 'Character Order': ('character_order.json',
+ 'your_data_path/perception/videos/', 'video', False),
+ 'Egocentric Navigation': ('egocentric_navigation.json',
+ 'your_data_path/vlnqa/', 'video', False),
+ 'Episodic Reasoning': ('episodic_reasoning.json',
+ 'your_data_path/tvqa/frames_fps3/', 'video', False), # has start & end
+ 'Counterfactual Inference': ('counterfactual_inference.json',
+ 'your_data_path/clevrer/video_validation/', 'video', False),
+ }
+ super().__init__(dataset=dataset, nframe=nframe, fps=fps)
+
+ @classmethod
+ def supported_datasets(cls):
+ return ['MVTamperBench', 'MVTamperBenchStart', 'MVTamperBenchEnd']
+
+ def prepare_dataset(self, dataset_name='MVTamperBench', repo_id=None):
+ if repo_id:
+ dataset_name = repo_id.split('/')[-1]
+ else:
+ repo_id = f'Srikant86/{dataset_name}'
+
+ def check_integrity(pth):
+ """
+ Verifies the completeness and consistency of the dataset located at the specified path.
+
+ Args:
+ path_to_dataset (str): The directory path where the dataset is stored.
+
+ Returns:
+ bool: True if the dataset is intact, False otherwise.
+ """
+ # Construct the full path to the data file
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+
+ # Check if the data file exists
+ if not os.path.exists(data_file):
+ # If the data file doesn't exist, immediately return False
+ return False
+ # Verify the integrity of the data file by checking its MD5 hash
+ if md5(data_file) != self.MD5[dataset_name]:
+ return False
+ # Load the data from the data file
+ data = load(data_file)
+ for idx, item in data.iterrows():
+ if not osp.exists(osp.join(pth, item['prefix'], item['video'])):
+ return False
+ # If all checks pass, the dataset is considered intact
+ return True
+
+ cache_path = get_cache_path(repo_id, branch='main')
+ if cache_path is not None and check_integrity(cache_path):
+ dataset_path = cache_path
+ else:
+ def unzip_hf_zip(pth):
+ pth = os.path.join(pth, 'video/')
+ for filename in os.listdir(pth):
+ if filename.endswith('.zip'):
+ # 构建完整的文件路径
+ zip_path = os.path.join(pth, filename)
+
+ # 解压 ZIP 文件
+ with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+ zip_ref.extractall(pth)
+
+ def generate_tsv(pth):
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+ if os.path.exists(data_file) and md5(data_file) == self.MD5[dataset_name]:
+ return
+ json_data_dir = os.path.join(dataset_path, 'json')
+ self.data_list = []
+ for k, v in self.type_data_list.items():
+ with open(os.path.join(json_data_dir, v[0]), 'r') as f:
+ json_data = json.load(f)
+ for data in json_data:
+ if os.path.exists(
+ os.path.join(dataset_path, v[1].replace('your_data_path', 'video'), data['video'])):
+ self.data_list.append({
+ 'task_type': k,
+ 'prefix': v[1].replace('your_data_path', 'video'),
+ 'data_type': v[2],
+ 'bound': v[3],
+ 'start': data['start'] if 'start' in data.keys() else None,
+ 'end': data['end'] if 'end' in data.keys() else None,
+ 'video': data['video'],
+ 'question': data['question'],
+ 'answer': data['answer'],
+ 'candidates': data['candidates'],
+ 'tamper_type': data['tamper_type'],
+ 'task_tamper_type': f"{k}_{data['tamper_type']}"
+ })
+
+ data_df = pd.DataFrame(self.data_list)
+ data_df = data_df.assign(index=range(len(data_df)))
+ data_df.to_csv(data_file, sep='\t', index=False)
+
+ def move_files(pth):
+ # special for mvbench/data0613 supplementary data
+ src_folder = os.path.join(pth, 'video/data0613')
+ if not os.path.exists(src_folder):
+ return
+ for subdir in os.listdir(src_folder):
+ subdir_path = os.path.join(src_folder, subdir)
+ if os.path.isdir(subdir_path):
+ for subsubdir in os.listdir(subdir_path):
+ subsubdir_path = os.path.join(subdir_path, subsubdir)
+ if os.path.isdir(subsubdir_path):
+ for item in os.listdir(subsubdir_path):
+ item_path = os.path.join(subsubdir_path, item)
+ target_folder = os.path.join(pth, 'video', subdir, subsubdir)
+ if not os.path.exists(os.path.join(target_folder, item)):
+ shutil.move(item_path, os.path.join(target_folder, item))
+
+ src_folder = os.path.join(pth, 'video/perception')
+ if not os.path.exists(src_folder):
+ return
+ for subdir in os.listdir(src_folder):
+ subdir_path = os.path.join(src_folder, subdir)
+ if os.path.isdir(subdir_path):
+ for subsubdir in os.listdir(subdir_path):
+ subsubdir_path = os.path.join(subdir_path, subsubdir)
+ if os.path.isdir(subsubdir_path):
+ if not os.path.exists(src_folder):
+ return
+ for item in os.listdir(subsubdir_path):
+ item_path = os.path.join(subsubdir_path, item)
+ target_folder = os.path.join(pth, 'video/perception', subdir)
+ if not os.path.exists(os.path.join(target_folder, item)):
+ shutil.move(item_path, target_folder)
+
+ hf_token = os.environ.get('HUGGINGFACE_TOKEN')
+ huggingface_hub.login(hf_token)
+ dataset_path = snapshot_download(repo_id=repo_id, repo_type='dataset')
+ unzip_hf_zip(dataset_path)
+ move_files(dataset_path)
+ generate_tsv(dataset_path)
+
+ data_file = osp.join(dataset_path, f'{dataset_name}.tsv')
+
+ self.decord_method = {
+ 'video': self.read_video,
+ 'gif': self.read_gif,
+ 'frame': self.read_frame,
+ }
+
+ self.nframe = 8
+ self.frame_fps = 3
+
+ # transform
+ self.transform = T.Compose([
+ Stack(),
+ ToTorchFormatTensor()
+ ])
+
+ return dict(root=dataset_path, data_file=data_file)
+
+ def get_index(self, bound, fps, max_frame, first_idx=0):
+ start, end = bound if bound else (-100000, 100000)
+ start_idx = max(first_idx, round(start * fps))
+ end_idx = min(round(end * fps), max_frame)
+ seg_size = (end_idx - start_idx) / self.num_segments
+ mid_seg_size = seg_size / 2
+ indices = np.arange(self.num_segments)
+ frame_indices = start_idx + mid_seg_size + np.round(seg_size * indices)
+ return frame_indices.astype(int)
+
+ def read_video(self, video_path, bound=None):
+ vr = VideoReader(video_path, ctx=cpu(0), num_threads=1)
+ max_frame = len(vr) - 1
+ fps = float(vr.get_avg_fps())
+
+ images_group = list()
+ frame_indices = self.get_index(bound, fps, max_frame, first_idx=0)
+ for frame_index in frame_indices:
+ img = Image.fromarray(vr[frame_index].asnumpy())
+ images_group.append(img)
+ torch_imgs = self.transform(images_group)
+ return torch_imgs
+
+ def read_gif(self, video_path, bound=None, fps=25):
+ gif = imageio.get_reader(video_path)
+ max_frame = len(gif) - 1
+
+ images_group = list()
+ frame_indices = self.get_index(bound, fps, max_frame, first_idx=0)
+ for index, frame in enumerate(gif):
+ if index in frame_indices:
+ img = cv2.cvtColor(frame, cv2.COLOR_RGBA2RGB)
+ img = Image.fromarray(img)
+ images_group.append(img)
+ torch_imgs = self.transform(images_group)
+ return torch_imgs
+
+ def read_frame(self, video_path, bound=None, fps=3):
+ """
+ Reads frames from a video directory, processes them, and returns a tensor of images.
+
+ Args:
+ video_path (str): Path to the directory containing video frames.
+ bound (tuple, optional): A tuple specifying the range of frames to read. Defaults to None.
+ fps (int, optional): Frames per second to sample from the video. Defaults to 3.
+
+ Returns:
+ torch.Tensor: A tensor containing the processed images.
+ """
+ max_frame = len(os.listdir(video_path))
+ images_group = list()
+ frame_indices = self.get_index(bound, fps, max_frame, first_idx=1) # frame_idx starts from 1
+ for frame_index in frame_indices:
+ img = Image.open(os.path.join(video_path, f'{frame_index:05d}.jpg'))
+ images_group.append(img)
+ torch_imgs = self.transform(images_group)
+ return torch_imgs
+
+ def save_video_frames(self, imgs, video_name, frames):
+
+ frame_paths = self.frame_paths(video_name)
+ flag = np.all([osp.exists(p) for p in frame_paths])
+
+ if not flag:
+ block_size = imgs.size(0) // frames
+ split_tensors = torch.split(imgs, block_size)
+ to_pil = transforms.ToPILImage()
+ images = [to_pil(arr) for arr in split_tensors]
+ for im, pth in zip(images, frame_paths):
+ if not osp.exists(pth):
+ im.save(pth)
+
+ return frame_paths
+
+ def qa_template(self, data):
+ question = f"Question: {data['question']}\n"
+ question += 'Options:\n'
+ answer = data['answer']
+ answer_idx = -1
+ for idx, c in enumerate(eval(data['candidates'])):
+ question += f"({chr(ord('A') + idx)}) {c}\n"
+ if c == answer:
+ answer_idx = idx
+ question = question.rstrip()
+ answer = f"({chr(ord('A') + answer_idx)}) {answer}"
+ return question, answer
+
+ def load_into_video_and_process(self, line):
+ """
+ Loads a video or image sequence, processes it, and returns the path to the processed video.
+
+ Args:
+ line (dict): A dictionary containing the following keys:
+ - 'prefix' (str): The prefix path to the video or image sequence.
+ - 'video' (str): The video file name or directory containing image frames.
+ - 'data_type' (str): The type of data, either 'gif', 'webm', or 'frame'.
+ - 'bound' (bool): Whether to process a subclip of the video.
+ - 'start' (float): The start time of the subclip (if 'bound' is True).
+ - 'end' (float): The end time of the subclip (if 'bound' is True).
+
+ Returns:
+ str: The path to the processed video file.
+
+ Raises:
+ ImportError: If MoviePy is not installed.
+ """
+ try:
+ from moviepy.editor import VideoFileClip, ImageSequenceClip
+ except:
+ raise ImportError(
+ 'MoviePy is not installed, please install it by running "pip install moviepy==1.0.3"'
+ )
+ video_path = os.path.join(self.data_root, line['prefix'], line['video'])
+
+ if line['data_type'] in ['gif'] or os.path.splitext(video_path)[1] in ['.webm']:
+ processed_video_path = video_path.replace(os.path.splitext(video_path)[1], '.mp4')
+ if not os.path.exists(processed_video_path):
+ # using MoviePy to transform GIF, webm into mp4 format
+ gif_clip = VideoFileClip(video_path)
+ gif_clip.write_videofile(processed_video_path, codec='libx264')
+ gif_clip.close()
+ elif line['data_type'] in ['frame']:
+ input_images = os.path.join(video_path, '*.jpg')
+ processed_video_path = f'{video_path}.mp4'
+ if not os.path.exists(processed_video_path):
+ # using MoviePy to transform images into mp4
+ image_files = sorted(glob.glob(input_images))
+ image_clip = ImageSequenceClip(image_files, fps=self.frame_fps)
+ image_clip.write_videofile(processed_video_path, codec='libx264')
+ image_clip.close()
+ else:
+ processed_video_path = video_path
+
+ if line['bound']:
+ base_name, suffix = os.path.splitext(processed_video_path)
+ output_video_path = f'{base_name}_processed{suffix}'
+ if not os.path.exists(output_video_path):
+ video_clip = VideoFileClip(processed_video_path)
+ clip = video_clip.subclip(line['start'], min(line['end'], video_clip.duration))
+ clip.write_videofile(output_video_path)
+ clip.close()
+ else:
+ output_video_path = processed_video_path
+
+ return output_video_path
+
+ def save_video_into_images(self, line):
+ bound = None
+ if line['bound']:
+ bound = (
+ line['start'],
+ line['end'],
+ )
+ video_path = os.path.join(self.data_root, line['prefix'], line['video'])
+ decord_method = self.decord_method[line['data_type']]
+ self.num_segments = self.nframe
+ torch_imgs = decord_method(video_path, bound)
+ img_frame_paths = self.save_video_frames(torch_imgs, line['video'], self.num_segments)
+ return img_frame_paths
+
+ def build_prompt(self, line, video_llm):
+ """
+ Builds a prompt for a language model based on the provided data and settings.
+
+ Args:
+ line (int or dict): Either an integer index into the dataset or dictionary representing a single data point.
+ video_llm (bool): Whether to use a video-based language model or process individual frames as images.
+
+ Returns:
+ list: A list of dictionaries representing the constructed prompt, where each dictionary contains the type
+ and value of the prompt element.
+
+ Raises:
+ ValueError: If the frame rate (fps) is greater than zero, indicating that this method
+ is not compatible with MVBench's requirements.
+ """
+ # Ensure that the frame rate is not set, as MVBench does not support it
+ if self.fps > 0:
+ raise ValueError('MVBench does not support fps setting, please transfer to MVBench_MP4!')
+
+ # If line is an integer, retrieve the corresponding data point from the d
+ if isinstance(line, int):
+ assert line < len(self)
+ line = self.data.iloc[line]
+
+ # Generate the question and answer pair based on the current data point
+ question, answer = self.qa_template(line)
+ # Initialize the prompt with a system message
+ message = [dict(type='text', value=self.SYS, role='system')]
+ # Add the generated question to the prompt
+ message.append(dict(type='text', value=question))
+ # Process the video data according to the specified mode
+ if video_llm:
+ # Load the video and process it for the video-based langua
+ new_video_path = self.load_into_video_and_process(line)
+ message.append(dict(type='video', value=new_video_path))
+ else:
+ # Save the video as individual image frames for processing
+ img_frame_paths = self.save_video_into_images(line)
+ for im in img_frame_paths:
+ message.append(dict(type='image', value=im))
+ # Add instructions to the prompt
+ message.append(dict(type='text', value='\nOnly give the best option.'))
+ # Indicate the start of the assistant's response
+ message.append(dict(type='text', value='Best option:(', role='assistant'))
+ return message
+
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ """
+ Evaluates the given evaluation file and generates ratings based on different dimensions.
+
+ Args:
+ eval_file (str): Path to the evaluation file. The file should be in .xlsx format.
+ **judge_kwargs: Additional keyword arguments for the judge model.
+
+ Returns:
+ dict: A dictionary containing ratings for task type, tamper type, and task-tamper type.
+
+ Raises:
+ AssertionError: If the eval_file does not end with '.xlsx'.
+ Warning: If the OPENAI API is not working properly or the API key is not set,
+ exact matching will be used for evaluation.
+
+ Notes:
+ - The function generates temporary files and score files based on the eval_file name.
+ - If the score file already exists, it will be used directly.
+ - The function processes the data, evaluates predictions, and calculates scores.
+ - Ratings are generated for different dimensions and saved to respective files.
+ """
+
+ assert eval_file.endswith('.xlsx'), 'data file should be an xlsx file'
+
+ tmp_file = eval_file.replace('.xlsx', '_tmp.pkl')
+ tgt_task_type_file = eval_file.replace('.xlsx', '_task_type_rating.json')
+ tgt_tamper_type_file = eval_file.replace('.xlsx', '_tamper_type_rating.json')
+ tgt_task_tamper_type_file = eval_file.replace('.xlsx', '_task_tamper_type_rating.json')
+ score_file = eval_file.replace('.xlsx', '_score.xlsx')
+ score_metrics_file = eval_file.replace('.xlsx', '_score_f1.xlsx')
+ action_metrics_file = eval_file.replace('.xlsx', '_action_f1.xlsx')
+
+ if not osp.exists(score_file):
+ model = judge_kwargs.setdefault('model', 'chatgpt-0125')
+ assert model in ['chatgpt-0125', 'exact_matching', 'gpt-4-0125']
+
+ if model == 'exact_matching':
+ model = None
+ elif gpt_key_set():
+ model = build_judge(**judge_kwargs)
+ if not model.working():
+ warnings.warn('OPENAI API is not working properly, will use exact matching for evaluation')
+ warnings.warn(DEBUG_MESSAGE)
+ model = None
+ else:
+ warnings.warn('OPENAI_API_KEY is not set properly, will use exact matching for evaluation')
+ model = None
+ res = {} if not osp.exists(tmp_file) else load(tmp_file)
+ res = {k: v for k, v in res.items() if FAIL_MSG not in v}
+
+ data = load(eval_file)
+ data_un = data[~pd.isna(data['prediction'])]
+
+ for idx in data_un['index']:
+ ans = data.loc[data['index'] == idx, 'answer'].values[0]
+ pred = data.loc[data['index'] == idx, 'prediction'].values[0]
+ options = eval(data.loc[data['index'] == idx, 'candidates'].values[0])
+ answer_idx = -1
+ for id, c in enumerate(options):
+ if c == ans:
+ answer_idx = id
+ ans = f"({chr(ord('A') + answer_idx)}) {ans}"
+ input_item = data.loc[data['index'] == idx].to_dict(orient='records')[0]
+ for id, option_content in enumerate(eval(input_item['candidates'])):
+ input_item[chr(ord('A') + id)] = option_content
+ if option_content == input_item['answer']:
+ input_item['answer'] = chr(ord('A') + id)
+
+ if FAIL_MSG in pred:
+ data.loc[idx, 'score'] = -1
+ else:
+ data.loc[idx, 'score'] = int(check_ans_with_model(
+ pred, ans, model,
+ input_item,
+ 'MVTamperBench'
+ ))
+
+ rejected = [x for x in data['score'] if x == -1]
+
+ print(
+ f'Among {len(data)} questions, failed to obtain prediction for {len(data) - len(data_un)} questions, '
+ f'failed to obtain the score for another {len(rejected)} questions. '
+ f'Those questions will be counted as -1 score in ALL rating, and will not be counted in VALID rating.'
+ )
+
+ dump(data, score_file)
+
+ model_name = score_file.split(f"_{self.BASENAME}")[0].split("/")[-1]
+
+ score_metrics = process_results(score_file, model_name)
+ dump(score_metrics, score_metrics_file)
+
+ action_metrics = aggregate_metrics_with_macro_average(score_file)
+ dump(action_metrics, action_metrics_file)
+
+ rating_task_type = get_dimension_rating(score_file, 'task_type')
+ dump(rating_task_type, tgt_task_type_file)
+ rating_tamper_type = get_dimension_rating(score_file, 'tamper_type')
+ dump(rating_tamper_type, tgt_tamper_type_file)
+ rating_task_tamper_type = get_dimension_rating(score_file, 'task_tamper_type')
+ dump(rating_task_tamper_type, tgt_task_tamper_type_file)
+ rating = {**rating_task_type, **rating_tamper_type, **rating_task_tamper_type}
+ return rating
diff --git a/vlmeval/dataset/tempcompass.py b/vlmeval/dataset/tempcompass.py
new file mode 100644
index 0000000000000000000000000000000000000000..e61bf21a6f1b513d90b8392c2602f29c36a7d380
--- /dev/null
+++ b/vlmeval/dataset/tempcompass.py
@@ -0,0 +1,639 @@
+import huggingface_hub
+from huggingface_hub import snapshot_download
+from ..smp import *
+from .video_concat_dataset import ConcatVideoDataset
+from .video_base import VideoBaseDataset
+from .utils import build_judge, DEBUG_MESSAGE
+from ..utils import track_progress_rich
+import torchvision.transforms as T
+from torchvision import transforms
+from torchvision.transforms.functional import InterpolationMode
+from decord import VideoReader, cpu
+from .utils.tempcompass import *
+
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+class TempCompass(ConcatVideoDataset):
+ def __init__(self, dataset='TempCompass', nframe=0, fps=-1):
+ self.DATASET_SETS[dataset] = ['TempCompass_MCQ', 'TempCompass_Captioning', 'TempCompass_YorN']
+ super().__init__(dataset=dataset, nframe=nframe, fps=fps)
+
+ @classmethod
+ def supported_datasets(cls):
+ return ['TempCompass']
+
+ def evaluate(self, eval_file, **judge_kwargs):
+ result = super().evaluate(eval_file=eval_file, **judge_kwargs)
+ suffix = eval_file.split('.')[-1]
+ result = result.reset_index().rename(columns={'index': 'dim.task_type'})
+ score_file = eval_file.replace(f'.{suffix}', '_acc.csv')
+ avg_dict = {}
+ for idx, item in result.iterrows():
+ dim, task_type = item['dim.task_type'].split('. ')
+ if dim not in avg_dict:
+ avg_dict[dim] = {'success': 0.0, 'overall': 0.0}
+ if task_type not in avg_dict:
+ avg_dict[task_type] = {'success': 0.0, 'overall': 0.0}
+ if 'overall' not in avg_dict:
+ avg_dict['overall'] = {'success': 0.0, 'overall': 0.0}
+ avg_dict[dim]['success'] += item['success']
+ avg_dict[dim]['overall'] += item['overall']
+ avg_dict[task_type]['success'] += item['success']
+ avg_dict[task_type]['overall'] += item['overall']
+ avg_dict['overall']['success'] += item['success']
+ avg_dict['overall']['overall'] += item['overall']
+ result.loc[idx, 'acc'] = round(item['success'] / item['overall'] * 100, 2)
+ for key, value in avg_dict.items():
+ # 使用 loc 方法添加新行
+ result.loc[len(result)] = {
+ 'dim.task_type': key,
+ 'success': value['success'],
+ 'overall': value['overall'],
+ 'acc': round(value['success'] / value['overall'] * 100, 2)
+ }
+ dump(result, score_file)
+ return result
+
+
+class TempCompass_MCQ(VideoBaseDataset):
+
+ MD5 = '7efbb9e6d9dabacd22daf274852691dd'
+ TYPE = 'Video-MCQ'
+
+ def __init__(self, dataset='TempCompass_MCQ', nframe=0, fps=-1):
+ self.type_data_list = {
+ 'multi-choice': ('multi-choice.json', './videos', '.mp4'),
+ 'caption_matching': ('caption_matching.json', './videos', '.mp4'),
+ }
+ super().__init__(dataset=dataset, nframe=nframe, fps=fps)
+
+ @classmethod
+ def supported_datasets(cls):
+ return ['TempCompass_MCQ']
+
+ def prepare_dataset(self, dataset_name='TempCompass_MCQ', repo_id='lmms-lab/TempCompass'):
+ def check_integrity(pth):
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+
+ if not osp.exists(data_file):
+ return False
+
+ if md5(data_file) != self.MD5:
+ return False
+
+ data = load(data_file)
+ for idx, item in data.iterrows():
+ if not osp.exists(osp.join(pth, item['prefix'], item['video'] + item['suffix'])):
+ return False
+ return True
+
+ cache_path = get_cache_path(repo_id)
+ if cache_path is not None and check_integrity(cache_path):
+ dataset_path = cache_path
+ else:
+ def read_parquet(pth):
+ import pandas as pd
+ for task_name in self.type_data_list.keys():
+ if not osp.exists(osp.join(pth, f'{task_name}.json')):
+ data = pd.read_parquet(osp.join(pth, task_name, 'test-00000-of-00001.parquet'))
+ data.to_json(osp.join(pth, f'{task_name}.json'), orient='records', lines=False)
+
+ def unzip_videos(pth):
+ import zipfile
+ if not osp.exists(osp.join(pth, 'videos')):
+ zip_file = osp.join(pth, 'tempcompass_videos.zip')
+ with zipfile.ZipFile(zip_file, 'r') as zip_ref:
+ zip_ref.extractall(pth)
+
+ def generate_tsv(pth):
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+ if osp.exists(data_file) and md5(data_file) == self.MD5:
+ return
+ self.data_list = []
+ for k, v in self.type_data_list.items():
+ with open(osp.join(pth, v[0]), 'r') as f:
+ json_data = json.load(f)
+ for data in json_data:
+ self.data_list.append({
+ 'task_type': k,
+ 'prefix': v[1],
+ 'suffix': v[2],
+ 'video': data['video_id'],
+ 'question': data['question'].split('\n')[0],
+ 'answer': data['answer'],
+ 'dim': data['dim'],
+ 'candidates': data['question'].split('\n')[1:],
+ })
+
+ data_df = pd.DataFrame(self.data_list)
+ data_df = data_df.assign(index=range(len(data_df)))
+ data_df.to_csv(data_file, sep='\t', index=False)
+
+ if modelscope_flag_set():
+ from modelscope import dataset_snapshot_download
+ dataset_path = dataset_snapshot_download(dataset_id=repo_id)
+ else:
+ dataset_path = snapshot_download(repo_id=repo_id, repo_type='dataset')
+ read_parquet(dataset_path)
+ unzip_videos(dataset_path)
+ generate_tsv(dataset_path)
+
+ data_file = osp.join(dataset_path, f'{dataset_name}.tsv')
+ return dict(root=dataset_path, data_file=data_file)
+
+ def qa_template(self, data):
+ question = data['question'] + '\n' + '\n'.join(eval(data['candidates']))
+ answer = data['answer']
+ return question, answer
+
+ def save_video_frames(self, line):
+ vid_path = osp.join(self.data_root, line['prefix'], line['video'] + line['suffix'])
+ vid = decord.VideoReader(vid_path)
+ video_info = {
+ 'fps': vid.get_avg_fps(),
+ 'n_frames': len(vid),
+ }
+ if self.nframe > 0 and self.fps < 0:
+ step_size = len(vid) / (self.nframe + 1)
+ indices = [int(i * step_size) for i in range(1, self.nframe + 1)]
+ frame_paths = self.frame_paths(line['video'])
+ elif self.fps > 0:
+ # not constrained by num_frames, get frames by fps
+ total_duration = video_info['n_frames'] / video_info['fps']
+ required_frames = int(total_duration * self.fps)
+ step_size = video_info['fps'] / self.fps
+ indices = [int(i * step_size) for i in range(required_frames)]
+ frame_paths = self.frame_paths_fps(line['video'], len(indices))
+
+ flag = np.all([osp.exists(p) for p in frame_paths])
+
+ if not flag:
+ images = [vid[i].asnumpy() for i in indices]
+ images = [Image.fromarray(arr) for arr in images]
+ for im, pth in zip(images, frame_paths):
+ if not osp.exists(pth):
+ im.save(pth)
+
+ return frame_paths
+
+ def save_video_into_images(self, line):
+ frame_paths = self.save_video_frames(line)
+ return frame_paths
+
+ def build_prompt(self, line, video_llm):
+ if isinstance(line, int):
+ assert line < len(self)
+ line = self.data.iloc[line]
+
+ question, answer = self.qa_template(line)
+ message = []
+ message.append(dict(type='text', value=question))
+ video_path = osp.join(self.data_root, line['prefix'], line['video'] + line['suffix'])
+ if video_llm:
+ message.append(dict(type='video', value=video_path))
+ else:
+ img_frame_paths = self.save_video_into_images(line)
+ for im in img_frame_paths:
+ message.append(dict(type='image', value=im))
+ message.append(dict(type='text', value='\nPlease directly give the best option:'))
+ return message
+
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ model = judge_kwargs.get('model', 'exact_matching')
+ assert model in ['chatgpt-1106', 'exact_matching']
+ judge_kwargs.update({
+ "max_tokens": 128,
+ "temperature": 1.0,
+ "top_p": 1,
+ "presence_penalty": 1,
+ })
+
+ suffix = eval_file.split('.')[-1]
+ score_file = eval_file.replace(f'.{suffix}', f'_{model}_score.xlsx')
+ tmp_file = eval_file.replace(f'.{suffix}', f'_{model}.pkl')
+ nproc = judge_kwargs.pop('nproc', 4)
+
+ if not osp.exists(score_file):
+ data = load(eval_file)
+ if model != 'exact_matching':
+ model = build_judge(system_prompt=sys_prompt, **judge_kwargs)
+ else:
+ model = None
+
+ lt = len(data)
+ lines = [data.iloc[i] for i in range(lt)]
+ tups = [(model, line) for line in lines]
+ indices = [line['index'] for line in lines]
+
+ ans = {}
+ if osp.exists(tmp_file):
+ ans = load(tmp_file)
+ tups = [x for x, i in zip(tups, indices) if i not in ans]
+ indices = [i for i in indices if i not in ans]
+
+ if len(indices):
+ _ = track_progress_rich(
+ evaluate_tempcompass_mcq,
+ tups,
+ nproc=nproc,
+ chunksize=nproc,
+ keys=indices,
+ save=tmp_file,
+ )
+ ans = load(tmp_file)
+ for idx, item in data.iterrows():
+ data.loc[idx, 'score'] = ans[idx]['rating']
+ dump(data, score_file)
+
+ rating = get_dimension_rating(score_file)
+ return rating
+
+
+class TempCompass_Captioning(VideoBaseDataset):
+
+ MD5 = '35be9bf2581ea7767f02e9a8f37ae1ab'
+ TYPE = 'Video-VQA'
+
+ def __init__(self, dataset='TempCompass_Captioning', nframe=0, fps=-1):
+ self.type_data_list = {
+ 'captioning': ('captioning.json', './videos', '.mp4'),
+ }
+ super().__init__(dataset=dataset, nframe=nframe, fps=fps)
+
+ @classmethod
+ def supported_datasets(cls):
+ return ['TempCompass_Captioning']
+
+ def prepare_dataset(self, dataset_name='TempCompass_Captioning', repo_id='lmms-lab/TempCompass'):
+ def check_integrity(pth):
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+
+ if not osp.exists(data_file):
+ return False
+
+ if md5(data_file) != self.MD5:
+ return False
+
+ data = load(data_file)
+ for idx, item in data.iterrows():
+ if not osp.exists(osp.join(pth, item['prefix'], item['video'] + item['suffix'])):
+ return False
+ return True
+
+ cache_path = get_cache_path(repo_id)
+ if cache_path is not None and check_integrity(cache_path):
+ dataset_path = cache_path
+ else:
+ def read_parquet(pth):
+ import pandas as pd
+ for task_name in self.type_data_list.keys():
+ if not osp.exists(osp.join(pth, f'{task_name}.json')):
+ data = pd.read_parquet(osp.join(pth, task_name, 'test-00000-of-00001.parquet'))
+ data.to_json(osp.join(pth, f'{task_name}.json'), orient='records', lines=False)
+
+ def unzip_videos(pth):
+ import zipfile
+ if not osp.exists(osp.join(pth, 'videos')):
+ zip_file = osp.join(pth, 'tempcompass_videos.zip')
+ with zipfile.ZipFile(zip_file, 'r') as zip_ref:
+ zip_ref.extractall(pth)
+
+ def generate_tsv(pth):
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+ if osp.exists(data_file) and md5(data_file) == self.MD5:
+ return
+ self.data_list = []
+ for k, v in self.type_data_list.items():
+ with open(osp.join(pth, v[0]), 'r') as f:
+ json_data = json.load(f)
+ for data in json_data:
+ self.data_list.append({
+ 'task_type': k,
+ 'prefix': v[1],
+ 'suffix': v[2],
+ 'video': data['video_id'],
+ 'question': data['question'],
+ 'answer': data['answer'],
+ 'dim': data['dim'],
+ 'mc_question': data['mc_question'],
+ 'mc_answer': data['mc_answer'],
+ })
+
+ data_df = pd.DataFrame(self.data_list)
+ data_df = data_df.assign(index=range(len(data_df)))
+ data_df.to_csv(data_file, sep='\t', index=False)
+
+ if modelscope_flag_set():
+ from modelscope import dataset_snapshot_download
+ dataset_path = dataset_snapshot_download(dataset_id=repo_id)
+ else:
+ dataset_path = snapshot_download(repo_id=repo_id, repo_type='dataset')
+ read_parquet(dataset_path)
+ unzip_videos(dataset_path)
+ generate_tsv(dataset_path)
+
+ data_file = osp.join(dataset_path, f'{dataset_name}.tsv')
+ return dict(root=dataset_path, data_file=data_file)
+
+ def qa_template(self, data):
+ question = data['question']
+ answer = data['answer']
+ return question, answer
+
+ def save_video_frames(self, line):
+ vid_path = osp.join(self.data_root, line['prefix'], line['video'] + line['suffix'])
+ vid = decord.VideoReader(vid_path)
+ video_info = {
+ 'fps': vid.get_avg_fps(),
+ 'n_frames': len(vid),
+ }
+ if self.nframe > 0 and self.fps < 0:
+ step_size = len(vid) / (self.nframe + 1)
+ indices = [int(i * step_size) for i in range(1, self.nframe + 1)]
+ frame_paths = self.frame_paths(line['video'])
+ elif self.fps > 0:
+ # not constrained by num_frames, get frames by fps
+ total_duration = video_info['n_frames'] / video_info['fps']
+ required_frames = int(total_duration * self.fps)
+ step_size = video_info['fps'] / self.fps
+ indices = [int(i * step_size) for i in range(required_frames)]
+ frame_paths = self.frame_paths_fps(line['video'], len(indices))
+
+ flag = np.all([osp.exists(p) for p in frame_paths])
+
+ if not flag:
+ images = [vid[i].asnumpy() for i in indices]
+ images = [Image.fromarray(arr) for arr in images]
+ for im, pth in zip(images, frame_paths):
+ if not osp.exists(pth):
+ im.save(pth)
+
+ return frame_paths
+
+ def save_video_into_images(self, line):
+ frame_paths = self.save_video_frames(line)
+ return frame_paths
+
+ def build_prompt(self, line, video_llm):
+ if isinstance(line, int):
+ assert line < len(self)
+ line = self.data.iloc[line]
+
+ question, answer = self.qa_template(line)
+ message = []
+ message.append(dict(type='text', value=question))
+ video_path = osp.join(self.data_root, line['prefix'], line['video'] + line['suffix'])
+ if video_llm:
+ message.append(dict(type='video', value=video_path))
+ else:
+ img_frame_paths = self.save_video_into_images(line)
+ for im in img_frame_paths:
+ message.append(dict(type='image', value=im))
+ return message
+
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ model = judge_kwargs.setdefault('model', 'chatgpt-1106')
+ assert model in ['chatgpt-1106']
+ judge_kwargs.update({
+ "max_tokens": 128,
+ "temperature": 1.0,
+ "top_p": 1,
+ "presence_penalty": 1,
+ })
+
+ suffix = eval_file.split('.')[-1]
+ score_file = eval_file.replace(f'.{suffix}', f'_{model}_score.xlsx')
+ tmp_file = eval_file.replace(f'.{suffix}', f'_{model}.pkl')
+ nproc = judge_kwargs.pop('nproc', 4)
+
+ if not osp.exists(score_file):
+ data = load(eval_file)
+ if model != 'exact_matching':
+ model = build_judge(system_prompt=sys_prompt, **judge_kwargs)
+ else:
+ model = None
+
+ lt = len(data)
+ lines = [data.iloc[i] for i in range(lt)]
+ tups = [(model, line) for line in lines]
+ indices = [line['index'] for line in lines]
+
+ ans = {}
+ if osp.exists(tmp_file):
+ ans = load(tmp_file)
+ tups = [x for x, i in zip(tups, indices) if i not in ans]
+ indices = [i for i in indices if i not in ans]
+
+ if len(indices):
+ _ = track_progress_rich(
+ evaluate_tempcompass_captioning,
+ tups,
+ nproc=nproc,
+ chunksize=nproc,
+ keys=indices,
+ save=tmp_file,
+ )
+ ans = load(tmp_file)
+ for idx, item in data.iterrows():
+ data.loc[idx, 'score'] = ans[idx]['rating']
+ dump(data, score_file)
+
+ rating = get_dimension_rating(score_file)
+ return rating
+
+
+class TempCompass_YorN(VideoBaseDataset):
+
+ MD5 = 'c72c046d7fa0e82c8cd7462f2e844ea8'
+ TYPE = 'Video-Y/N'
+
+ def __init__(self, dataset='TempCompass_YorN', nframe=0, fps=-1):
+ self.type_data_list = {
+ 'yes_no': ('yes_no.json', './videos', '.mp4'),
+ }
+ super().__init__(dataset=dataset, nframe=nframe, fps=fps)
+
+ @classmethod
+ def supported_datasets(cls):
+ return ['TempCompass_YorN']
+
+ def prepare_dataset(self, dataset_name='TempCompass_YorN', repo_id='lmms-lab/TempCompass'):
+ def check_integrity(pth):
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+
+ if not osp.exists(data_file):
+ return False
+
+ if md5(data_file) != self.MD5:
+ return False
+
+ data = load(data_file)
+ for idx, item in data.iterrows():
+ if not osp.exists(osp.join(pth, item['prefix'], item['video'] + item['suffix'])):
+ return False
+ return True
+
+ cache_path = get_cache_path(repo_id)
+ if cache_path is not None and check_integrity(cache_path):
+ dataset_path = cache_path
+ else:
+ def read_parquet(pth):
+ import pandas as pd
+ for task_name in self.type_data_list.keys():
+ if not osp.exists(osp.join(pth, f'{task_name}.json')):
+ data = pd.read_parquet(osp.join(pth, task_name, 'test-00000-of-00001.parquet'))
+ data.to_json(osp.join(pth, f'{task_name}.json'), orient='records', lines=False)
+
+ def unzip_videos(pth):
+ import zipfile
+ if not osp.exists(osp.join(pth, 'videos')):
+ zip_file = osp.join(pth, 'tempcompass_videos.zip')
+ with zipfile.ZipFile(zip_file, 'r') as zip_ref:
+ zip_ref.extractall(pth)
+
+ def generate_tsv(pth):
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+ if osp.exists(data_file) and md5(data_file) == self.MD5:
+ return
+ self.data_list = []
+ for k, v in self.type_data_list.items():
+ with open(osp.join(pth, v[0]), 'r') as f:
+ json_data = json.load(f)
+ for data in json_data:
+ self.data_list.append({
+ 'task_type': k,
+ 'prefix': v[1],
+ 'suffix': v[2],
+ 'video': data['video_id'],
+ 'question': data['question'].split('\n')[0],
+ 'answer': data['answer'],
+ 'dim': data['dim']
+ })
+
+ data_df = pd.DataFrame(self.data_list)
+ data_df = data_df.assign(index=range(len(data_df)))
+ data_df.to_csv(data_file, sep='\t', index=False)
+
+ if modelscope_flag_set():
+ from modelscope import dataset_snapshot_download
+ dataset_path = dataset_snapshot_download(dataset_id=repo_id)
+ else:
+ dataset_path = snapshot_download(repo_id=repo_id, repo_type='dataset')
+ read_parquet(dataset_path)
+ unzip_videos(dataset_path)
+ generate_tsv(dataset_path)
+
+ data_file = osp.join(dataset_path, f'{dataset_name}.tsv')
+ return dict(root=dataset_path, data_file=data_file)
+
+ def qa_template(self, data):
+ question = data['question']
+ answer = data['answer']
+ return question, answer
+
+ def save_video_frames(self, line):
+ vid_path = osp.join(self.data_root, line['prefix'], line['video'] + line['suffix'])
+ vid = decord.VideoReader(vid_path)
+ video_info = {
+ 'fps': vid.get_avg_fps(),
+ 'n_frames': len(vid),
+ }
+ if self.nframe > 0 and self.fps < 0:
+ step_size = len(vid) / (self.nframe + 1)
+ indices = [int(i * step_size) for i in range(1, self.nframe + 1)]
+ frame_paths = self.frame_paths(line['video'])
+ elif self.fps > 0:
+ # not constrained by num_frames, get frames by fps
+ total_duration = video_info['n_frames'] / video_info['fps']
+ required_frames = int(total_duration * self.fps)
+ step_size = video_info['fps'] / self.fps
+ indices = [int(i * step_size) for i in range(required_frames)]
+ frame_paths = self.frame_paths_fps(line['video'], len(indices))
+
+ flag = np.all([osp.exists(p) for p in frame_paths])
+
+ if not flag:
+ images = [vid[i].asnumpy() for i in indices]
+ images = [Image.fromarray(arr) for arr in images]
+ for im, pth in zip(images, frame_paths):
+ if not osp.exists(pth):
+ im.save(pth)
+
+ return frame_paths
+
+ def save_video_into_images(self, line):
+ frame_paths = self.save_video_frames(line)
+ return frame_paths
+
+ def build_prompt(self, line, video_llm):
+ if isinstance(line, int):
+ assert line < len(self)
+ line = self.data.iloc[line]
+
+ question, answer = self.qa_template(line)
+ message = []
+ message.append(dict(type='text', value=question))
+ video_path = osp.join(self.data_root, line['prefix'], line['video'] + line['suffix'])
+ if video_llm:
+ message.append(dict(type='video', value=video_path))
+ else:
+ img_frame_paths = self.save_video_into_images(line)
+ for im in img_frame_paths:
+ message.append(dict(type='image', value=im))
+ message.append(dict(type='text', value='\nPlease answer yes or no:'))
+ return message
+
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ model = judge_kwargs.get('model', 'exact_matching')
+ assert model in ['chatgpt-1106', 'exact_matching']
+ judge_kwargs.update({
+ "max_tokens": 128,
+ "temperature": 1.0,
+ "top_p": 1,
+ "presence_penalty": 1,
+ })
+
+ suffix = eval_file.split('.')[-1]
+ score_file = eval_file.replace(f'.{suffix}', f'_{model}_score.xlsx')
+ tmp_file = eval_file.replace(f'.{suffix}', f'_{model}.pkl')
+ nproc = judge_kwargs.pop('nproc', 4)
+
+ if not osp.exists(score_file):
+ data = load(eval_file)
+ if model != 'exact_matching':
+ model = build_judge(system_prompt=sys_prompt, **judge_kwargs)
+ else:
+ model = None
+
+ lt = len(data)
+ lines = [data.iloc[i] for i in range(lt)]
+ tups = [(model, line) for line in lines]
+ indices = [line['index'] for line in lines]
+
+ ans = {}
+ if osp.exists(tmp_file):
+ ans = load(tmp_file)
+ tups = [x for x, i in zip(tups, indices) if i not in ans]
+ indices = [i for i in indices if i not in ans]
+
+ if len(indices):
+ _ = track_progress_rich(
+ evaluate_tempcompass_YorN,
+ tups,
+ nproc=nproc,
+ chunksize=nproc,
+ keys=indices,
+ save=tmp_file,
+ )
+ ans = load(tmp_file)
+ for idx, item in data.iterrows():
+ data.loc[idx, 'score'] = ans[idx]['rating']
+ dump(data, score_file)
+
+ rating = get_dimension_rating(score_file)
+ return rating
diff --git a/vlmeval/dataset/text_base.py b/vlmeval/dataset/text_base.py
new file mode 100644
index 0000000000000000000000000000000000000000..67bb9378915f4ca08ddec25ecfa02f27dca06d86
--- /dev/null
+++ b/vlmeval/dataset/text_base.py
@@ -0,0 +1,88 @@
+from abc import abstractmethod
+from ..smp import *
+
+
+class TextBaseDataset:
+ MODALITY = 'TEXT'
+ DATASET_URL = {}
+ DATASET_MD5 = {}
+
+ def __init__(self, dataset='MMBench', **kwargs):
+ self.dataset_name = dataset
+
+ data = self.load_data(dataset)
+
+ data['index'] = [str(x) for x in data['index']]
+
+ if np.all([istype(x, int) for x in data['index']]):
+ data['index'] = [int(x) for x in data['index']]
+
+ self.data = data
+ self.post_build(dataset)
+
+ def __len__(self):
+ return len(self.data)
+
+ def __getitem__(self, idx):
+ return dict(self.data.iloc[idx])
+
+ def prepare_tsv(self, url, file_md5=None):
+ data_root = LMUDataRoot()
+ os.makedirs(data_root, exist_ok=True)
+ update_flag = False
+ file_name = url.split('/')[-1]
+ data_path = osp.join(data_root, file_name)
+ if osp.exists(data_path) and (file_md5 is None or md5(data_path) == file_md5):
+ pass
+ else:
+ warnings.warn('The dataset tsv is not downloaded')
+ download_file(url, data_path)
+ update_flag = True
+
+ if file_size(data_path, 'GB') > 1:
+ local_path = data_path.replace('.tsv', '_local.tsv')
+ if not osp.exists(local_path) or os.environ.get('FORCE_LOCAL', None) or update_flag:
+ from ..tools import LOCALIZE
+ LOCALIZE(data_path, local_path)
+ data_path = local_path
+ return load(data_path)
+
+ def dump_image(self, line):
+ return []
+
+ def display(self, line):
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+ assert isinstance(line, pd.Series) or isinstance(line, dict)
+ mmqa_display(line)
+
+ # Return a list of dataset names that are supported by this class, can override
+ @classmethod
+ def supported_datasets(cls):
+ return list(cls.DATASET_URL)
+
+ # Given the dataset name, return the dataset as a pandas dataframe, can override
+ def load_data(self, dataset):
+ url = self.DATASET_URL[dataset]
+ file_md5 = self.DATASET_MD5[dataset]
+ return self.prepare_tsv(url, file_md5)
+
+ # Post built hook, will be called after the dataset is built, can override
+ def post_build(self, dataset):
+ pass
+
+ # Given one data record, return the built prompt (a multi-modal message), can override
+ def build_prompt(self, line):
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ question = line['question']
+
+ msgs = []
+ msgs.append(dict(type='text', value=question))
+ return msgs
+
+ # Given the prediction file, return the evaluation results in the format of a dictionary or pandas dataframe
+ @abstractmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ pass
diff --git a/vlmeval/dataset/text_mcq.py b/vlmeval/dataset/text_mcq.py
new file mode 100644
index 0000000000000000000000000000000000000000..9db53893d69b5c58ed4026e5831b14db0234a6dd
--- /dev/null
+++ b/vlmeval/dataset/text_mcq.py
@@ -0,0 +1,123 @@
+from .text_base import TextBaseDataset
+from .utils import build_judge, DEBUG_MESSAGE
+from ..smp import *
+
+
+class TextMCQDataset(TextBaseDataset):
+ TYPE = 'MCQ'
+
+ DATASET_URL = {}
+
+ DATASET_MD5 = {}
+
+ def build_prompt(self, line):
+
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ question = line['question']
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ options_prompt = 'Options:\n'
+ for key, item in options.items():
+ options_prompt += f'{key}. {item}\n'
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ prompt = ''
+ if hint is not None:
+ prompt += f'Hint: {hint}\n'
+ prompt += f'Question: {question}\n'
+ if len(options):
+ prompt += options_prompt
+ prompt += 'Please select the correct answer from the options above. \n'
+
+ msgs = []
+
+ msgs.append(dict(type='text', value=prompt))
+
+ return msgs
+
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.multiple_choice import report_acc, report_acc_MMT, mcq_circular_eval, mcq_vanilla_eval
+ # assert dataset is not None
+ dataset_map = {
+ 'MMBench_TEST_EN': 'MMBench', 'MMBench_TEST_EN_V11': 'MMBench_V11',
+ 'MMBench_TEST_CN': 'MMBench_CN', 'MMBench_TEST_CN_V11': 'MMBench_CN_V11'
+ }
+ dataset = self.dataset_name
+ if dataset in dataset_map:
+ dataset = dataset_map[dataset]
+ nproc = judge_kwargs.pop('nproc', 4)
+
+ circular = False
+
+ suffix = eval_file.split('.')[-1]
+ model = judge_kwargs.get('model', 'exact_matching')
+ assert model in ['chatgpt-0125', 'exact_matching', 'gpt-4-0125']
+ name_str_map = {'chatgpt-0125': 'openai', 'gpt-4-0125': 'gpt4'}
+ name_str = name_str_map[model] if model in name_str_map else model
+
+ if model == 'exact_matching':
+ model = None
+ elif gpt_key_set():
+ model = build_judge(**judge_kwargs)
+ if not model.working():
+ warnings.warn('OPENAI API is not working properly, will use exact matching for evaluation')
+ warnings.warn(DEBUG_MESSAGE)
+ model = None
+ else:
+ warnings.warn('OPENAI_API_KEY is not set properly, will use exact matching for evaluation')
+ model = None
+
+ result_file = eval_file.replace(f'.{suffix}', f'_{name_str}_result.pkl')
+
+ data = load(eval_file)
+ data = data.sort_values(by='index')
+ data['prediction'] = [str(x) for x in data['prediction']]
+ # If not choice label, then use lower case
+ for k in data.keys():
+ data[k.lower() if k not in list(string.ascii_uppercase) else k] = data.pop(k)
+
+ meta = self.data
+ meta_q_map = {x: y for x, y in zip(meta['index'], meta['question'])}
+ data_map = {x: y for x, y in zip(data['index'], data['question'])}
+ for k in data_map:
+ assert k in meta_q_map, (
+ f'eval_file should be the same as or a subset of dataset {self.dataset_name}'
+ )
+
+ if circular:
+ data = mcq_circular_eval(model, data, meta, nproc, result_file, self.dataset_name)
+ else:
+ data = mcq_vanilla_eval(model, data, meta, nproc, result_file, self.dataset_name)
+
+ # load split
+ dump(data, eval_file.replace(f'.{suffix}', f'_{name_str}_result.{suffix}'))
+ data = load(eval_file.replace(f'.{suffix}', f'_{name_str}_result.{suffix}'))
+
+ # May have different report acc functions for different datasets
+ if 'MMT' in dataset:
+ acc = report_acc_MMT(data)
+ else:
+ acc = report_acc(data)
+
+ score_file = eval_file.replace(f'.{suffix}', '_acc.csv')
+ dump(acc, score_file)
+
+ return acc
+
+
+class CustomTextMCQDataset(TextMCQDataset):
+
+ def load_data(self, dataset):
+ data_path = osp.join(LMUDataRoot(), f'{dataset}.tsv')
+
+ if file_size(data_path, 'GB') > 1:
+ local_path = data_path.replace('.tsv', '_local.tsv')
+ if not osp.exists(local_path) or os.environ.get('FORCE_LOCAL', None):
+ from ..tools import LOCALIZE
+ LOCALIZE(data_path, local_path)
+ data_path = local_path
+ return load(data_path)
diff --git a/vlmeval/dataset/utils/__init__.py b/vlmeval/dataset/utils/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..11e5af6d24ea12176227304baab40711e3c83f1d
--- /dev/null
+++ b/vlmeval/dataset/utils/__init__.py
@@ -0,0 +1,9 @@
+from .judge_util import build_judge, DEBUG_MESSAGE
+from .multiple_choice import extract_answer_from_item, prefetch_answer
+from .vqa_eval import levenshtein_distance
+from .reasoning import extract_answer
+
+__all__ = [
+ 'build_judge', 'extract_answer_from_item', 'prefetch_answer',
+ 'levenshtein_distance', 'DEBUG_MESSAGE', 'extract_answer',
+]
diff --git a/vlmeval/dataset/utils/ccocr_evaluator/README.md b/vlmeval/dataset/utils/ccocr_evaluator/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..f018a24da460e323497e5dbf1cda3a38d698d568
--- /dev/null
+++ b/vlmeval/dataset/utils/ccocr_evaluator/README.md
@@ -0,0 +1,59 @@
+# CC-OCR: A Comprehensive and Challenging OCR Benchmark for Evaluating Large Multimodal Models in Literacy
+
+## Introduction
+
+Please refer to our [GitHub](https://github.com/AlibabaResearch/AdvancedLiterateMachinery/tree/main/Benchmarks/CC-OCR) for more information.
+
+## Running Scripts
+
+Once the environment is ready, execute the following script from the root directory of VLMEvalKit
+to perform inference and evaluation tasks in batch.
+
+```shell
+MODEL_NAME="QwenVLMax"
+OUTPUT_DIR="/your/path/to/output_dir"
+
+SUB_OUTPUT_DIR=${OUTPUT_DIR}/multi_scene_ocr
+python run.py --data CCOCR_MultiSceneOcr_Cord CCOCR_MultiSceneOcr_Funsd CCOCR_MultiSceneOcr_Iam CCOCR_MultiSceneOcr_ZhDoc CCOCR_MultiSceneOcr_ZhHandwriting CCOCR_MultiSceneOcr_Hieragent CCOCR_MultiSceneOcr_Ic15 CCOCR_MultiSceneOcr_Inversetext CCOCR_MultiSceneOcr_Totaltext CCOCR_MultiSceneOcr_ZhScene CCOCR_MultiSceneOcr_UgcLaion CCOCR_MultiSceneOcr_ZhDense CCOCR_MultiSceneOcr_ZhVertical --model ${MODEL_NAME} --work-dir ${SUB_OUTPUT_DIR} --verbose
+python vlmeval/dataset/utils/ccocr_evaluator/common.py ${SUB_OUTPUT_DIR}
+
+SUB_OUTPUT_DIR=${OUTPUT_DIR}/multi_lan_ocr
+python run.py --data CCOCR_MultiLanOcr_Arabic CCOCR_MultiLanOcr_French CCOCR_MultiLanOcr_German CCOCR_MultiLanOcr_Italian CCOCR_MultiLanOcr_Japanese CCOCR_MultiLanOcr_Korean CCOCR_MultiLanOcr_Portuguese CCOCR_MultiLanOcr_Russian CCOCR_MultiLanOcr_Spanish CCOCR_MultiLanOcr_Vietnamese --model ${MODEL_NAME} --work-dir ${SUB_OUTPUT_DIR} --verbose
+python vlmeval/dataset/utils/ccocr_evaluator/common.py ${SUB_OUTPUT_DIR}
+
+SUB_OUTPUT_DIR=${OUTPUT_DIR}/doc_parsing
+python run.py --data CCOCR_DocParsing_DocPhotoChn CCOCR_DocParsing_DocPhotoEng CCOCR_DocParsing_DocScanChn CCOCR_DocParsing_DocScanEng CCOCR_DocParsing_TablePhotoChn CCOCR_DocParsing_TablePhotoEng CCOCR_DocParsing_TableScanChn CCOCR_DocParsing_TableScanEng CCOCR_DocParsing_MolecularHandwriting CCOCR_DocParsing_FormulaHandwriting --model ${MODEL_NAME} --work-dir ${SUB_OUTPUT_DIR} --verbose
+python vlmeval/dataset/utils/ccocr_evaluator/common.py ${SUB_OUTPUT_DIR}
+
+SUB_OUTPUT_DIR=${OUTPUT_DIR}/kie
+python run.py --data CCOCR_Kie_Sroie2019Word CCOCR_Kie_Cord CCOCR_Kie_EphoieScut CCOCR_Kie_Poie CCOCR_Kie_ColdSibr CCOCR_Kie_ColdCell --model ${MODEL_NAME} --work-dir ${SUB_OUTPUT_DIR} --verbose
+python vlmeval/dataset/utils/ccocr_evaluator/common.py ${SUB_OUTPUT_DIR}
+```
+
+## Example Output
+The evaluation results will be saved in `${SUB_OUTPUT_DIR}/summary.md`. For example, for the KIE subset,
+the output is as follows:
+
+| exp_name(f1_score) | COLD_CELL | COLD_SIBR | CORD | EPHOIE_SCUT | POIE | sroie2019_word | summary |
+|:-------------------|------------:|------------:|-------:|--------------:|-------:|-----------------:|----------:|
+| QwenVLMax | 81.01 | 72.46 | 69.33 | 71.2 | 60.85 | 76.37 | 71.87 |
+
+
+## Citation
+If you find our work helpful, feel free to give us a cite.
+
+```
+@misc{yang2024ccocr,
+ title={CC-OCR: A Comprehensive and Challenging OCR Benchmark for Evaluating Large Multimodal Models in Literacy},
+ author={Zhibo Yang and Jun Tang and Zhaohai Li and Pengfei Wang and Jianqiang Wan and Humen Zhong and Xuejing Liu and Mingkun Yang and Peng Wang and Shuai Bai and LianWen Jin and Junyang Lin},
+ year={2024},
+ eprint={2412.02210},
+ archivePrefix={arXiv},
+ primaryClass={cs.CV},
+ url={https://arxiv.org/abs/2412.02210},
+}
+```
+
+## Contact Us
+
+If you have any questions, feel free to send an email to: wpf272043@alibaba-inc.com or xixing.tj@alibaba-inc.com
\ No newline at end of file
diff --git a/vlmeval/dataset/utils/ccocr_evaluator/__init__.py b/vlmeval/dataset/utils/ccocr_evaluator/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d89f6f6b78a7da3c82d38d2060a015175f0274f2
--- /dev/null
+++ b/vlmeval/dataset/utils/ccocr_evaluator/__init__.py
@@ -0,0 +1,12 @@
+from .kie_evaluator import KieEvaluator
+from .doc_parsing_evaluator import ParsingEvaluator
+from .ocr_evaluator import OcrEvaluator
+from .common import summary
+
+
+evaluator_map_info = {
+ "kie": KieEvaluator("kie"),
+ "doc_parsing": ParsingEvaluator("doc_parsing"),
+ "multi_lan_ocr": OcrEvaluator("multi_lan_ocr"),
+ "multi_scene_ocr": OcrEvaluator("multi_scene_ocr")
+}
diff --git a/vlmeval/dataset/utils/ccocr_evaluator/common.py b/vlmeval/dataset/utils/ccocr_evaluator/common.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ce9bcb550c4d22e24f3d92654603d06c92662f6
--- /dev/null
+++ b/vlmeval/dataset/utils/ccocr_evaluator/common.py
@@ -0,0 +1,222 @@
+import os
+import json
+import time
+import sys
+from abc import abstractmethod
+from tabulate import tabulate
+
+
+def pick_response_text(json_path):
+ """
+ """
+ try:
+ with open(json_path, "r") as f:
+ json_data = json.load(f)
+ except Exception as e:
+ print("--> file error: msg: {}, path: {}".format(e, json_path))
+ return None
+
+ for required_key in ["model_name", "response"]:
+ if required_key not in json_data:
+ print("--> required key not exists, name: {}, path: {}".format(required_key, json_path))
+ return None
+
+ model_name = json_data["model_name"]
+ model_response = json_data["response"]
+
+ response_text = None
+ if model_name.startswith("gpt") or model_name.startswith("o1"):
+ response_text = model_response.get("data", {}).get("response", {}).get("choices", [{}])[0].get("message", {}).get("content", None) # noqa: E501
+ elif model_name.startswith("local_"):
+ response_text = model_response
+ else:
+ if model_name.startswith("claude"):
+ content_list = model_response.get("content", None)
+ elif model_name.startswith("gemini"):
+ content_list = model_response.get("candidates", [{}])[0].get("content", {}).get("parts", None)
+ elif model_name.startswith("qwen"):
+ content_list = model_response.get("output", {}).get("choices", [{}])[0].get("message", {}).get("content", None) # noqa: E501
+ else:
+ raise NotImplementedError("The pick_response_text NOT implemented for model: {}".format(model_name))
+
+ if isinstance(content_list, list) and len(content_list) > 0:
+ response_text = content_list[0].get("text", None)
+
+ if response_text is None:
+ print("--> [error][{}] text pick error, path: {}".format(model_name, json_path))
+ return response_text
+
+
+def load_response_from_dir(res_dir):
+ """
+ """
+ response_info = {}
+ for file_name in os.listdir(res_dir):
+ file_path = os.path.abspath(os.path.join(res_dir, file_name))
+ if not file_name.endswith(".json"):
+ print("--> skip: result file should be a json: but got: {}".format(file_path))
+ continue
+
+ response_text = pick_response_text(file_path)
+ if response_text is None:
+ continue
+
+ file_name_wo_ext, ext = os.path.splitext(file_name)
+ response_info[file_name_wo_ext] = response_text
+ return response_info
+
+
+class BaseMetric(object):
+ """ BaseMetric """
+ """ OCRMetric """
+ def __init__(self, group_name, **kwargs):
+ self.group_name = group_name
+ self.kwargs = kwargs
+
+ def response_post_func(self, response_text, **kwargs):
+ return response_text
+
+ @abstractmethod
+ # Given the prediction and gt, return the evaluation results in the format of a dictionary
+ # results should contain a 'summary' key, for example:
+ # {
+ # "summary": {
+ # "f1-score": 99.99,
+ # "metric_name": "metric_value" # used for summary，only metric info could be placed in this dict.
+ # },
+ # "your other info": "xxx"
+ # }
+ def evaluate(self, response_info, gt_info, normalize_func=None, **kwargs):
+ pass
+
+ def __call__(self, pdt_res_dir, gt_info, with_response_ratio=True, **kwargs):
+ if isinstance(pdt_res_dir, dict):
+ raw_response_info = pdt_res_dir
+ elif os.path.exists(pdt_res_dir) and os.path.isdir(pdt_res_dir):
+ raw_response_info = load_response_from_dir(pdt_res_dir)
+ else:
+ return ValueError("invalid input: response dict or folder are required, but got {}".format(pdt_res_dir))
+
+ post_error_list, response_info = [], {}
+ response_error_list = list(gt_info.keys() - raw_response_info.keys())
+ for file_name, single_pdt_str in raw_response_info.items():
+ single_pdt_str = self.response_post_func(single_pdt_str, **kwargs)
+ if single_pdt_str is None:
+ post_error_list.append(file_name)
+ continue
+ response_info[file_name] = single_pdt_str
+
+ meta_info = {
+ "gt_total_num": len(gt_info), "pdt_total_num": len(response_info),
+ "post_error_list": post_error_list, "response_error_list": response_error_list,
+ }
+ eval_info = self.evaluate(response_info, gt_info, **kwargs)
+
+ # add response_success_ratio
+ if "summary" in eval_info and with_response_ratio:
+ success_ratio = (len(response_info) + len(post_error_list)) / (len(gt_info) + 1e-9)
+ eval_info["summary"].update({"response_success_ratio": success_ratio})
+ return meta_info, eval_info
+
+
+def summary(index_path, exp_dir_base, is_weighted_sum=False):
+ """
+ """
+ with open(index_path, "r") as f:
+ data_list = json.load(f)
+
+ all_data_info = {}
+ for data_info_item in data_list:
+ data_name = data_info_item["dataset"]
+ if not data_info_item.get("release", True):
+ continue
+ all_data_info[data_name] = data_info_item
+ dataset_list = list(all_data_info.keys())
+ summary_path = summary_multi_exp(exp_dir_base, dataset_list, is_weighted_sum=is_weighted_sum)
+ return summary_path
+
+
+def summary_multi_exp(exp_dir_base, dataset_list=None, is_weighted_sum=False):
+ """
+ """
+ if dataset_list is None:
+ all_dataset_name = []
+ for exp_name in os.listdir(exp_dir_base):
+ dir_status_path = os.path.join(exp_dir_base, exp_name, "status.json")
+ if not os.path.exists(dir_status_path):
+ continue
+ with open(dir_status_path, "r") as f:
+ data_status_info = json.load(f)
+ all_dataset_name.extend(data_status_info.keys())
+ dataset_list = sorted(set(all_dataset_name))
+
+ # summary main code
+ all_evaluate_info, _ = {}, 0
+ for exp_name in os.listdir(exp_dir_base):
+ dir_status_path = os.path.join(exp_dir_base, exp_name, "status.json")
+ if not os.path.exists(dir_status_path):
+ print("--> skip: status.json not exist: {}".format(dir_status_path))
+ continue
+
+ with open(dir_status_path, "r") as f:
+ all_status_info = json.load(f)
+
+ for data_name in dataset_list:
+ total_num = all_status_info.get(data_name, {}).get("config", {}).get("num", "-1")
+ summary_info = all_status_info.get(data_name, {}).get("evaluation", {}).get("summary", {})
+ for metric_name, metric_value in summary_info.items():
+ if metric_name not in all_evaluate_info:
+ all_evaluate_info[metric_name] = {}
+ if exp_name not in all_evaluate_info[metric_name]:
+ all_evaluate_info[metric_name][exp_name] = {}
+ all_evaluate_info[metric_name][exp_name][data_name] = (metric_value, total_num)
+
+ all_table_md = []
+ for metric_name, metric_info in all_evaluate_info.items():
+ formatted_time = time.strftime("%Y-%m-%d %H:%M", time.localtime(time.time()))
+ summary_line_list = []
+ summary_key_name = "summary(weighted)" if is_weighted_sum else "summary"
+ summary_head = [f"exp_name({metric_name}_{formatted_time})"] + dataset_list + [summary_key_name]
+ for exp_name, data_eval_info in metric_info.items():
+ summary_line = [exp_name, ]
+
+ all_metric_value = 0
+ is_summary_valid, all_total_num, all_weighted_metric = True, 0, 0
+ for data_name in dataset_list:
+ metric_value, total_num = data_eval_info.get(data_name, ("-1", "-1"))
+ summary_line.append("{:.2f}".format(float(metric_value) * 100))
+ if str(metric_value) == "-1" or str(metric_value) == "-1":
+ is_summary_valid = False
+ continue
+
+ all_total_num += float(total_num)
+ all_weighted_metric += float(total_num) * float(metric_value)
+ all_metric_value += float(metric_value)
+
+ summary_value_valid = ((all_weighted_metric / (all_total_num + 1e-9)) * 100) if is_weighted_sum \
+ else (all_metric_value / (len(dataset_list) + 1e-9) * 100)
+ summary_value = "-" if not is_summary_valid else "{:.2f}".format(summary_value_valid)
+ summary_line.append(summary_value)
+ summary_line_list.append(summary_line)
+
+ md_table_info = tabulate(summary_line_list, headers=summary_head, tablefmt='pipe')
+ all_table_md.append(md_table_info)
+
+ print("\n\n".join(all_table_md))
+ summary_path = os.path.abspath(os.path.join(exp_dir_base, "summary.md"))
+ with open(summary_path, "w") as f:
+ f.write("\n\n".join(all_table_md))
+ return summary_path
+
+
+if __name__ == '__main__':
+ if len(sys.argv) != 2:
+ print("Usage: python {} exp_base_dir".format(__file__))
+ exit(-1)
+ else:
+ print('--> info: {}'.format(sys.argv))
+ exp_base_dir = sys.argv[1]
+
+ summary_path = summary_multi_exp(exp_base_dir, dataset_list=None, is_weighted_sum=False)
+ print("--> info: summary saved at : {}".format(summary_path))
+ print("happy coding.")
diff --git a/vlmeval/dataset/utils/ccocr_evaluator/doc_parsing_evaluator.py b/vlmeval/dataset/utils/ccocr_evaluator/doc_parsing_evaluator.py
new file mode 100644
index 0000000000000000000000000000000000000000..d059adc0935e1b5c3370ea6fd1c21df3fd9bffc2
--- /dev/null
+++ b/vlmeval/dataset/utils/ccocr_evaluator/doc_parsing_evaluator.py
@@ -0,0 +1,256 @@
+import nltk
+import re
+from tqdm import tqdm
+from collections import deque
+from apted.helpers import Tree
+from apted import APTED, Config
+
+# local import
+from .common import BaseMetric
+
+
+# 移除指定的LaTeX命令
+patterns = [
+ r'\\documentclass\{.*?\}',
+ r'\\usepackage\[.*?\]\{.*?\}',
+ r'\\usepackage\{.*?\}',
+ r'\\geometry\{.*?\}',
+ r'\\begin\{document\}',
+ r'\\end\{document\}',
+ r'\\noindent'
+]
+
+
+class TableTree(Tree):
+ """
+ # Copyright 2020 IBM
+ # Author: peter.zhong@au1.ibm.com
+ # License: Apache 2.0 License.
+ """
+ def __init__(self, tag, colspan=None, rowspan=None, content=None, *children):
+ self.tag = tag
+ self.colspan = colspan
+ self.rowspan = rowspan
+ self.content = content
+ self.children = list(children)
+
+ def bracket(self):
+ """Show tree using brackets notation"""
+ if self.tag == "td":
+ result = '"tag": %s, "colspan": %d, "rowspan": %d, "text": %s' % (
+ self.tag,
+ self.colspan,
+ self.rowspan,
+ self.content,
+ )
+ else:
+ result = '"tag": %s' % self.tag
+ for child in self.children:
+ result += child.bracket()
+ return "{{{}}}".format(result)
+
+
+class CustomConfig(Config):
+ """
+ # Copyright 2020 IBM
+ # Author: peter.zhong@au1.ibm.com
+ # License: Apache 2.0 License.
+ """
+ def rename(self, node1, node2):
+ """Compares attributes of trees"""
+ # print(node1.tag)
+ if (
+ (node1.tag != node2.tag)
+ or (node1.colspan != node2.colspan)
+ or (node1.rowspan != node2.rowspan)
+ ):
+ return 1.0
+ if node1.tag == "td":
+ if node1.content or node2.content:
+ return nltk.edit_distance(node1.content, node2.content) / max(len(node1.content), len(node2.content))
+ return 0.0
+
+
+class TEDS(object):
+ """Tree Edit Distance basead Similarity
+ # Copyright 2020 IBM
+ # Author: peter.zhong@au1.ibm.com
+ # License: Apache 2.0 License.
+ """
+ def __init__(self, structure_only=False, n_jobs=1, ignore_nodes=None):
+ assert isinstance(n_jobs, int) and (
+ n_jobs >= 1
+ ), "n_jobs must be an integer greather than 1"
+ self.structure_only = structure_only
+ self.n_jobs = n_jobs
+ self.ignore_nodes = ignore_nodes
+ self.__tokens__ = []
+
+ def tokenize(self, node):
+ """Tokenizes table cells"""
+ self.__tokens__.append("<%s>" % node.tag)
+ if node.text is not None:
+ self.__tokens__ += list(node.text)
+ for n in node.getchildren():
+ self.tokenize(n)
+ if node.tag != "unk":
+ self.__tokens__.append("" % node.tag)
+ if node.tag != "td" and node.tail is not None:
+ self.__tokens__ += list(node.tail)
+
+ def load_html_tree(self, node, parent=None):
+ """Converts HTML tree to the format required by apted"""
+ global __tokens__
+ if node.tag == "td":
+ if self.structure_only:
+ cell = []
+ else:
+ self.__tokens__ = []
+ self.tokenize(node)
+ cell = self.__tokens__[1:-1].copy()
+ new_node = TableTree(
+ node.tag,
+ int(node.attrib.get("colspan", "1")),
+ int(node.attrib.get("rowspan", "1")),
+ cell,
+ *deque(),
+ )
+ else:
+ new_node = TableTree(node.tag, None, None, None, *deque())
+ if parent is not None:
+ parent.children.append(new_node)
+ if node.tag != "td":
+ for n in node.getchildren():
+ self.load_html_tree(n, new_node)
+ if parent is None:
+ return new_node
+
+ def evaluate(self, pred, true):
+ """Computes TEDS score between the prediction and the ground truth of a
+ given sample
+ """
+ # try_import("lxml")
+ from lxml import etree, html
+ if (not pred) or (not true):
+ return 0.0
+
+ parser = html.HTMLParser(remove_comments=True, encoding="utf-8")
+ pred = html.fromstring(pred, parser=parser)
+ true = html.fromstring(true, parser=parser)
+ if pred.xpath("body/table") and true.xpath("body/table"):
+ pred = pred.xpath("body/table")[0]
+ true = true.xpath("body/table")[0]
+ if self.ignore_nodes:
+ etree.strip_tags(pred, *self.ignore_nodes)
+ etree.strip_tags(true, *self.ignore_nodes)
+ n_nodes_pred = len(pred.xpath(".//*"))
+ n_nodes_true = len(true.xpath(".//*"))
+ n_nodes = max(n_nodes_pred, n_nodes_true)
+ tree_pred = self.load_html_tree(pred)
+ tree_true = self.load_html_tree(true)
+ distance = APTED(
+ tree_pred, tree_true, CustomConfig()
+ ).compute_edit_distance()
+ return 1.0 - (float(distance) / n_nodes)
+ else:
+ return 0.0
+
+
+class ParsingEvaluator(BaseMetric):
+ def response_post_func(self, response_text, **kwargs):
+ return response_text
+
+ def evaluate(self, response_info, gt_info, **kwargs):
+ op = kwargs['op']
+ if op == 'doc':
+ score = self.eval_doc(response_info, gt_info)
+ elif op == 'table':
+ score = self.eval_table(response_info, gt_info)
+ elif op in ['molecular', "formula"]:
+ score = self.eval_formula(response_info, gt_info, op_name=op)
+ else:
+ raise ValueError(f'doc parsing unsupported op: {op}')
+
+ # summary info
+ eval_info = {"summary": {"score": score}}
+ return eval_info
+
+ def eval_doc(self, response_info, gt_info):
+ results = []
+ for img_name, gt in tqdm(gt_info.items()):
+ if img_name not in response_info:
+ results.append(0)
+ continue
+
+ pred = response_info[img_name]
+ for pattern in patterns:
+ pred = re.sub(pattern, '', pred)
+
+ try:
+ pred = pred.split('```')[1]
+ except:
+ pass
+
+ pred = pred.replace('```latex', '')
+ pred = pred.replace('```', '')
+
+ pred = pred.replace(' ', '').replace('\n', '')
+ gt = gt.replace(' ', '').replace('\n', '')
+
+ edit_dist = nltk.edit_distance(pred, gt) / max(len(pred), len(gt))
+ results.append(1 - edit_dist)
+
+ score = sum(results) / len(results)
+ return score
+
+ def eval_table(self, response_info, gt_info):
+ teds = TEDS(structure_only=False, n_jobs=1)
+ results = []
+ for img_name, gt in tqdm(gt_info.items()):
+ if img_name not in response_info:
+ results.append(0)
+ continue
+
+ pred = response_info[img_name]
+ for pattern in patterns:
+ pred = re.sub(pattern, '', pred)
+
+ try:
+ pred = pred.split('```html')[1]
+ except:
+ pass
+
+ pred = pred.replace('```', '')
+ pred = pred.replace(' ', '').replace('\n', '').replace('，', ',')
+ gt = gt.replace(' ', '').replace('\n', '')
+
+ pred_html = '{}'.format(pred)
+ gt_html = '{}'.format(gt)
+ results.append(teds.evaluate(pred_html, gt_html))
+
+ score = sum(results) / len(results)
+ return score
+
+ def eval_formula(self, response_info, gt_info, op_name='formula'):
+ results = []
+ for img_name, gt in tqdm(gt_info.items()):
+ if img_name not in response_info:
+ results.append(0)
+ continue
+
+ pred = response_info[img_name]
+
+ if op_name == 'formula':
+ pred = pred.replace("\n", " ").replace("```latex", "").replace("```", "").replace("\t", " ").replace(" ", "") # noqa: E501
+ gt = gt.replace(" ", "")
+ elif op_name == 'molecular':
+ pred = pred.replace("\n", "").replace(" ", "").replace("", "").replace(" ", "")
+ gt = gt.replace(" ", "")
+ edit_dist = nltk.edit_distance(pred, gt) / max(len(pred), len(gt))
+ results.append(1 - edit_dist)
+ score = sum(results) / len(results)
+ return score
+
+
+if __name__ == '__main__':
+ pass
diff --git a/vlmeval/dataset/utils/ccocr_evaluator/kie_evaluator.py b/vlmeval/dataset/utils/ccocr_evaluator/kie_evaluator.py
new file mode 100644
index 0000000000000000000000000000000000000000..797d4244608d44252d24e6b6aea742ba8c768da6
--- /dev/null
+++ b/vlmeval/dataset/utils/ccocr_evaluator/kie_evaluator.py
@@ -0,0 +1,385 @@
+
+"""
+Donut
+Copyright (c) 2022-present NAVER Corp.
+MIT License
+"""
+import json
+import os
+import sys
+import re
+import time
+from typing import Any, Dict, List, Tuple, Union
+
+import zss
+from zss import Node
+from collections import Counter
+from nltk import edit_distance
+
+# local import
+from .common import BaseMetric
+
+
+def flatten(data: dict):
+ """
+ Convert Dictionary into Non-nested Dictionary
+ Example:
+ input(dict)
+ {
+ "menu": [
+ {"name" : ["cake"], "count" : ["2"]},
+ {"name" : ["juice"], "count" : ["1"]},
+ ]
+ }
+ output(list)
+ [
+ ("menu.name", "cake"),
+ ("menu.count", "2"),
+ ("menu.name", "juice"),
+ ("menu.count", "1"),
+ ]
+ """
+ flatten_data = list()
+
+ def _flatten(value, key=""):
+ if type(value) is dict:
+ for child_key, child_value in value.items():
+ _flatten(child_value, f"{key}.{child_key}" if key else child_key)
+ elif type(value) is list:
+ for value_item in value:
+ _flatten(value_item, key)
+ else:
+ flatten_data.append((key, value))
+
+ _flatten(data)
+ return flatten_data
+
+
+def update_cost(node1: Node, node2: Node):
+ """
+ Update cost for tree edit distance.
+ If both are leaf node, calculate string edit distance between two labels (special token '' will be ignored).
+ If one of them is leaf node, cost is length of string in leaf node + 1.
+ If neither are leaf node, cost is 0 if label1 is same with label2 othewise 1
+ """
+ label1 = node1.label
+ label2 = node2.label
+ label1_leaf = "" in label1
+ label2_leaf = "" in label2
+ if label1_leaf and label2_leaf:
+ return edit_distance(label1.replace("", ""), label2.replace("", ""))
+ elif not label1_leaf and label2_leaf:
+ return 1 + len(label2.replace("", ""))
+ elif label1_leaf and not label2_leaf:
+ return 1 + len(label1.replace("", ""))
+ else:
+ return int(label1 != label2)
+
+
+def insert_and_remove_cost(node: Node):
+ """
+ Insert and remove cost for tree edit distance.
+ If leaf node, cost is length of label name.
+ Otherwise, 1
+ """
+ label = node.label
+ if "" in label:
+ return len(label.replace("", ""))
+ else:
+ return 1
+
+
+def normalize_dict(data: Union[Dict, List, Any]):
+ """
+ Sort by value, while iterate over element if data is list
+ """
+ # if not data:
+ # return {}
+
+ if isinstance(data, dict):
+ new_data = dict()
+ for key in sorted(data.keys(), key=lambda k: (len(k), k)):
+ value = normalize_dict(data[key])
+ if value:
+ if not isinstance(value, list):
+ value = [value]
+ new_data[key] = value
+
+ elif isinstance(data, list):
+ if all(isinstance(item, dict) for item in data):
+ new_data = []
+ for item in data:
+ item = normalize_dict(item)
+ if item:
+ new_data.append(item)
+ else:
+ new_data = [str(item).strip() for item in data if type(item) in {str, int, float} and str(item).strip()]
+ else:
+ new_data = [str(data).strip()]
+ return new_data
+
+
+def cal_f1_all(preds, answers):
+ """
+ Calculate global F1 accuracy score (field-level, micro-averaged) by counting all true positives,
+ false negatives and false positives
+ """
+ metric_info, error_info = {}, {}
+ total_tp, total_fn_or_fp = 0, 0
+ for file_name, answer in answers.items():
+ sample_error_info = {"fp": [], "fn": [], "tp": []}
+ pred = preds.get(file_name, {})
+ pred, answer = flatten(normalize_dict(pred)), flatten(normalize_dict(answer))
+ for field in pred:
+ field_name = field[0]
+ if field_name not in metric_info:
+ metric_info[field_name] = {"total_tp": 0, "total_fn_or_fp": 0}
+ if field in answer:
+ total_tp += 1
+ metric_info[field_name]["total_tp"] += 1
+ sample_error_info["tp"].append(field)
+ answer.remove(field)
+ else:
+ total_fn_or_fp += 1
+ metric_info[field_name]["total_fn_or_fp"] += 1
+ sample_error_info["fp"].append(field)
+
+ total_fn_or_fp += len(answer)
+ for field in answer:
+ field_name = field[0]
+ if field_name not in metric_info:
+ metric_info[field_name] = {"total_tp": 0, "total_fn_or_fp": 0}
+ metric_info[field_name]["total_fn_or_fp"] += 1
+ sample_error_info["fn"].append(field)
+
+ sample_error_num = sum([len(v) for k, v in sample_error_info.items() if k != "tp"])
+ if sample_error_num > 0:
+ sample_error_info["error_num"] = sample_error_num
+ error_class_list = ["counter_" + x[0] for x in (sample_error_info["fn"] + sample_error_info["fp"])]
+ counter = Counter(error_class_list)
+ sample_error_info["error_info"] = dict(counter)
+ error_info[file_name] = sample_error_info
+
+ # summary
+ for field_name, field_info in metric_info.items():
+ field_tp, field_fn_or_fp = field_info["total_tp"], field_info["total_fn_or_fp"]
+ metric_info[field_name]["acc"] = field_tp / (field_tp + field_fn_or_fp / 2 + 1e-6)
+
+ print("donut_evaluator: total_tp: {}, total_fn_or_fp: {}, ptd_num: {}, gt_num: {}".format(total_tp, total_fn_or_fp,
+ len(preds), len(answers)))
+ error_info = {k: v for k, v in
+ sorted(error_info.items(), key=lambda item: item[1].get("error_num", 0), reverse=True)}
+ metric_info = {k: v for k, v in
+ sorted(metric_info.items(), key=lambda item: item[1].get("total_fn_or_fp", 0), reverse=True)}
+ return total_tp / (total_tp + total_fn_or_fp / 2 + 1e-6), metric_info, error_info
+
+
+def construct_tree_from_dict(data: Union[Dict, List], node_name: str = None):
+ """
+ Convert Dictionary into Tree
+
+ Example:
+ input(dict)
+
+ {
+ "menu": [
+ {"name" : ["cake"], "count" : ["2"]},
+ {"name" : ["juice"], "count" : ["1"]},
+ ]
+ }
+
+ output(tree)
+
+ |
+ menu
+ / \
+
+ / | | \
+ name count name count
+ / | | \
+ cake 2 juice 1
+ """
+ if node_name is None:
+ node_name = ""
+
+ node = Node(node_name)
+
+ if isinstance(data, dict):
+ for key, value in data.items():
+ kid_node = construct_tree_from_dict(value, key)
+ node.addkid(kid_node)
+ elif isinstance(data, list):
+ if all(isinstance(item, dict) for item in data):
+ for item in data:
+ kid_node = construct_tree_from_dict(
+ item,
+ "",
+ )
+ node.addkid(kid_node)
+ else:
+ for item in data:
+ node.addkid(Node(f"{item}"))
+ else:
+ raise Exception(data, node_name)
+ return node
+
+
+def cal_acc(pred: dict, answer: dict):
+ """
+ Calculate normalized tree edit distance(nTED) based accuracy.
+ 1) Construct tree from dict,
+ 2) Get tree distance with insert/remove/update cost,
+ 3) Divide distance with GT tree size (i.e., nTED),
+ 4) Calculate nTED based accuracy. (= max(1 - nTED, 0 ).
+ """
+ pred = construct_tree_from_dict(normalize_dict(pred))
+ answer = construct_tree_from_dict(normalize_dict(answer))
+ val1 = zss.distance(
+ pred,
+ answer,
+ get_children=zss.Node.get_children,
+ insert_cost=insert_and_remove_cost,
+ remove_cost=insert_and_remove_cost,
+ update_cost=update_cost,
+ return_operations=False,
+ )
+ val2 = zss.distance(
+ construct_tree_from_dict(normalize_dict({})),
+ answer,
+ get_children=zss.Node.get_children,
+ insert_cost=insert_and_remove_cost,
+ remove_cost=insert_and_remove_cost,
+ update_cost=update_cost,
+ return_operations=False,
+ )
+ return max(0, 1 - val1 / val2)
+
+
+def cal_acc_all(pred_info, answer_info):
+ acc_info, error_info = {}, {}
+ for file_name, answer in answer_info.items():
+ # if file_name not in pred_info:
+ # print("---> error: pdt not found: {}".format(file_name))
+ # continue
+ pred = pred_info.get(file_name, {})
+ acc = cal_acc(pred, answer)
+ acc_info[file_name] = acc
+ if acc < 1.0:
+ error_info[file_name] = {"acc": acc, "pred": pred, "answer": answer}
+
+ error_info = {k: v for k, v in sorted(error_info.items(), key=lambda item: item[1].get("acc", 0))}
+ acc_averge = sum(list(acc_info.values())) / (len(acc_info) + 1e-6)
+ return acc_averge, error_info
+
+
+def normalize_values_of_nested_dict(d, normalize_func):
+ """
+ """
+ if isinstance(d, dict):
+ return {k: normalize_values_of_nested_dict(v, normalize_func) for k, v in d.items()}
+ elif isinstance(d, list):
+ return [normalize_values_of_nested_dict(x, normalize_func) if isinstance(x, dict) else x for x in d]
+ elif isinstance(d, str):
+ return normalize_func(d)
+ else:
+ return d
+
+
+def eval_donut(pdt_info, gt_info, normalize_func=None, data_name=None):
+ """
+ """
+ if normalize_func is not None:
+ print("--> info: normalize_func executed.")
+ pdt_info = normalize_values_of_nested_dict(pdt_info, normalize_func)
+ gt_info = normalize_values_of_nested_dict(gt_info, normalize_func)
+
+ f1_score, class_eval_info, error_info = cal_f1_all(pdt_info, gt_info)
+ acc_average, acc_error_info = cal_acc_all(pdt_info, gt_info)
+ eval_info = {"f1_score": f1_score, "acc": acc_average, "class_f1_score": class_eval_info,
+ "f1_error_info": error_info, "acc_error_info": acc_error_info}
+ print(data_name, "f1_score", f1_score, "acc", acc_average)
+ return eval_info
+
+
+def post_process_to_json(qwen_info_str, file_name=None):
+ try:
+ if "```json" in qwen_info_str:
+ if "```" not in qwen_info_str:
+ qwen_info_str += "```"
+ qwen_info_group = re.search(r'```json(.*?)```', qwen_info_str, re.DOTALL)
+ json_str = qwen_info_group.group(1).strip().replace("\n", "")
+ else:
+ json_str = qwen_info_str.strip().replace("\n", "")
+ json_data = json.loads(json_str)
+ return json_data
+ except Exception as err: # noqa: F841
+ return None
+
+
+def fullwidth_to_halfwidth(text):
+ # 全角转半角
+ result = ''
+ for char in text:
+ code_point = ord(char)
+ # 全角空格直接转化
+ if code_point == 0x3000:
+ code_point = 0x0020
+ # 其他全角字符（除空格）转换为半角
+ elif 0xFF01 <= code_point <= 0xFF5E:
+ code_point -= 0xFEE0
+ result += chr(code_point)
+ result = result.replace("、", ",")
+ return result
+
+
+def remove_unnecessary_spaces(text):
+ # 去掉中文字符之间的空格
+ text = re.sub(r'(?<=[\u4e00-\u9fff])\s+(?=[\u4e00-\u9fff])', '', text)
+ # 去掉中文和英文、数字之间的空格
+ text = re.sub(r'(?<=[\u4e00-\u9fff])\s+(?=[a-zA-Z0-9])', '', text)
+ text = re.sub(r'(?<=[a-zA-Z0-9])\s+(?=[\u4e00-\u9fff])', '', text)
+ # 去掉符号前的不必要空格，保留符号后的一个空格
+ text = re.sub(r'(? 0]
+ return text_token_normalized
+
+
+def evaluate_single_sample(gts, preds):
+ right_num = 0
+ gt_counter_info = dict(Counter(gts))
+ pdt_counter_info = dict(Counter(preds))
+ for gt_token, gt_count in gt_counter_info.items():
+ pred_count = pdt_counter_info.get(gt_token, 0)
+ right_num += min(gt_count, pred_count)
+ return right_num
+
+
+def calculate_metrics(response_info, gt_info, is_verbose=False):
+ """
+ """
+ macro_recall_list, macro_precision_list, macro_f1_list = [], [], []
+ total_gt_num, total_pred_num, total_right_num = 0, 0, 0
+ for file_name, fullbox_gts in gt_info.items():
+ fullbox_preds = response_info.get(file_name, [])
+ right_num = evaluate_single_sample(fullbox_gts, fullbox_preds)
+ total_right_num += right_num
+ total_gt_num += len(fullbox_gts)
+ total_pred_num += len(fullbox_preds)
+
+ macro_recall = right_num / (len(fullbox_gts) + 1e-9)
+ macro_precision = right_num / (len(fullbox_preds) + 1e-9)
+ macro_f1 = 2 * macro_recall * macro_precision / (macro_recall + macro_precision + 1e-9)
+ macro_recall_list.append(macro_recall)
+ macro_precision_list.append(macro_precision)
+ macro_f1_list.append(macro_f1)
+
+ # marco
+ final_macro_recall = sum(macro_recall_list) / (len(macro_recall_list) + 1e-9)
+ final_macro_precision = sum(macro_precision_list) / (len(macro_precision_list) + 1e-9)
+ final_macro_f1 = sum(macro_f1_list) / (len(macro_f1_list) + 1e-9)
+
+ # micro
+ recall_acc = total_right_num / (total_gt_num + 1e-9)
+ preci_acc = total_right_num / (total_pred_num + 1e-9)
+ hmean = 2 * recall_acc * preci_acc / (recall_acc + preci_acc + 1e-9)
+ vbs_eval_result = {
+ 'macro_recall': final_macro_recall, 'macro_precision': final_macro_precision, 'macro_f1_score': final_macro_f1,
+ 'micro_recall': recall_acc, 'micro_precision': preci_acc, 'mirco_f1_score': hmean
+ }
+ eval_result = vbs_eval_result if is_verbose else {'macro_f1_score': final_macro_f1, 'mirco_f1_score': hmean}
+ return eval_result
+
+
+class OcrEvaluator(BaseMetric):
+ def response_post_func(self, response_text, **kwargs):
+ return response_text
+
+ def evaluate(self, response_info, gt_info, **kwargs):
+ # hard code here
+ dataset_name = kwargs['dataset']
+ is_word_level, is_lower, is_alphanum_only = True, True, False
+ if dataset_name in ["Arabic", "Japanese", "Korean"] or "zh" in dataset_name:
+ is_word_level = False
+ if "multi_scene_ocr" in self.group_name and is_word_level:
+ is_alphanum_only = True
+ eval_config = {"word_level": is_word_level, "alphanum_only": is_alphanum_only, "lowercase": is_lower}
+
+ image_pdt_info, image_gt_info = {}, {}
+ for file_name, gt_src in gt_info.items():
+ pred_src = response_info.get(file_name, "")
+ pdt_token_list = text_normalize_and_tokenize(
+ str(pred_src).strip(), is_word_level, is_lower, is_alphanum_only)
+ gt_token_list = text_normalize_and_tokenize(
+ str(gt_src).strip(), is_word_level, is_lower, is_alphanum_only)
+ image_pdt_info[file_name] = pdt_token_list
+ image_gt_info[file_name] = gt_token_list
+ eval_result = calculate_metrics(image_pdt_info, image_gt_info, is_verbose=False)
+ return {"summary": eval_result, "metric_config": eval_config}
+
+
+if __name__ == '__main__':
+ pass
diff --git a/vlmeval/dataset/utils/cgbench.py b/vlmeval/dataset/utils/cgbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..eaf643bcc24a0f09812112f00a0a0741d43d710b
--- /dev/null
+++ b/vlmeval/dataset/utils/cgbench.py
@@ -0,0 +1,682 @@
+from ...smp import *
+from .multiple_choice import extract_answer_from_item
+import pandas as pd
+import numpy as np
+import re
+
+FAIL_MSG = "Failed to obtain answer via API."
+
+frame_tmpl = "frame-{}-of-{}.jpg"
+
+sys_prompt_open_eval_step_1 = (
+ "You will be provided with a question, a model's prediction, and the ground "
+ "truth answer for this question.\n"
+ "Your task is to judge whether the model's prediction is correct based on the "
+ "meaning of the two texts.\n"
+ "In most cases, this can be done by determining if the meaning of the model's "
+ "prediction is consistent with, or contains, the ground truth answer. However, "
+ "in some cases where the two texts differ, it may represent different "
+ "descriptions of the same visual scene, in which case visual information is "
+ "needed for further judgment.\n"
+ "Therefore, I hope you:\n"
+ "- Output 0, if the model's prediction and the ground truth answer are neither "
+ "consistent nor related by inclusion, with fundamentally different meanings.\n"
+ "- Output 1, if the meaning of the model's prediction and the ground truth "
+ "answer is consistent, or if the model's prediction meaningfully contains the "
+ "ground truth answer.\n"
+ "- Output 2, if the model's prediction and ground truth are not consistent or "
+ "inclusive, but may be different descriptions of the same visual scene, "
+ "requiring visual information for further judgment.\n"
+ "Only output the answer in the following format:\n\n"
+ '```json\n{"result": choice}\n```\n\n'
+ "The choice is either 0, 1, or 2 as specified above."
+)
+
+sys_prompt_open_eval_step_2 = (
+ "You will be provided with a question, a model's prediction, and the sampling "
+ "frames of the clue intervals related to this question.\n"
+ "Your task is to determine whether the model has answered the question "
+ "correctly based on the visual information provided.\n"
+ "Therefore, I hope you:\n"
+ "- Output 0, if the model's prediction does not correctly answer the question.\n"
+ "- Output 1, if the model's prediction correctly answers the question.\n"
+ "Only output the answer in the following format without output extra "
+ "explanation:\n\n"
+ '```json\n{"result": choice}\n```\n\n'
+ "The choice is either 0 or 1 as specified above."
+)
+
+FAIL_MSG = "Failed to obtain answer via API."
+
+# '10-20', '20-30', '30-40', '40-50', '50-60'
+DURATIONS = ["0 ~ 10", "10 ~ 20", "20 ~ 30", "30 ~ 40", "40 ~ 50", "50 ~ 60", "60+"]
+
+DOMAINS = [
+ "Life Record",
+ "Music & TV show",
+ "Instruction & Knowledge",
+ "Driving",
+ "Embodied Expert",
+ "Humor/funny",
+ "Electonic/Social Gaming",
+ "Security & Health",
+ "Sports & Exercise",
+ "Special Scenes",
+ "Art & Culture",
+ "GUI",
+ "News",
+ "Animal & Pet",
+]
+
+SUB_CATEGORIES = [
+ "Time Cognition",
+ "Hallucination",
+ "Entity Perception",
+ "2D Spatial Perception",
+ "Time Perception",
+ "Scene Perception",
+ "Text Perception",
+ "Event Cognition",
+ "Entity Cognition",
+ "Text Cognition",
+ "Event Perception",
+ "Scene Cognition",
+]
+
+
+def get_dimention_rating_open_ended(data_path):
+ # 读取数据
+ df = load(data_path)
+
+ df = df[df["score"] != -1]
+
+ # 将秒转换为分钟并分配到对应区间
+ df["duration_minutes"] = df["duration"] / 60
+ df["duration_range"] = pd.cut(
+ df["duration_minutes"], bins=[-np.inf, 10, 20, 30, 40, 50, 60, np.inf], labels=DURATIONS
+ )
+
+ # 初始化结果字典
+ result = {
+ "overall": 0,
+ "duration": {k: 0 for k in DURATIONS},
+ "domain": {k: 0 for k in DOMAINS},
+ "sub_category": {k: 0 for k in SUB_CATEGORIES},
+ }
+
+ # Overall
+ result["overall"] = round(df["score"].mean(), 4)
+
+ # Duration
+ for dur in DURATIONS:
+ dur_scores = df[df["duration_range"] == dur]["score"]
+ result["duration"][dur] = round(dur_scores.mean(), 4) if not dur_scores.empty else 0
+
+ # Domain
+ for domain in DOMAINS:
+ domain_scores = df[df["domain"] == domain]["score"]
+ result["domain"][domain] = round(domain_scores.mean(), 4) if not domain_scores.empty else 0
+
+ # Sub-category
+ for sub_cat in SUB_CATEGORIES:
+ sub_cat_scores = df[df["sub_category"] == sub_cat]["score"]
+ result["sub_category"][sub_cat] = round(sub_cat_scores.mean(), 4) if not sub_cat_scores.empty else 0
+
+ return result
+
+
+def get_dimention_rating_mcq_grouding(data_path):
+
+ # 读取数据
+ df = load(data_path)
+
+ # df.loc[(df['task_mode'] == 'miou') & (df['score'] == -1), 'score'] = 0
+
+ df = df[df["score"] != -1]
+
+ # 将秒转换为分钟并分配到对应区间
+ df["duration_minutes"] = df["duration"] / 60
+ df["duration_range"] = pd.cut(
+ df["duration_minutes"], bins=[-np.inf, 10, 20, 30, 40, 50, 60, np.inf], labels=DURATIONS
+ )
+
+ # 初始化结果字典
+ result = {
+ metric: {
+ "overall": 0,
+ "duration": {k: 0 for k in DURATIONS},
+ "domain": {k: 0 for k in DOMAINS},
+ "sub_category": {k: 0 for k in SUB_CATEGORIES},
+ }
+ for metric in ["long_acc", "clue_acc", "miou", "CRR", "acc@iou", "rec@iou"]
+ }
+
+ # 计算基础指标
+ for metric in ["long_acc", "clue_acc", "miou"]:
+ metric_df = df[df["task_mode"] == metric]
+
+ # Overall
+ result[metric]["overall"] = round(metric_df["score"].mean(), 4)
+
+ # Duration
+ for dur in DURATIONS:
+ dur_scores = metric_df[metric_df["duration_range"] == dur]["score"]
+ result[metric]["duration"][dur] = round(dur_scores.mean(), 4) if not dur_scores.empty else 0
+
+ # Domain
+ for domain in DOMAINS:
+ domain_scores = metric_df[metric_df["domain"] == domain]["score"]
+ result[metric]["domain"][domain] = round(domain_scores.mean(), 4) if not domain_scores.empty else 0
+
+ # Sub-category
+ for sub_cat in SUB_CATEGORIES:
+ sub_cat_scores = metric_df[metric_df["sub_category"] == sub_cat]["score"]
+ result[metric]["sub_category"][sub_cat] = round(sub_cat_scores.mean(), 4) if not sub_cat_scores.empty else 0
+
+ # 计算复合指标 CRR
+ def calculate_crr(scores):
+ long_acc = scores[scores["task_mode"] == "long_acc"]["score"].mean()
+ clue_acc = scores[scores["task_mode"] == "clue_acc"]["score"].mean()
+ return round(min(long_acc, clue_acc) / clue_acc, 4) if clue_acc != 0 else 0
+
+ # Overall CRR
+ result["CRR"]["overall"] = calculate_crr(df)
+
+ # Duration CRR
+ for dur in DURATIONS:
+ dur_df = df[df["duration_range"] == dur]
+ result["CRR"]["duration"][dur] = calculate_crr(dur_df)
+
+ # Domain CRR
+ for domain in DOMAINS:
+ domain_df = df[df["domain"] == domain]
+ result["CRR"]["domain"][domain] = calculate_crr(domain_df)
+
+ # Sub-category CRR
+ for sub_cat in SUB_CATEGORIES:
+ sub_cat_df = df[df["sub_category"] == sub_cat]
+ result["CRR"]["sub_category"][sub_cat] = calculate_crr(sub_cat_df)
+
+ # 计算 acc@iou
+ def calculate_acc_at_iou_threshold(scores, threshold):
+
+ miou_qids = set(scores[scores["task_mode"] == "miou"]["qid"])
+
+ long_acc_qids = set(scores[scores["task_mode"] == "long_acc"]["qid"])
+
+ valid_qids = miou_qids & long_acc_qids
+
+ miou_positive = set(scores[(scores["task_mode"] == "miou") & (scores["score"] > threshold)]["qid"])
+
+ long_acc_positive = scores[
+ (scores["task_mode"] == "long_acc") & (scores["qid"].isin(miou_positive)) & (scores["score"] == 1)
+ ]
+
+ acc_at_iou_threshold = len(long_acc_positive) / len(valid_qids) if len(valid_qids) > 0 else 0
+ return round(acc_at_iou_threshold, 4)
+
+ def calculate_acc_at_iou(scores):
+ thresholds = [0.1, 0.2, 0.3, 0.4, 0.5]
+ acc_at_iou_values = [calculate_acc_at_iou_threshold(scores, threshold) for threshold in thresholds]
+
+ return round(sum(acc_at_iou_values) / len(acc_at_iou_values), 4)
+
+ # Overall acc@iou
+ result["acc@iou"]["overall"] = calculate_acc_at_iou(df)
+
+ # Duration acc@iou
+ for dur in DURATIONS:
+ dur_df = df[df["duration_range"] == dur]
+ result["acc@iou"]["duration"][dur] = calculate_acc_at_iou(dur_df)
+
+ # Domain acc@iou
+ for domain in DOMAINS:
+ domain_df = df[df["domain"] == domain]
+ result["acc@iou"]["domain"][domain] = calculate_acc_at_iou(domain_df)
+
+ # Sub-category acc@iou
+ for sub_cat in SUB_CATEGORIES:
+ sub_cat_df = df[df["sub_category"] == sub_cat]
+ result["acc@iou"]["sub_category"][sub_cat] = calculate_acc_at_iou(sub_cat_df)
+
+ # 计算 rec@iou
+ def calculate_rec_at_iou_threshold(scores, threshold):
+ # 获取所有 miou 类型的数据
+ miou_scores = scores[scores["task_mode"] == "miou"]
+
+ # 计算 miou score 大于 threshold 的数量
+ miou_positive = miou_scores[miou_scores["score"] > threshold]
+
+ # 计算比例
+ rec_at_iou = len(miou_positive) / len(miou_scores) if len(miou_scores) > 0 else 0
+
+ return round(rec_at_iou, 4)
+
+ def calculate_rec_at_iou(scores):
+ thresholds = [0.1, 0.2, 0.3, 0.4, 0.5]
+ rec_at_iou_values = [calculate_rec_at_iou_threshold(scores, threshold) for threshold in thresholds]
+
+ return round(sum(rec_at_iou_values) / len(rec_at_iou_values), 4)
+
+ # Overall rec@iou
+ result["rec@iou"]["overall"] = calculate_rec_at_iou(df)
+
+ # Duration rec@iou
+ for dur in DURATIONS:
+ dur_df = df[df["duration_range"] == dur]
+ result["rec@iou"]["duration"][dur] = calculate_rec_at_iou(dur_df)
+
+ # Domain rec@iou
+ for domain in DOMAINS:
+ domain_df = df[df["domain"] == domain]
+ result["rec@iou"]["domain"][domain] = calculate_rec_at_iou(domain_df)
+
+ # Sub-category rec@iou
+ for sub_cat in SUB_CATEGORIES:
+ sub_cat_df = df[df["sub_category"] == sub_cat]
+ result["rec@iou"]["sub_category"][sub_cat] = calculate_rec_at_iou(sub_cat_df)
+
+ return result
+
+
+def milliseconds_to_seconds(milliseconds):
+ return milliseconds / 1000
+
+
+def sample_frames_clue_average(clues_time_intervals, frame_num, fps):
+ # 计算每个线索区间的时长
+ clues_frame_intervals = [(round(interval[0] * fps), round(interval[1] * fps)) for interval in clues_time_intervals]
+ clue_durations = [interval[1] - interval[0] for interval in clues_frame_intervals]
+ total_duration = sum(clue_durations)
+ # 如果 frame_num 的数量大于等于总帧数, 则直接返回全部帧
+ if frame_num >= total_duration:
+ return [frame for interval in clues_frame_intervals for frame in range(interval[0], interval[1])]
+ frames_per_clue = [int(frame_num * (duration / total_duration)) for duration in clue_durations]
+ frame_indices = []
+ for i, (interval, num_frames) in enumerate(zip(clues_frame_intervals, frames_per_clue)):
+ num_frames = max(1, num_frames)
+ seg_size = (interval[1] - interval[0]) / num_frames
+ clue_frame_indices = [int(interval[0] + seg_size / 2 + seg_size * idx) for idx in range(num_frames)]
+ frame_indices.extend(clue_frame_indices)
+ return frame_indices
+
+
+def merge_intervals(intervals):
+ """
+ Merge overlapping intervals in a list.
+ Assumes each interval is a list [start, end].
+ """
+ if not intervals:
+ return []
+
+ # Sort intervals by start time
+ intervals.sort(key=lambda x: x[0])
+
+ merged = [intervals[0]]
+
+ for current in intervals[1:]:
+ last_merged = merged[-1]
+
+ # Check if there is an overlap
+ if current[0] <= last_merged[1]:
+ # Merge the current interval with the last one
+ last_merged[1] = max(last_merged[1], current[1])
+ else:
+ # No overlap, add current interval
+ merged.append(current)
+
+ return merged
+
+
+def calculate_intervals_iou(intervals1, intervals2):
+ """
+ Calculate the IoU of two lists of intervals.
+ Each list contains intervals represented as [start, end].
+ """
+ # Merge overlapping intervals in both lists
+ merged1 = merge_intervals(intervals1)
+ merged2 = merge_intervals(intervals2)
+
+ # Calculate total length of intervals for both lists
+ def total_length(merged_intervals):
+ return sum(end - start for start, end in merged_intervals)
+
+ length1 = total_length(merged1)
+ length2 = total_length(merged2)
+
+ # Calculate intersection length
+ intersection_length = 0
+ for interval1 in merged1:
+ for interval2 in merged2:
+ intersection_start = max(interval1[0], interval2[0])
+ intersection_end = min(interval1[1], interval2[1])
+ intersection_length += max(0, intersection_end - intersection_start)
+ # Calculate union length
+ union_length = length1 + length2 - intersection_length
+ # IoU is intersection divided by union
+ iou = intersection_length / union_length if union_length > 0 else 0
+ return iou
+
+
+def post_process(response, right_answer, task_mode, duration):
+ result = -1
+
+ if response:
+ # 找到 ```json 和 ``` 的位置
+ json_start = response.find("```json")
+ json_end = response.find("```", json_start + len("```json"))
+
+ # 如果找到了 json 内容
+ if json_start != -1 and json_end != -1:
+ json_content = response[json_start + len("```json"):json_end].strip()
+ else:
+ json_content = ""
+
+ if json_content:
+ if task_mode in ["long_acc", "clue_acc"]:
+ json_content = re.sub(r"(?<=:\s)([A-Za-z_]\w*)", r'"\1"', json_content)
+
+ try:
+ model_result = json.loads(json_content)["result"]
+
+ if task_mode in ["long_acc", "clue_acc"]:
+ result = 1 if right_answer == model_result else 0
+ elif task_mode == "miou":
+ if not isinstance(model_result, list):
+ return -1
+ if not isinstance(model_result[0], list):
+ model_result = [model_result]
+
+ need_duration = all(interval[0] <= 1 and interval[1] <= 1 for interval in model_result)
+
+ if need_duration:
+ model_result = [[interval[0] * duration, interval[1] * duration] for interval in model_result]
+
+ right_answer = eval(right_answer)
+
+ result = calculate_intervals_iou(right_answer, model_result)
+
+ except Exception as e:
+ print(f"Error in parsing JSON: {e}, {json_content}")
+
+ if result == -1:
+ if task_mode in ["long_acc", "clue_acc"]:
+ # 检查是否存在大写字母 A-H，认为其为模型答案
+ matches = re.findall(r"\b[A-H]\b", response)
+ if matches:
+ result = 1 if right_answer in matches else 0
+ elif task_mode == "miou":
+ # 提取所有实数，进行配对
+ numbers = re.findall(r"-?\d+\.?\d*", response)
+ if len(numbers) < 2:
+ result = -1
+ else:
+ if len(numbers) % 2 != 0:
+ numbers = numbers[:-1]
+ model_result = [[float(numbers[i]), float(numbers[i + 1])] for i in range(0, len(numbers), 2)]
+
+ if type(right_answer) is str:
+ right_answer = eval(right_answer)
+
+ result = calculate_intervals_iou(right_answer, model_result)
+
+ return result
+
+
+def get_timestampes(frame_indices, fps):
+ seconds = list(map(lambda x: str(round(x / fps, 4)), frame_indices))
+ timestamps = ", ".join(seconds)
+ return "A total of {frame_num} frames are sampled. Their corresponding timestamps are:\n\n{timestamps}\n\n".format(
+ frame_num=len(frame_indices), timestamps=timestamps
+ )
+
+
+def post_process_open(response):
+ model_result = -1
+
+ if response and response != FAIL_MSG:
+ json_start = response.find("```json")
+ json_end = response.find("```", json_start + len("```json"))
+
+ # 如果找到了 json 内容
+ if json_start != -1 and json_end != -1:
+ json_content = response[json_start + len("```json"):json_end].strip()
+ else:
+ json_content = ""
+
+ if json_content:
+ try:
+ model_result = json.loads(json_content)["result"]
+ except Exception as e:
+ print(f"Error in parsing JSON: {e}, {json_content}")
+
+ if model_result == -1:
+ model_result = response
+
+ return model_result
+
+
+def post_process_eval_open(response, step):
+
+ model_result = -1
+
+ if response and response != FAIL_MSG:
+
+ json_start = response.find("```json")
+ json_end = response.find("```", json_start + len("```json"))
+
+ if json_start != -1 and json_end != -1:
+ json_content = response[json_start + len("```json"):json_end].strip()
+ else:
+ json_content = ""
+
+ if json_content:
+ try:
+ model_result = json.loads(json_content)["result"]
+ except Exception as e:
+ print(f"Error in parsing JSON: {e}, {json_content}")
+ return -1
+ if model_result == -1:
+ if step == 1:
+ match = re.search(r"[012]", response)
+ if match:
+ model_result = int(match.group())
+ else:
+ match = re.search(r"[01]", response)
+ if match:
+ model_result = int(match.group())
+
+ return model_result
+
+
+def eval_open_first(model, line):
+
+ user_prompt = ""
+
+ user_prompt += f"Question: {line['question']}\n\n"
+
+ user_prompt += f"The ground truth answer is '{line['answer']}'\n\n"
+
+ user_prompt += f"The model's prediction is '{line['model_result']}'\n\n"
+
+ result = model.generate(user_prompt)
+
+ return result
+
+
+def save_step_1_steps(data, step_1_results):
+
+ # 处理所有结果
+ data["step_1_result"] = data["qid"].map(lambda x: post_process_eval_open(step_1_results[x], 1))
+
+ # 条件更新
+ mask = data["step_1_result"].isin([-1, 0, 1])
+ data.loc[mask, "step_2_result"] = data.loc[mask, "step_1_result"]
+ data.loc[mask, "score"] = data.loc[mask, "step_1_result"]
+
+ return data
+
+
+def eval_open_second(model, line, frame_paths):
+
+ user_prompt = ""
+
+ user_prompt += f"Question: {line['question']}\n\n"
+
+ user_prompt += f"The model's prediction is '{line['model_result']}'\n\n"
+
+ result = model.generate([user_prompt] + frame_paths)
+
+ return result
+
+
+def save_step_2_steps(data, step_1_results):
+
+ # 处理所有结果
+ data["score"] = data["qid"].map(lambda x: post_process_eval_open(step_1_results[x], 2))
+
+ return data
+
+
+def clue_frame_paths(clue_frame_root, qid, num_frames=8):
+ frame_root = osp.join(clue_frame_root, str(qid))
+ os.makedirs(frame_root, exist_ok=True)
+ return [osp.join(frame_root, frame_tmpl.format(i, num_frames)) for i in range(1, num_frames + 1)]
+
+
+def save_clue_video_frames(data_root, clue_frame_root, video, uid, clue_intervals=None, num_frames=8, fps=-1):
+
+ if type(uid) is str:
+ uid = str(uid)
+
+ vid_path = osp.join(data_root, video)
+ vid = decord.VideoReader(vid_path)
+ vid_fps = vid.get_avg_fps()
+
+ if clue_intervals is not None:
+ # 1. 合并重叠区间
+ merged_intervals = merge_intervals(clue_intervals)
+
+ if num_frames > 0 and fps < 0:
+ # 2. 基于clue_intervals均匀抽帧
+ indices = sample_frames_clue_average(merged_intervals, num_frames, vid_fps)
+ frame_paths = clue_frame_paths(clue_frame_root, uid, len(indices))
+
+ # 保存帧
+ flag = np.all([osp.exists(p) for p in frame_paths])
+ if not flag:
+ images = [vid[i].asnumpy() for i in indices]
+ images = [Image.fromarray(arr) for arr in images]
+ for im, pth in zip(images, frame_paths):
+ if not osp.exists(pth):
+ im.save(pth)
+
+ return frame_paths, indices, vid_fps
+
+
+def get_chunk_number(filename):
+ try:
+ num = filename.split("chunk_")[1].split(".zip")[0]
+ return int(num)
+ except:
+ return float('inf')
+
+
+def unzip_hf_zip(pth):
+
+ import zipfile
+
+ target_dir = pth
+
+ if os.path.exists(f"{target_dir}/cg_videos_720p") and os.path.exists(f"{target_dir}/cg_subtitles")\
+ and os.path.exists(f"{target_dir}/cg_clue_videos"):
+ print("all exists")
+ return
+
+ video_zip_files = [
+ os.path.join(target_dir, file)
+ for file in os.listdir(target_dir)
+ if file.endswith(".zip") and file.startswith("video")
+ ]
+
+ video_zip_files = sorted(video_zip_files, key=lambda x: get_chunk_number(os.path.basename(x)))
+
+ videos_temp_zip = os.path.join(target_dir, "videos_merged.zip")
+
+ print("Merging video files ...")
+
+ with open(videos_temp_zip, "wb") as outfile:
+ for video_zip_file in tqdm(video_zip_files, desc="Merging videos"):
+ with open(video_zip_file, "rb") as infile:
+ outfile.write(infile.read())
+
+ print("Extracting video files...")
+
+ try:
+ with zipfile.ZipFile(videos_temp_zip, "r") as zip_ref:
+
+ total_files = len(zip_ref.namelist())
+
+ for file in tqdm(zip_ref.namelist(), desc="Extracting", total=total_files):
+ zip_ref.extract(file, target_dir)
+
+ print(f"Successfully extracted to {target_dir}")
+ except Exception as e:
+ print(f"Error during extraction: {e}")
+ finally:
+
+ if os.path.exists(videos_temp_zip):
+ os.remove(videos_temp_zip)
+ print("Cleaned up temporary video file")
+
+ clue_video_zip_files = [
+ os.path.join(target_dir, file)
+ for file in os.listdir(target_dir)
+ if file.endswith(".zip") and file.startswith("clue_video")
+ ]
+
+ clue_video_zip_files = sorted(clue_video_zip_files, key=lambda x: get_chunk_number(os.path.basename(x)))
+
+ clue_videos_temp_zip = os.path.join(target_dir, "clue_videos_merged.zip")
+
+ print("Merging clue video files ...")
+
+ with open(clue_videos_temp_zip, "wb") as outfile:
+ for clue_video_zip_file in tqdm(clue_video_zip_files, desc="Merging clue_videos"):
+ with open(clue_video_zip_file, "rb") as infile:
+ outfile.write(infile.read())
+
+ print("Extracting clue video files...")
+
+ try:
+ with zipfile.ZipFile(clue_videos_temp_zip, "r") as zip_ref:
+
+ total_files = len(zip_ref.namelist())
+
+ for file in tqdm(zip_ref.namelist(), desc="Extracting", total=total_files):
+ zip_ref.extract(file, target_dir)
+
+ print(f"Successfully extracted to {target_dir}")
+ except Exception as e:
+ print(f"Error during extraction: {e}")
+ finally:
+
+ if os.path.exists(clue_videos_temp_zip):
+ os.remove(clue_videos_temp_zip)
+ print("Cleaned up temporary clue video file")
+
+ print("Extracting subtitle files ...")
+
+ subtitles_zip = os.path.join(target_dir, "subtitles.zip")
+
+ try:
+ with zipfile.ZipFile(subtitles_zip, "r") as zip_ref:
+
+ total_files = len(zip_ref.namelist())
+
+ for file in tqdm(zip_ref.namelist(), desc="Extracting", total=total_files):
+ zip_ref.extract(file, target_dir)
+
+ print(f"Successfully extracted to {target_dir}")
+ except Exception as e:
+ print(f"Error during extraction: {e}")
diff --git a/vlmeval/dataset/utils/crpe.py b/vlmeval/dataset/utils/crpe.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec89792ca621c321758f49cc3fc43434f87a77ac
--- /dev/null
+++ b/vlmeval/dataset/utils/crpe.py
@@ -0,0 +1,13 @@
+import json
+import argparse
+from collections import defaultdict
+
+
+def is_correct(predict, answer):
+ # predict是标准答案 answer是预测
+ if len(answer) == 1:
+ return answer[0] == predict[0]
+ elif len(answer) != 1 and answer[0] in ['A', 'B', 'C', 'D']:
+ return answer[0] == predict[0]
+ elif len(answer) != 1 and answer[0] not in ['A', 'B', 'C', 'D']:
+ return predict[4:].lower() in answer.lower()
diff --git a/vlmeval/dataset/utils/hrbench.py b/vlmeval/dataset/utils/hrbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..894128067fbe11cd0c028c19b65ca9a7b64bce23
--- /dev/null
+++ b/vlmeval/dataset/utils/hrbench.py
@@ -0,0 +1,54 @@
+from ...smp import *
+import os
+
+
+def report_acc_hrbench(df):
+ cycle_group = df.groupby('cycle_category')
+ result_dic = defaultdict(list)
+ avg_dic = defaultdict(int)
+
+ count = 0
+ for key, data_value in cycle_group:
+ count += 1
+ _, resp_dic = hrbench_score(data_value)
+
+ for task_type, accuracy in resp_dic.items():
+ result_dic['cycle'].append(key)
+ result_dic['type'].append(task_type)
+ result_dic['accuracy'].append(accuracy)
+
+ avg_dic[task_type] += accuracy
+ for task_type, accuracy in avg_dic.items():
+ result_dic['cycle'].append('Average')
+ result_dic['type'].append(task_type)
+ result_dic['accuracy'].append(accuracy / count)
+ result_pd = pd.DataFrame(result_dic)
+
+ return result_pd
+
+
+def hrbench_score(data):
+ ret = defaultdict(list)
+ resp_dic = {}
+ category_list = set(data['category'])
+ score_dict = defaultdict(list)
+
+ for i in range(len(data)):
+ d = data.iloc[i]
+ category = d['category']
+ gpt_score = d['hit']
+ score_dict[category].append(gpt_score)
+ score_dict['all'].append(gpt_score)
+
+ all_acc = np.mean(score_dict['all'])
+ ret['type'].append('all')
+ ret['acc'].append(all_acc)
+ resp_dic['all'] = all_acc
+ for cate in category_list:
+ acc = np.mean(score_dict[cate])
+ ret['type'].append(cate)
+ ret['acc'].append(acc)
+
+ resp_dic[cate] = acc
+
+ return pd.DataFrame(ret), resp_dic
diff --git a/vlmeval/dataset/utils/judge_util.py b/vlmeval/dataset/utils/judge_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..025e0a911803e13ee204c7b9f282e144c01d2d3e
--- /dev/null
+++ b/vlmeval/dataset/utils/judge_util.py
@@ -0,0 +1,52 @@
+import os
+from ...smp import load_env
+
+INTERNAL = os.environ.get('INTERNAL', 0)
+
+
+def build_judge(**kwargs):
+ from ...api import OpenAIWrapper, SiliconFlowAPI, HFChatModel
+ model = kwargs.pop('model', None)
+ kwargs.pop('nproc', None)
+ load_env()
+ LOCAL_LLM = os.environ.get('LOCAL_LLM', None)
+ if LOCAL_LLM is None:
+ model_map = {
+ 'gpt-4-turbo': 'gpt-4-1106-preview',
+ 'gpt-4-0613': 'gpt-4-0613',
+ 'gpt-4-0125': 'gpt-4-0125-preview',
+ 'gpt-4-0409': 'gpt-4-turbo-2024-04-09',
+ 'chatgpt-1106': 'gpt-3.5-turbo-1106',
+ 'chatgpt-0125': 'gpt-3.5-turbo-0125',
+ 'gpt-4o': 'gpt-4o-2024-05-13',
+ 'gpt-4o-0806': 'gpt-4o-2024-08-06',
+ 'gpt-4o-mini': 'gpt-4o-mini-2024-07-18',
+ 'qwen-7b': 'Qwen/Qwen2.5-7B-Instruct',
+ 'qwen-72b': 'Qwen/Qwen2.5-72B-Instruct',
+ 'deepseek': 'deepseek-ai/DeepSeek-V2.5',
+ 'llama31-8b': 'meta-llama/Llama-3.1-8B-Instruct',
+ }
+ model_version = model_map[model]
+ else:
+ model_version = LOCAL_LLM
+
+ if model in ['qwen-7b', 'qwen-72b', 'deepseek']:
+ model = SiliconFlowAPI(model_version, **kwargs)
+ elif model == 'llama31-8b':
+ model = HFChatModel(model_version, **kwargs)
+ else:
+ model = OpenAIWrapper(model_version, **kwargs)
+ return model
+
+
+DEBUG_MESSAGE = """
+To debug the OpenAI API, you can try the following scripts in python:
+```python
+from vlmeval.api import OpenAIWrapper
+model = OpenAIWrapper('gpt-4o', verbose=True)
+msgs = [dict(type='text', value='Hello!')]
+code, answer, resp = model.generate_inner(msgs)
+print(code, answer, resp)
+```
+You cam see the specific error if the API call fails.
+"""
diff --git a/vlmeval/dataset/utils/llavabench.py b/vlmeval/dataset/utils/llavabench.py
new file mode 100644
index 0000000000000000000000000000000000000000..4e703610084d44e1a70d887c051620fb99ecad2b
--- /dev/null
+++ b/vlmeval/dataset/utils/llavabench.py
@@ -0,0 +1,65 @@
+import numpy as np
+import pandas as pd
+from ...smp import *
+
+rule_dict = {
+ '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.'}, # noqa: E501
+ '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.'}, # noqa: E501
+ '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.'} # noqa: E501
+}
+
+
+def get_eval(judge, content):
+ return judge.generate(content)
+
+
+def parse_score(review):
+ logger = get_logger('Evaluation')
+ 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:
+ logger.error('error', review)
+ return [-1, -1]
+ except Exception as e:
+ logger.error(e, 'error', review)
+ return [-1, -1]
+
+
+def build_prompt(line):
+ cap_str = line['caption']
+ question = line['question']
+ ans1 = line['gpt4_ans']
+ ans2 = line['prediction']
+ category = 'llava_bench_' + line['category']
+ rule = rule_dict[category]
+ role, prompt = rule['role'], rule['prompt']
+
+ content = (f'[Context]\n{cap_str}\n\n'
+ f'[Question]\n{question}\n\n'
+ f'[{role} 1]\n{ans1}\n\n[End of {role} 1]\n\n'
+ f'[{role} 2]\n{ans2}\n\n[End of {role} 2]\n\n'
+ f'[System]\n{prompt}\n\n')
+ return content
+
+
+def LLaVABench_atomeval(model, prompt):
+ review = get_eval(model, prompt)
+ scores = parse_score(review)
+ return scores
+
+
+def LLaVABench_score(data):
+ cates = ['overall'] + list(set(data['category']))
+ ret = defaultdict(list)
+
+ for c in cates:
+ ret['split'].append(c)
+ sub = data[data['category'] == c] if c != 'overall' else data
+ ret['Relative Score (main)'].append(np.mean(sub['score']) / np.mean(sub['gpt4_score']) * 100)
+ ret['VLM Score'].append(np.mean(sub['score']) * 10)
+ ret['GPT4 Score'].append(np.mean(sub['gpt4_score']) * 10)
+ return pd.DataFrame(ret)
diff --git a/vlmeval/dataset/utils/logicvista.py b/vlmeval/dataset/utils/logicvista.py
new file mode 100644
index 0000000000000000000000000000000000000000..4cb8c184c88e97a7929feb48d66cfd8429c1248c
--- /dev/null
+++ b/vlmeval/dataset/utils/logicvista.py
@@ -0,0 +1,150 @@
+import pandas as pd
+
+# from colorama import Fore, Back, Style
+from ...smp import *
+
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+def build_prompt_logicvista(line):
+ question = line['question']
+ prediction = str(line['prediction'])
+ tmpl = (
+ "You are a information extractor that extracts multiple choice letter answer choices "
+ "from a paragraph that contains the answer choice and sometimes explaination of why that "
+ "choice is correct to the given question.\n"
+ "What letter did the following answer choose? If the answer did not select a letter answer choice, "
+ "first try to infer the answer based off the given choices.\n"
+ "If it does not seem like the given answer corresponds to an answer choice OR if there is no selected answer, please just respond with Z.\n"
+ "Make sure you answer with ONLY the letters chosen.\n"
+ 'Example 1: \n'
+ 'Question: \nWhat is the main object in image?\nOptions: A. teddy bear B. rabbit C. cat D. dog\n\n'
+ 'Answer: \na cute teddy bear\n\nYour output: A\n'
+ 'Example 2: \n'
+ 'Question: \nWhat is the main object in image?\nOptions: A. teddy bear B. rabbit C. cat D. dog\n\n'
+ 'Answer: \nSpider\n\nYour output: Z\n'
+ 'Example 3: \n'
+ 'Question: \nWhich figure is a rotation of the object?\n\n'
+ 'Answer: \nThe figure on the right, labeled "D," is a rotation of the object shown in the top left corner.\n\nYour output: D\n'
+ 'Example 4: \n'
+ 'Question: \nWhich of the boxes comes next in the sequence? Select from A-E\n\n'
+ 'Answer: \nThe sequence of the boxes is A, B, C, D, E.\n\nYour output: ABCDE\n'
+ 'Example 5: \n'
+ 'Question: \n{}\n\nAnswer: \n{}\n\nYour output: '
+ )
+
+ return tmpl.format(question, prediction)
+
+
+def LogicVista_auxeval(model, line):
+ prompt = build_prompt_logicvista(line)
+ print(prompt)
+ log = ''
+ retry = 5
+
+ for i in range(retry):
+ prediction = line['prediction']
+ res = model.generate(prompt, temperature=i * 0.5)
+ answer = line['answer'].split(", ")
+ for j in range(0, len(answer)):
+ answer[j] = answer[j].lower()
+ answer.sort()
+ answer = ''.join(answer)
+
+ if FAIL_MSG in res:
+ log += f'Try {i}: output is {prediction}, failed to parse.\n'
+ elif not res.isupper() or not res.isalpha():
+ log += f'Try {i}: output is {prediction}, failed to parse.\n'
+ else:
+ log += 'Succeed'
+ hit = 0
+ extracted = [alpha.lower() for alpha in res]
+ extracted.sort()
+ extracted = ''.join(extracted)
+ if extracted == answer:
+ hit = 1
+ return dict(log=log, res=res, hit=hit)
+ log += 'All 5 retries failed.\n'
+ return dict(log=log, res='', hit=0)
+
+
+cat = ["diagram", "ocr", "patterns", "graphs", "tables", "3d shapes", "puzzles", "sequences", "physics"]
+
+
+def evaluate_logicvista(file_path):
+ df = pd.read_excel(file_path)
+
+ tot = defaultdict(lambda: 0)
+ hit = defaultdict(lambda: 0)
+ acc = defaultdict(lambda: 0)
+
+ lt = len(df)
+ skill_list = []
+
+ df_tot = df
+
+ df_inductive = df[df["skill"].str.contains("inductive")]
+ df_deductive = df[df["skill"].str.contains("deductive")]
+ df_numerical = df[df["skill"].str.contains("numerical")]
+ df_spatial = df[df["skill"].str.contains("spatial")]
+ df_mechanical = df[df["skill"].str.contains("mechanical")]
+
+ tot_correct = df_tot["hit"].sum()
+ tot_acc = (tot_correct / df_tot.shape[0]) * 100
+ tot['Overall'] = df_tot.shape[0]
+ hit['Overall'] = tot_correct
+ acc['Overall'] = tot_acc
+
+ inductive_correct = df_inductive["hit"].sum()
+ inductive_acc = (inductive_correct / df_inductive.shape[0]) * 100
+
+ tot["inductive"] = df_inductive.shape[0]
+ hit["inductive"] = inductive_correct
+ acc["inductive"] = inductive_acc
+
+ deductive_correct = df_deductive["hit"].sum()
+ deductive_acc = (deductive_correct / df_deductive.shape[0]) * 100
+
+ tot["deductive"] = df_deductive.shape[0]
+ hit["deductive"] = deductive_correct
+ acc["deductive"] = deductive_acc
+
+ numerical_correct = df_numerical["hit"].sum()
+ numerical_acc = (numerical_correct / df_numerical.shape[0]) * 100
+
+ tot["numerical"] = df_numerical.shape[0]
+ hit["numerical"] = numerical_correct
+ acc["numerical"] = numerical_acc
+
+ spatial_correct = df_spatial["hit"].sum()
+ spatial_acc = (spatial_correct / df_spatial.shape[0]) * 100
+
+ tot["spatial"] = df_spatial.shape[0]
+ hit["spatial"] = spatial_correct
+ acc["spatial"] = spatial_acc
+
+ mechanical_correct = df_mechanical["hit"].sum()
+ mechanical_acc = (mechanical_correct / df_mechanical.shape[0]) * 100
+
+ tot["mechanical"] = df_mechanical.shape[0]
+ hit["mechanical"] = mechanical_correct
+ acc["mechanical"] = mechanical_acc
+
+ # capability dimension, the official data json does not contain 'capability' column, so it is now ignored
+ # for i in cat:
+ # curr = df[df["capability"].str.contains(i.replace(" ", ""))]
+ # correct = curr["hit"].sum()
+ # accuracy = (correct / curr.shape[0]) * 100
+ # tot[i] = curr.shape[0]
+ # hit[i] = correct
+ # acc[i] = accuracy
+
+ res = defaultdict(list)
+ for k in tot.keys():
+ res['Task&Skill'].append(k)
+ res['tot'].append(tot[k])
+ res['hit'].append(hit[k])
+ res['acc'].append(acc[k])
+ res = pd.DataFrame(res)
+ return res
diff --git a/vlmeval/dataset/utils/longvideobench.py b/vlmeval/dataset/utils/longvideobench.py
new file mode 100644
index 0000000000000000000000000000000000000000..ca814bd2117b169e38ab4796b21b5685ce497e4a
--- /dev/null
+++ b/vlmeval/dataset/utils/longvideobench.py
@@ -0,0 +1,80 @@
+from ...smp import *
+from .multiple_choice import extract_answer_from_item
+import numpy as np
+import re
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+DURATIONS = [15, 60, 600, 3600]
+TASK_CATEGORIES = [
+ "S2E", "S2O", "S2A",
+ "E2O", "O2E", "T2E",
+ "T2O", "T2A", "E3E",
+ "O3O", "SSS", "SOS",
+ "SAA", "T3E", "T3O",
+ "TOS", "TAA"
+]
+
+
+def get_dimension_rating(data_path):
+ data = load(data_path)
+ print(data.iloc[0])
+
+ duration_rating = {k: {} for k in DURATIONS}
+ for duration in DURATIONS + ['overall']:
+ duration_rating[duration] = {
+ 'overall': '',
+ 'question_category': {k: [] for k in TASK_CATEGORIES}
+ }
+
+ for i in range(len(data)):
+
+ task_ctg = data.iloc[i]['question_category']
+
+ duration = data.iloc[i]['duration_group']
+ duration_rating[duration]['question_category'][task_ctg].append(data.iloc[i]['score'])
+
+ duration_rating['overall']['question_category'][task_ctg].append(data.iloc[i]['score'])
+
+ for duration in DURATIONS + ['overall']:
+ overall_res_dur = f'{np.mean([x for x in sum(duration_rating[duration]["question_category"].values(), []) if x >= 0]):.3f}' # noqa: E501
+ duration_rating[duration]['overall'] = overall_res_dur
+ for task_ctg in TASK_CATEGORIES:
+ task_res_dur = f'{np.mean([x for x in duration_rating[duration]["question_category"][task_ctg] if x >= 0]):.3f}' # noqa: E501
+ duration_rating[duration]['question_category'][task_ctg] = task_res_dur
+
+ return duration_rating
+
+
+def extract_option(model, input_item, dataset_name):
+ options = input_item['question'].split('\n')[1:]
+ for id, option in enumerate(options):
+ option_id = chr(ord('A') + id) + '.'
+ if option.find(option_id) >= 0:
+ input_item[chr(ord('A') + id)] = option[option.find(option_id) + len(option_id):].strip('. \n')
+ return extract_answer_from_item(model, input_item, dataset_name)['opt']
+
+
+def extract_characters_regex(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:',
+ 'Answer:',
+ '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:
+ return ''
+ return matches[0]
diff --git a/vlmeval/dataset/utils/mathv.py b/vlmeval/dataset/utils/mathv.py
new file mode 100644
index 0000000000000000000000000000000000000000..bf743d7cbd762496b13779db365eb392f72b6810
--- /dev/null
+++ b/vlmeval/dataset/utils/mathv.py
@@ -0,0 +1,179 @@
+from ...smp import *
+from ...utils import can_infer
+import timeout_decorator
+try:
+ from latex2sympy2 import latex2sympy
+except Exception as e:
+ logging.critical(f'{type(e)}: {e}')
+ logging.critical('Please install latex2sympy2 by running "pip install latex2sympy2"')
+
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+@timeout_decorator.timeout(30, use_signals=False)
+def is_equal(asw: str, gt_asw: str) -> bool:
+ if not isinstance(asw, str) != str or not isinstance(gt_asw, str):
+ print('Warning: input is not string')
+ print(asw, gt_asw)
+ asw = str(asw).lower().strip()
+ gt_asw = str(gt_asw).lower().strip()
+ if gt_asw == asw:
+ return True
+ try:
+ a = eval(gt_asw)
+ b = eval(asw)
+ if abs(a - b) < 1e-6:
+ return True
+ except:
+ pass
+ try:
+ a = latex2sympy(gt_asw)
+ b = latex2sympy(asw)
+ if abs(eval(str(a)) - eval(str(b))) < 1e-6:
+ return True
+ if abs(a - b) < 1e-6:
+ return True
+ except:
+ pass
+ return False
+
+
+def get_gpt4_ICE():
+ example_1 = """
+Hint: Please answer the question and provide the final answer at the end.\n
+Question: Which number is missing?\n
+Model response: The number missing in the sequence is 14.\n
+Extracted answer: 14
+"""
+
+ example_2 = """
+Hint: Please answer the question and provide the final answer at the end.\n
+Question: What is the fraction of females facing the camera?\n
+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.\n
+Extracted answer: 0.6
+"""
+
+ example_3 = """
+Hint: Please answer the question and provide the final answer at the end.\n
+Question: How much money does Luca need to buy a sour apple candy and a butter-scotch candy? (Unit: $)\n
+Model response: Luca needs $1.45 to buy a sour apple candy and a butterscotch candy.\n
+Extracted answer: 1.45
+"""
+
+ example_4 = """
+Hint: Please answer the question and provide the final answer at the end.\n
+Question: Between which two years does the line graph saw its maximum peak?\n
+Model response: The line graph saw its maximum peak between 2007 and 2008.\n
+Extracted answer: [2007, 2008]
+"""
+
+ example_5 = """
+Hint: Please answer the question and provide the correct option letter, e.g., A, B, C, D, at the end.\n
+Question: What fraction of the shape is blue?\n
+Choices: (A) 3/11 (B) 8/11 (C) 6/11 (D) 3/5\n
+Model response: The correct answer is (B) 8/11.\n
+Extracted answer: B
+"""
+
+ return [example_1, example_2, example_3, example_4, example_5]
+
+
+def build_mathv_gpt4_prompt(line):
+ task_description = """
+Please read the following example.
+Then extract the answer from the model response and type it at the end of the prompt.\n
+"""
+ question = line['question']
+ prediction = str(line['prediction'])
+ prompt = task_description
+ examples = get_gpt4_ICE()
+ for example in examples:
+ prompt += example + '\n'
+ prompt += question + '\n'
+ prompt += 'Model respone: ' + prediction
+ prompt += 'Extracted answer:'
+ return prompt
+
+
+def list_to_dict(lst):
+ return {chr(65 + i): val for i, val in enumerate(lst)}
+
+
+def post_check(line, prefetch=False):
+ res = None
+ ans = line['answer']
+ response = line['prediction'] if prefetch else line['res']
+ try:
+ if len(eval(line['choices'])) > 0:
+ ans = line['answer']
+ choices = list_to_dict(eval(line['choices']))
+ res = can_infer(response, choices)
+ if prefetch:
+ return res
+ else:
+ res = str(response)
+ ans = str(ans)
+ except ValueError:
+ pass
+
+ try:
+ if is_equal(res, ans):
+ return res if prefetch else True
+ else:
+ return False
+ except Exception as err:
+ logging.warning(f'{type(err)}: {err}')
+ return False
+
+
+def MATH_V_auxeval(model, line):
+ prompt = build_mathv_gpt4_prompt(line)
+ log = ''
+ retry = 5
+ if post_check(line, prefetch=True):
+ res = post_check(line, prefetch=True)
+ return dict(log='Prefetch succeed', res=res)
+ for i in range(retry):
+ prediction = line['prediction']
+ res = model.generate(prompt, temperature=i * 0.5)
+
+ if FAIL_MSG in res:
+ log += f'Try {i}: output is {prediction}, failed to parse.\n'
+ else:
+ log += 'Succeed'
+ return dict(log=log, res=res)
+ log += 'All 5 retries failed.\n'
+ return dict(log=log, res='')
+
+
+def MATH_V_acc(result_file):
+ data = load(result_file)
+ tot = defaultdict(lambda: 0)
+ fetch = defaultdict(lambda: 0)
+ hit = defaultdict(lambda: 0)
+ lt = len(data)
+ from tqdm import tqdm
+ for i in tqdm(range(lt)):
+ item = data.iloc[i]
+ cate = item['category']
+ tot['Overall'] += 1
+ tot[cate] += 1
+ if item['log'] == 'Prefetch succeed':
+ fetch['Overall'] += 1
+ fetch[cate] += 1
+ if post_check(item, prefetch=False):
+ hit['Overall'] += 1
+ hit[cate] += 1
+
+ res = defaultdict(list)
+ for k in tot.keys():
+ res['Subject'].append(k)
+ res['tot'].append(tot[k])
+ res['prefetch'].append(fetch[k])
+ res['hit'].append(hit[k])
+ res['prefetch_rate'].append(fetch[k] / tot[k] * 100)
+ res['acc'].append(hit[k] / tot[k] * 100)
+ res = pd.DataFrame(res).sort_values('Subject', ignore_index=True)
+ return res
diff --git a/vlmeval/dataset/utils/mathverse.py b/vlmeval/dataset/utils/mathverse.py
new file mode 100644
index 0000000000000000000000000000000000000000..ce80f11c751d256fd9912d01756dbb29647926a4
--- /dev/null
+++ b/vlmeval/dataset/utils/mathverse.py
@@ -0,0 +1,194 @@
+from ...smp import *
+from ...utils import can_infer
+
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+def get_gpt4_extract_ICE():
+ example_1 = """
+1.
+Model response: 'Rounded to two decimal places, the perimeter of the sector is approximately:\n\n(-2, 1)'
+Extracted Answer: (-2, 1)
+""" # noqa
+
+ example_2 = """
+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
+""" # noqa
+
+ example_3 = """
+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]\\)
+""" # noqa
+
+ example_4 = """
+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
+""" # noqa
+
+ example_5 = """
+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
+""" # noqa
+
+ example_6 = """
+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
+""" # noqa
+
+ return [example_1, example_2, example_3, example_4, example_5, example_6]
+
+
+def get_gpt4_score_ICE():
+ example_1 = """
+[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
+""" # noqa
+
+ example_2 = """
+[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
+""" # noqa
+
+ example_3 = """
+[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
+""" # noqa
+
+ example_4 = """
+[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
+""" # noqa
+
+ return [example_1, example_2, example_3, example_4]
+
+
+def build_mathverse_gpt4_extract_prompt(line):
+ task_description = """
+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.\n\n
+""" # noqa
+ prediction = str(line['prediction'])
+ demo_prompt = task_description
+ examples = get_gpt4_extract_ICE()
+ for example in examples:
+ demo_prompt += example + '\n\n'
+ test_prompt = f"Model response: '{prediction}'\nExtracted Answer: "
+ full_prompt = f'{demo_prompt}7.\n{test_prompt}'
+
+ return full_prompt
+
+
+def build_mathverse_gpt4_score_prompt(line):
+ task_description = """
+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.\n\n
+""" # noqa
+ question_for_eval = line['question_for_eval']
+ extract = line['extract']
+ answer = line['answer']
+ demo_prompt = task_description
+ examples = get_gpt4_score_ICE()
+ for example in examples:
+ demo_prompt += example + '\n\n'
+ test_prompt = f"""
+ [Question]: {question_for_eval}
+ [Standard Answer]: {answer}
+ [Model_answer] : {extract}
+ Judgement:"""
+ full_prompt = f'{demo_prompt}{test_prompt}'
+
+ return full_prompt
+
+
+def post_check_score(line, prefetch=False):
+ ans = str(line['answer']).strip()
+ response = str(line['extract']).strip()
+
+ if response == ans:
+ return response if prefetch else True
+ else:
+ return False
+
+
+def MathVerse_auxeval_extract(model, line):
+ prompt = build_mathverse_gpt4_extract_prompt(line)
+ log = ''
+ retry = 5
+ for i in range(retry):
+ prediction = line['prediction']
+ res = model.generate(prompt, temperature=i * 0.5)
+
+ if FAIL_MSG in res:
+ log += f'Try {i}: output is {prediction}, failed to parse.\n'
+ else:
+ log += 'Succeed'
+ return dict(log_extract=log, extract=res)
+ log += 'All 5 retries failed.\n'
+ return dict(log_extract=log, extract='')
+
+
+def MathVerse_auxeval_score(model, line):
+ prompt = build_mathverse_gpt4_score_prompt(line)
+ log = ''
+ retry = 5
+ if post_check_score(line, prefetch=True):
+ res = post_check_score(line, prefetch=True)
+ return dict(log_score='Prefetch succeed', score=True)
+ for i in range(retry):
+ prediction = line['prediction']
+ res = model.generate(prompt, temperature=i * 0.5)
+
+ if FAIL_MSG in res or res.strip() not in ['0', '1']:
+ log += f'Try {i}: output is {prediction}, res is {res}, failed to parse.\n'
+ else:
+ log += 'Succeed'
+ return dict(log_score=log, score=int(res) == 1)
+ log += 'All 5 retries failed.\n'
+ return dict(log_score=log, score=False)
+
+
+def MathVerse_acc(result_file):
+ df = load(result_file)
+
+ df['metadata'] = df['metadata'].apply(lambda x: x.replace("'", '"'))
+ df['metadata'] = df['metadata'].apply(json.loads)
+ df_metadata = pd.json_normalize(df['metadata'])
+ df = pd.concat([df.drop('metadata', axis=1), df_metadata], axis=1)
+
+ subset = ["Overall"]
+ subset.extend(list(set(df['problem_version'])))
+
+ res = defaultdict(list)
+ for p in subset:
+ if p != 'Overall':
+ sub = df[df['problem_version'] == p]
+ else:
+ sub = cp.deepcopy(df)
+ res['split'].append(p)
+ # Overall Acc
+ res['Overall'].append(np.mean(sub['score']) * 100)
+ # Subject
+ subjects = set(df['subject'])
+ for k in subjects:
+ res[k].append(np.mean(sub[sub['subject'] == k]['score']) * 100)
+ # Subfield
+ subfields = set(df['subfield'])
+ for k in subfields:
+ res[k].append(np.mean(sub[sub['subfield'] == k]['score']) * 100)
+
+ return pd.DataFrame(res)
diff --git a/vlmeval/dataset/utils/mathvista.py b/vlmeval/dataset/utils/mathvista.py
new file mode 100644
index 0000000000000000000000000000000000000000..52e138508262abd1b93bfa544120d37881d7ff5b
--- /dev/null
+++ b/vlmeval/dataset/utils/mathvista.py
@@ -0,0 +1,164 @@
+from ...smp import *
+from ...utils import can_infer
+
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+def get_gpt4_ICE():
+ example_1 = """
+Hint: Please answer the question requiring an integer answer and provide the final value,
+e.g., 1, 2, 3, at the end.\n
+Question: Which number is missing?\n
+Model response: The number missing in the sequence is 14.\n
+Extracted answer: 14
+"""
+
+ example_2 = """
+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.\n
+Question: What is the fraction of females facing the camera?\n
+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.\n
+Extracted answer: 0.6
+"""
+
+ example_3 = """
+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.\n
+Question: How much money does Luca need to buy a sour apple candy and a butter-scotch candy? (Unit: $)\n
+Model response: Luca needs $1.45 to buy a sour apple candy and a butterscotch candy.\n
+Extracted answer: 1.45
+"""
+
+ example_4 = """
+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.\n
+Question: Between which two years does the line graph saw its maximum peak?\n
+Model response: The line graph saw its maximum peak between 2007 and 2008.\n
+Extracted answer: [2007, 2008]
+"""
+
+ example_5 = """
+Hint: Please answer the question and provide the correct option letter, e.g., A, B, C, D, at the end.\n
+Question: What fraction of the shape is blue?\n
+Choices: (A) 3/11 (B) 8/11 (C) 6/11 (D) 3/5\n
+Model response: The correct answer is (B) 8/11.\n
+Extracted answer: B
+"""
+
+ return [example_1, example_2, example_3, example_4, example_5]
+
+
+def build_mathvista_gpt4_prompt(line):
+ task_description = """
+Please read the following example.
+Then extract the answer from the model response and type it at the end of the prompt.\n
+"""
+ question = line['question']
+ prediction = str(line['prediction'])
+ prompt = task_description
+ examples = get_gpt4_ICE()
+ for example in examples:
+ prompt += example + '\n'
+ prompt += question + '\n'
+ prompt += 'Model respone: ' + prediction
+ prompt += 'Extracted answer:'
+ return prompt
+
+
+def list_to_dict(lst):
+ return {chr(65 + i): val for i, val in enumerate(lst)}
+
+
+def post_check(line, prefetch=False):
+ res = None
+ ans = line['answer']
+ response = line['prediction'] if prefetch else line['res']
+ try:
+ if line['question_type'] == 'multi_choice':
+ ans = line['answer_option']
+ choices = list_to_dict(eval(line['choices']))
+ res = can_infer(response, choices)
+ if prefetch:
+ return res
+ else:
+ if line['answer_type'] == 'integer':
+ res = int(response)
+ ans = int(line['answer'])
+ elif line['answer_type'] == 'float':
+ res = float(response)
+ ans = float(line['answer'])
+ else:
+ res = str(res)
+ ans = str(ans)
+ except ValueError:
+ pass
+
+ if res == ans:
+ return res if prefetch else True
+ else:
+ return False
+
+
+def MathVista_auxeval(model, line):
+ prompt = build_mathvista_gpt4_prompt(line)
+ log = ''
+ retry = 5
+ if post_check(line, prefetch=True):
+ res = post_check(line, prefetch=True)
+ return dict(log='Prefetch succeed', res=res)
+ for i in range(retry):
+ prediction = line['prediction']
+ res = model.generate(prompt, temperature=i * 0.5)
+
+ if FAIL_MSG in res:
+ log += f'Try {i}: output is {prediction}, failed to parse.\n'
+ else:
+ log += 'Succeed'
+ return dict(log=log, res=res)
+ log += 'All 5 retries failed.\n'
+ return dict(log=log, res='')
+
+
+def MathVista_acc(result_file):
+ data = load(result_file)
+ tot = defaultdict(lambda: 0)
+ fetch = defaultdict(lambda: 0)
+ hit = defaultdict(lambda: 0)
+ lt = len(data)
+ skill_list = []
+ for i in range(lt):
+ item = data.iloc[i]
+ cate = item['task']
+ tot['Overall'] += 1
+ try:
+ skills = eval(item['skills'])
+ except SyntaxError:
+ skills = [item['skills']]
+ for skill in skills:
+ if skill not in skill_list:
+ skill_list.append(skill)
+ tot[skill] += 1
+ tot[cate] += 1
+ if item['log'] == 'Prefetch succeed':
+ fetch['Overall'] += 1
+ fetch[cate] += 1
+ for skill in skills:
+ fetch[skill] += 1
+ if post_check(item, prefetch=False):
+ hit['Overall'] += 1
+ hit[cate] += 1
+ for skill in skills:
+ hit[skill] += 1
+
+ res = defaultdict(list)
+ for k in tot.keys():
+ res['Task&Skill'].append(k)
+ res['tot'].append(tot[k])
+ res['prefetch'].append(fetch[k])
+ res['hit'].append(hit[k])
+ res['prefetch_rate'].append(fetch[k] / tot[k] * 100)
+ res['acc'].append(hit[k] / tot[k] * 100)
+ res = pd.DataFrame(res)
+ return res
diff --git a/vlmeval/dataset/utils/megabench/README.md b/vlmeval/dataset/utils/megabench/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..4636b04402347c309f1251d1cbe46e7d9f6fccc3
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/README.md
@@ -0,0 +1,81 @@
+# MEGA-Bench metrics
+
+Each task's metrics are specified in `metrics.json` and follow the schema outlined below:
+
+```json
+{
+ "field_score_function": {
+ for field_name in field_names:
+ field_name: scoring_function
+ },
+ "aggregation": {
+ "function": aggregation_function,
+ "field_weights": {
+ for field_name in field_names:
+ field_name: field_weight
+ }
+ },
+ "response_parse_function": response_parse_function
+}
+```
+
+## Scoring Functions
+
+### String Comparisons
+These metrics are applied when both the response and the correct field are strings.
+
+- `exact_str_match`: Checks if the field exactly matches the reference response.
+- `simple_str_match`: Performs a case-insensitive comparison, ignoring spaces and hyphens, to determine if the response matches the correct field.
+- `exact_str_match_case_insensitive`: A case-insensitive version of `exact_str_match`.
+- `normalized_similarity_demarau_levenshtein`: Computes the normalized Damerau-Levenshtein similarity between the strings.
+- `near_str_match`: Normalizes accented characters to their ASCII equivalents, then performs a case-insensitive fuzzy string match. If the similarity score is below a certain threshold (currently 0.9), the score is set to 0.
+- `program_judge`: A custom suite of test cases specifically for the `code_programming_test` task.
+
+### Set Comparisons
+These metrics are used when inputs are iterables or strings that represent sets. Inputs are converted into sets and treated as empty if parsing fails. These metrics are useful when the order doesn't matter.
+
+`set_equality`: Checks if the sets are identical.
+`jaccard_index`: Calculates the Jaccard index of the two sets.
+`set_precision`: Measures the ratio of the predicted set elements that appear in the correct set.
+`chess_move_list_jaccard_index`: Computes the Jaccard index without requiring the response to specify whether a move results in check or checkmate.
+
+### List Comparisons
+These metrics apply when inputs are iterables or strings that represent lists. Inputs are converted into lists and treated as empty if parsing fails.
+
+`longest_common_list_prefix_ratio`: Calculates the ratio of the length of the longest common prefix (list) to the length of the correct solution.
+
+#### Bounding boxes
+Bounding boxes are a specialized type of list metric. Each solution consists of a list of 4-tuples, where each tuple is of the form (x1, y1, x2, y2), representing the top-left and bottom-right corners of the bounding box, respectively. Since images are dynamically resized before being sent to the LMM, coordinates are normalized to the range [0, 1].
+
+`nbbox_iou_tuple`: Matches each predicted bounding box with the one that has the highest Intersection over Union (IoU) score, which is then used as the score for that bounding box. The mean score across all predicted bounding boxes is calculated.
+
+### Dictionary Comparisons
+These metrics apply when inputs are dictionaries or strings that encode dictionaries. Inputs are converted into dictionaries and treated as empty if parsing fails.
+
+Generally, these metrics follow a two-step approach:
+1. Calculate a metric for values with matching keys, resulting in a mapping of key-score pairs. If a key is missing in the response, its score is set to 0.
+2. Aggregate the scores.
+
+This approach is straightforward when the keys in the response and the correct answer match. If they don't, various strategies can be employed.
+
+- `agg_recall`: Computes the mean score for keys that appear in the correct answer.
+- `agg_jaccard`: Computes the mean score across all keys, using the size of the union of keys from both the response and the correct answer as the denominator.
+
+Derivative metrics that follow this format include:
+- `dict_exact_str_match_agg_recall`
+- `dict_set_equality_agg_jaccard`
+- `dict_jaccard_agg_jaccard`
+- `dict_nbbox_iou_tuple_agg_jaccard`
+
+## Aggregation Functions
+The following functions are used to aggregate the field scores:
+
+- `mean`: Calculates a weighted mean, with weights specified in `aggregation.field_weights`.
+- `min`: Returns the minimum field score.
+
+## Response Parsing Functions
+These functions are used to parse the model's response:
+
+`json`: Parses the response as a JSON object.
+`odd_one_out`: A custom parser for the `logical_reasoning_find_odd_out_one` task.
+`logical_2d_views_3d_shapes`: A custom parser for the `logical_reasoning_2D_views_of_3D_shapes` task.
diff --git a/vlmeval/dataset/utils/megabench/__init__.py b/vlmeval/dataset/utils/megabench/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5b136359db1d036614f0b5c63e26c1b4a4f63b6e
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/__init__.py
@@ -0,0 +1,5 @@
+from .aggregation_type import AggregationType
+from .metric_type import MetricType
+from .response_parse_type import ResponseParseType
+
+__all__ = [AggregationType, MetricType, ResponseParseType]
diff --git a/vlmeval/dataset/utils/megabench/aggregation/mean_agg.py b/vlmeval/dataset/utils/megabench/aggregation/mean_agg.py
new file mode 100644
index 0000000000000000000000000000000000000000..13d675fa3e73e7c3233185763a73e440c703e518
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/aggregation/mean_agg.py
@@ -0,0 +1,22 @@
+from numbers import Number
+from typing import Dict
+import numpy as np
+
+
+class MeanAggregation:
+ """Take the mean of all valid scores."""
+
+ @staticmethod
+ def aggregate(scores: Dict[str, Number], weights: Dict[str, Number]) -> Number:
+ """Exact match between targets and responses."""
+ filtered_scores = {f: s for f, s in scores.items() if s >= 0}
+ if not filtered_scores:
+ return -1
+
+ # Align the key order
+ flattened_scores = []
+ flattened_weights = []
+ for field in filtered_scores:
+ flattened_scores.append(filtered_scores[field])
+ flattened_weights.append(weights[field])
+ return np.average(flattened_scores, weights=flattened_weights)
diff --git a/vlmeval/dataset/utils/megabench/aggregation/min_agg.py b/vlmeval/dataset/utils/megabench/aggregation/min_agg.py
new file mode 100644
index 0000000000000000000000000000000000000000..1558991ffda6dfdd0d12663e8ef31950bc521ce7
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/aggregation/min_agg.py
@@ -0,0 +1,14 @@
+from numbers import Number
+from typing import Dict
+
+
+class MinAggregation:
+ """Take the minimum of all valid scores."""
+
+ @staticmethod
+ def aggregate(scores: Dict[str, Number], weights: Dict[str, Number]) -> Number:
+ """Exact match between targets and responses."""
+ filtered_scores = [s for s in scores.values() if s >= 0]
+ if not filtered_scores:
+ return -1
+ return min(filtered_scores)
diff --git a/vlmeval/dataset/utils/megabench/aggregation/unsupported_agg.py b/vlmeval/dataset/utils/megabench/aggregation/unsupported_agg.py
new file mode 100644
index 0000000000000000000000000000000000000000..1cd9991b67130a7be359a75c32d953ecda68a4b8
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/aggregation/unsupported_agg.py
@@ -0,0 +1,8 @@
+from numbers import Number
+from typing import Dict
+
+
+class UnsupportedAggregation:
+ @staticmethod
+ def aggregate(scores: Dict[str, Number], weights: Dict[str, Number]) -> Number:
+ return -1
diff --git a/vlmeval/dataset/utils/megabench/aggregation_type.py b/vlmeval/dataset/utils/megabench/aggregation_type.py
new file mode 100644
index 0000000000000000000000000000000000000000..b921c3db57a2aea6fb3b43f75d27db9ab01fffef
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/aggregation_type.py
@@ -0,0 +1,25 @@
+from enum import Enum
+
+class AggregationType(Enum):
+ MEAN = 0
+
+ @classmethod
+ def from_string(cls, s):
+ return cls.MEAN
+
+ def aggregate(self, field_scores, field_weights):
+ if not field_scores:
+ return 0.0
+
+ total_score = 0.0
+ total_weight = 0.0
+
+ for field, score in field_scores.items():
+ weight = field_weights.get(field, 1.0)
+ try:
+ total_score += score * weight
+ except:
+ total_score += score[0] * weight
+ total_weight += weight
+
+ return total_score / total_weight if total_weight > 0 else 0.0
diff --git a/vlmeval/dataset/utils/megabench/evaluator.py b/vlmeval/dataset/utils/megabench/evaluator.py
new file mode 100644
index 0000000000000000000000000000000000000000..83ffe7a63ed4e4075a62c13aea4f15472ed03808
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/evaluator.py
@@ -0,0 +1,385 @@
+import argparse
+import json
+import os
+from typing import Any, Dict, List
+import ast
+from vlmeval import load, dump
+
+
+from . import MetricType, AggregationType, ResponseParseType
+from .parsing.common.utils import evaluate_as_string
+
+
+class MEGABenchEvaluator:
+ def __init__(
+ self,
+ subset_name: str,
+ responses_file: str,
+ output_file: str,
+ ):
+ """
+ :param hf_data_file: Path to a file containing HF dataset tasks + their metric configs
+ :param model_responses_file: Path to a JSON file with tasks + model responses
+ :param output_file: Path to store evaluated results
+ """
+ self.hf_data = self._load_hf(subset_name) # e.g. same structure used previously
+ self.data = self._load_json(responses_file) # The model's output
+ self.output_file = output_file
+ self.tmp_output_file = output_file.replace(".json", "_tmp.pkl")
+
+ # Build a dict of {task_name -> metric configuration} for quick lookup
+ self.scoring_functions = {}
+ for task_name, task_samples in self.hf_data.items():
+ self.scoring_functions[task_name] = ast.literal_eval(
+ task_samples[0]["metric_info"]
+ )
+
+ def _load_hf(self, subset_name: str) -> List[Dict[str, Any]]:
+ """
+ Load the HF dataset for the given subset name.
+ """
+ from datasets import load_dataset
+ dataset = load_dataset("TIGER-Lab/MEGA-Bench", subset_name)["test"]
+ task_dict = {}
+ for sample in dataset:
+ task_name = sample["task_name"]
+ if task_name not in task_dict:
+ task_dict[task_name] = []
+ task_dict[task_name].append(sample)
+
+ return task_dict
+
+ def _get_eval_context(self, task_name, query):
+ if "query_idx" in query:
+ query_idx = query["query_idx"]
+ eval_context = self.hf_data[task_name][query_idx]["eval_context"]
+ else:
+ global_idx = query["global_idx"]
+ global_idx_to_sample = {sample["id"]: sample for sample in self.hf_data[task_name]}
+ eval_context = global_idx_to_sample[global_idx]["eval_context"]
+
+ eval_context = ast.literal_eval(eval_context)
+ return eval_context
+
+ def evaluate(self):
+ """
+ The main entry point to evaluate all tasks in self.data based on the HF dataset’s metric info.
+ """
+ if os.path.exists(self.tmp_output_file):
+ exist_records = load(self.tmp_output_file)
+ else:
+ exist_records = {}
+ num_tasks = 0
+ num_queries = 0
+ total_query_score = 0.0
+ total_task_score = 0.0
+
+ # Evaluate each task
+ for task in self.data:
+ task_name = task.get("task_name", "")
+ if task_name not in exist_records:
+ exist_records[task_name] = {}
+
+ # If no scoring config is found for the given task_name, skip
+ score_config = self.scoring_functions.get(
+ task_name,
+ {
+ "field_score_function": {},
+ "aggregation": {"function": None, "field_weights": {}},
+ "response_parse_function": None,
+ },
+ )
+ if not task.get("query_response"):
+ # No queries to score
+ continue
+
+ num_tasks += 1
+ task_score_sum = 0.0
+ # Prepare the aggregator
+ aggregator = AggregationType.from_string(score_config["aggregation"]["function"])
+ field_weights = score_config["aggregation"]["field_weights"]
+
+ # Parse the metric definitions
+ field_score_functions = score_config.get("field_score_function", {})
+ global_aux_metrics = score_config.get("global_aux_metrics", {})
+ parser_type_str = score_config.get("response_parse_function", "dummy")
+ parser = ResponseParseType.from_string(parser_type_str)
+
+ # Extract the fields from the first correct_answer (assuming uniform)
+ first_correct = task["query_response"][0]["correct_answer"]
+ all_fields = list(first_correct.keys())
+ # Usually, we only treat “##something” fields as metadata, so skip them:
+ answer_fields = [f for f in all_fields if not f.startswith("##")]
+
+ # For each query in the task
+ for idx, query in enumerate(task["query_response"]):
+ num_queries += 1
+ response_text = query.get("response", "")
+ correct_answer = query["correct_answer"]
+
+ # 1) Parse the response according to the specified parser
+ response_obj = self._parse_response(
+ task_name,
+ parser,
+ response_text,
+ correct_answer,
+ answer_fields,
+ query,
+ task,
+ )
+
+ if idx in exist_records[task_name]:
+ query["scores"] = exist_records[task_name][idx]
+ else:
+ # Initialize scores for this query
+ query["scores"] = {"field": {}, "info": {}}
+
+ # 2) Evaluate each field
+ for fld, fld_metric_name in field_score_functions.items():
+ metric = self._build_metric(fld_metric_name, score_config)
+ self._evaluate_field(
+ task_name,
+ metric,
+ fld,
+ response_obj,
+ correct_answer,
+ query
+ )
+
+ # Evaluate global auxiliary metrics (if any)
+ for fld, fld_metric_name in global_aux_metrics.items():
+ metric = self._build_metric(fld_metric_name, score_config)
+ # Some tasks want the entire response object to do an additional check
+ # So, pass original `response_obj` under `fld` key:
+ tmp_obj = {fld: response_obj}
+ self._evaluate_field(
+ task_name,
+ metric,
+ fld,
+ tmp_obj,
+ correct_answer,
+ query,
+ is_aux=True,
+ )
+
+ exist_records[task_name][idx] = query["scores"]
+ if idx % 10 == 0 or idx == len(task["query_response"]) - 1:
+ dump(exist_records, self.tmp_output_file)
+
+ # 3) Aggregate the query-level score
+ query["scores"]["query"] = aggregator.aggregate(
+ query["scores"]["field"],
+ field_weights,
+ )
+
+ if query["scores"]["query"] >= 0:
+ task_score_sum += query["scores"]["query"]
+
+ # Calculate overall task score
+ if task["query_response"]:
+ mean_score = task_score_sum / len(task["query_response"])
+ else:
+ mean_score = 0.0
+ task["task_score"] = task_score_sum
+ task["mean_task_score"] = mean_score
+
+ total_query_score += task_score_sum
+ total_task_score += mean_score
+
+ print(f"[Task: {task_name}] Score = {task_score_sum} / {len(task['query_response'])}")
+
+ # Produce overall summary stats
+ summary = {}
+ if num_tasks > 0:
+ macro_mean_score = total_task_score / num_tasks
+ summary["macro_mean_score"] = macro_mean_score
+ else:
+ summary["macro_mean_score"] = 0.0
+
+ if num_queries > 0:
+ micro_mean_score = total_query_score / num_queries
+ summary["micro_mean_score"] = micro_mean_score
+ else:
+ summary["micro_mean_score"] = 0.0
+
+ summary["num_tasks"] = num_tasks
+ summary["num_queries"] = num_queries
+ # print(f"\n=== Evaluation Summary ===\n{json.dumps(summary, indent=4)}\n")
+
+ # Write back final data + summary
+ output_data = {
+ "data": self.data,
+ "summary": summary,
+ }
+ self._save_results(self.output_file, output_data)
+ print(f"Evaluation complete! Results saved to {self.output_file}")
+
+ def _evaluate_field(
+ self,
+ task_name: str,
+ metric: Any,
+ field: str,
+ response_obj: Dict[str, Any],
+ correct_answer: Dict[str, Any],
+ query: Dict[str, Any],
+ is_aux: bool = False,
+ ) -> float:
+ """Compute score for a single field using the given metric."""
+ eval_context = self._get_eval_context(task_name, query)
+
+ if metric == MetricType.UNSUPPORTED:
+ print(f"The metric for {field} in task {task_name} is not supported")
+ return 0.0
+ elif metric == MetricType.SYMBOLIC_PLANNING_TEST or metric == MetricType.PROGRAM_JUDGE:
+ query["scores"]["field"][field] = metric.match(
+ response_obj.get(field),
+ eval_context,
+ )
+ elif metric == MetricType.CONSTRAINED_GENERATION:
+ score, eval_info = metric.match(response_obj, eval_context)
+ query["scores"]["field"][field] = score
+ query["scores"]["info"][field] = eval_info
+ elif metric == MetricType.XML_NORM_POINT_IN_BBOX:
+ score, eval_info = metric.match(response_obj.get(field), eval_context)
+ query["scores"]["field"][field] = score
+ query["scores"]["info"][field] = eval_info
+ elif isinstance(metric, MetricType.VLM_AS_JUDGE.class_impl):
+ images = query.get("images", [])
+ question = query.get("question", "")
+ correct_val = correct_answer.get(field, "") if not is_aux else correct_answer
+ response_info = (
+ response_obj.get(field)
+ if isinstance(response_obj, dict)
+ else response_obj
+ )
+ query["scores"]["field"][field] = metric.match(
+ response_info,
+ correct_val,
+ images=images,
+ question=question,
+ eval_context=eval_context,
+ )
+ else:
+ correct_val = correct_answer.get(field, "") if not is_aux else correct_answer
+ correct_val = evaluate_as_string(correct_val) # remove extra formatting
+ predicted_val = response_obj.get(field, "")
+ query["scores"]["field"][field] = metric.match(predicted_val, correct_val)
+
+ def _parse_response(
+ self,
+ task_name: str,
+ parser,
+ response_text: str,
+ correct_answer: Dict[str, Any],
+ answer_fields: List[str],
+ query: Dict[str, Any],
+ task: Dict[str, Any],
+ ) -> Dict[str, Any]:
+ """
+ Parse the raw response into a structured object, depending on the parser.
+ """
+ res_parsing_pass = True
+ if parser.is_single_field_parser():
+ # single field
+ assert (
+ len(answer_fields) == 1
+ ), "The answer_string parse must be used when the answer has a single field"
+ answer_key = answer_fields[0]
+
+ global_description = task["task_description"]
+ query_question = query["question"]
+ is_single_line_ans = "\n" not in correct_answer[answer_key]
+
+ response_obj = parser.parse(
+ response_text,
+ answer_key,
+ global_description=global_description,
+ query_question=query_question,
+ is_single_line_ans=is_single_line_ans,
+ )
+ assert isinstance(response_obj[answer_key], str), "Single-field parsing results must be string"
+ else:
+ # Structural output (using JSON parser or other specified parsing func) or dummy parse (return all)
+ response_obj = parser.parse(response_text)
+
+ if parser == ResponseParseType.JSON and (
+ not isinstance(response_obj, dict) or not response_obj
+ ):
+ # Expect a JSON, but parsing failed,
+ # Record the failure parsing, and use the raw string for each field of the answer
+ res_parsing_pass = False
+ response_obj = {}
+ for field in correct_answer:
+ response_obj[field] = response_text
+
+ if not res_parsing_pass:
+ print(
+ f"Task:{task_name}, cannot parse query with global idx {query['global_idx']}"
+ )
+ return response_obj
+
+ def _build_metric(self, metric_name: str, score_config: Dict[str, Any]):
+ """
+ Given a string for the metric (e.g. 'gpt_4o_as_judge'),
+ return the actual MetricType or a specialized metric class.
+ """
+ metric = MetricType.from_string(metric_name)
+ if metric == MetricType.VLM_AS_JUDGE:
+ # Build the GPT4O metric using the provided config
+ gpt4o_configs = score_config.get("gpt4o_eval_configs", {})
+ metric = metric.class_impl(gpt4o_configs)
+ elif metric == MetricType.ASCII_ART_GPT4O_JUDGE:
+ # Build the ASCII Art metric using the provided config
+ ascii_art_configs = score_config.get("ascii_art_eval_configs", {})
+ metric = metric.class_impl(ascii_art_configs)
+ return metric
+
+ @staticmethod
+ def _load_json(file_path: str) -> Any:
+ with open(file_path, "r", encoding="utf-8") as f:
+ return json.load(f)
+
+ @staticmethod
+ def _save_results(file_path: str, data: Any) -> None:
+ """
+ Safe-write a JSON file via temp file + replace.
+ Since the results file is long, this avoid breaking the file in case of a crash.
+ """
+ temp_filename = f"{file_path}.tmp"
+ with open(temp_filename, "w", encoding="utf-8") as f:
+ json.dump(data, f, ensure_ascii=False, indent=4)
+ os.replace(temp_filename, file_path)
+
+
+def main():
+ parser = argparse.ArgumentParser(description="Simple Evaluator")
+ parser.add_argument(
+ "--subset_name",
+ type=str,
+ required=True,
+ help="The subset of MEGA-Bench to evaluate.",
+ )
+ parser.add_argument(
+ "--submission_file",
+ type=str,
+ required=True,
+ help="Path to a JSON file containing model responses.",
+ )
+ parser.add_argument(
+ "--output_file",
+ type=str,
+ required=True,
+ help="Where to store the evaluation results (JSON).",
+ )
+
+ args = parser.parse_args()
+ evaluator = MEGABenchEvaluator(
+ subset_name=args.subset_name,
+ responses_file=args.submission_file,
+ output_file=args.output_file,
+ )
+ evaluator.evaluate()
+
+
+if __name__ == "__main__":
+ main()
diff --git a/vlmeval/dataset/utils/megabench/metric_type.py b/vlmeval/dataset/utils/megabench/metric_type.py
new file mode 100644
index 0000000000000000000000000000000000000000..892b5cba17ae267b0654a67a622fa899501dffa4
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/metric_type.py
@@ -0,0 +1,259 @@
+from functools import cached_property
+from enum import Enum
+from .utils import lazy_import
+import logging
+
+
+class MetricType(Enum):
+ """The types of metrics."""
+
+ EXACT_STR_MATCH = "exact_str_match"
+ SIMPLE_STR_MATCH = "simple_str_match"
+ CODE_RESULT_EXACT_STR_MATCH = "code_result_exact_str_match"
+ DICT_EXACT_STR_MATCH_AGG_RECALL = "dict_exact_str_match_agg_recall"
+ EXACT_STR_MATCH_CASE_INSENSITIVE = "exact_str_match_case_insensitive"
+ NORM_SIM_DAMERAU_LEVENSHTEIN = "normalized_similarity_damerau_levenshtein"
+ NEAR_STR_MATCH = "near_str_match"
+ NUMBER_RELATIVE_DIFF_RATIO = "number_rel_diff_ratio"
+ SET_EQUALITY = "set_equality"
+ SET_EQUALITY_CASE_INSENSITIVE = "set_equality_case_insensitive"
+ DICT_SET_EQUALITY_AGG_JACCARD = "dict_set_equality_agg_jaccard"
+ DICT_PRECISION = "dict_precision"
+ JACCARD_INDEX = "jaccard_index"
+ JACCARD_INDEX_CASE_INSENSITIVE = "jaccard_index_case_insensitive"
+ DICT_JACCARD_AGG_JACCARD = "dict_jaccard_agg_jaccard"
+ DICT_EQUALITY = "dict_equality"
+ SET_PRECISION = "set_precision"
+ POSITIVE_INT_MATCH = "positive_int_match"
+ CHESS_MOVE_LIST_JACCARD_INDEX = "chess_move_list_jaccard_index"
+ LONGEST_COMMON_LIST_PREFIX_RATIO = "longest_common_list_prefix_ratio"
+ ASCII_ART_GPT4O_JUDGE = "ascii_art_gpt4o_judge"
+ NLI_ENTAILMENT = "nli_entailment"
+ BLEU = "bleu"
+ GLEU_CN = "gleu_cn"
+ XML_NORM_BBOX_IOU_SINGLE = "xml_nbbox_iou_single"
+ LATEX_EXPR_EQUALITY = "latex_expr_equality"
+ TEXT_WITH_LATEX_EXPR_EQUALITY = "text_with_latex_expr_equality"
+ NORM_BBOX_IOU_TUPLE = "nbbox_iou_tuple"
+ NORM_BBOX_IOU_SINGLE = "nbbox_iou_single"
+ NORM_BBOX_IOU_SEQUENCE = "nbbox_iou_sequence"
+ DICT_NORM_BBOX_IOU_TUPLE_AGG_JACCARD = "dict_nbbox_iou_tuple_agg_jaccard"
+ XML_NORM_POINT_IN_BBOX = "xml_norm_point_in_bbox"
+ XML_NORM_POINT_DISTANCE = "xml_norm_point_distance"
+ GEO_PROXIMITY_LOCATION_DICT = "geo_proximity_location_dict"
+ NORMALIZED_RMSE = "normalized_rmse"
+ PROGRAM_JUDGE = "program_judge"
+ STR_SET_EQUALITY_LINE_BREAK = "str_set_equality_line_break"
+ STR_SET_EQUALITY_COMMA = "str_set_equality_comma"
+ SEQUENCE_EQUALITY = "sequence_equality"
+ SEQUENCE_EQUALITY_CASE_INSENSITIVE = "sequence_equality_case_insensitive"
+ SEQUENCE_ACCURACY_CASE_INSENSITIVE = "sequence_accuracy_case_insensitive"
+ ANGLE_SEQ_FLOAT_RMSE = "angle_seq_float_rmse"
+ SYMBOLIC_PLANNING_TEST = "symbolic_planning_test"
+ MULTI_REF_PHRASE_EVAL = "multi_ref_phrase"
+ GENERAL_SINGLE_NUMERICAL_MATCH = "general_single_numerical_match"
+ BOXED_SINGLE_NUMERICAL_MATCH = "boxed_single_numerical_match"
+ SEQUENCE_COORDS_SIMILARITY = "sequence_coords_similarity"
+ CONSTRAINED_GENERATION = "constrained_generation"
+ VLM_AS_JUDGE = "gpt_4o_as_judge"
+ UNSUPPORTED = "unsupported"
+
+ @cached_property
+ def class_impl(self):
+ lazy_imports = {
+ MetricType.SIMPLE_STR_MATCH: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.simple_str_match", "SimpleStrMatch"
+ ),
+ MetricType.EXACT_STR_MATCH: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.exact_str_match", "ExactStrMatch"
+ ),
+ MetricType.CODE_RESULT_EXACT_STR_MATCH: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.exact_str_match", "CodeResultExactStrMatch"
+ ),
+ MetricType.DICT_EXACT_STR_MATCH_AGG_RECALL: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.dict_exact_match_agg_recall",
+ "DictExactStrMatchAggRecall",
+ ),
+ MetricType.EXACT_STR_MATCH_CASE_INSENSITIVE: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.exact_str_match_case_insensitive",
+ "ExactStrMatchCaseInsensitive",
+ ),
+ MetricType.NORM_SIM_DAMERAU_LEVENSHTEIN: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.normalized_similarity_damerau_levenshtein",
+ "NormalizedSimilarityDamerauLevenshtein",
+ ),
+ MetricType.NEAR_STR_MATCH: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.near_str_match", "NearStrMatch"
+ ),
+ MetricType.NUMBER_RELATIVE_DIFF_RATIO: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.number_rel_diff_ratio", "NumberRelDiffRatio"
+ ),
+ MetricType.SET_EQUALITY: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.set_equality", "SetEquality"
+ ),
+ MetricType.SET_EQUALITY_CASE_INSENSITIVE: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.set_equality", "SetEqualityCaseInsensitive"
+ ),
+ MetricType.DICT_SET_EQUALITY_AGG_JACCARD: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.dict_set_equality_agg_jaccard",
+ "DictSetEqualityAggJaccard",
+ ),
+ MetricType.DICT_EQUALITY: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.dict_equality",
+ "DictEquality",
+ ),
+ MetricType.DICT_PRECISION: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.dict_equality",
+ "DictPrecision",
+ ),
+ MetricType.JACCARD_INDEX: lazy_import("vlmeval.dataset.utils.megabench.scoring.jaccard", "Jaccard"),
+ MetricType.JACCARD_INDEX_CASE_INSENSITIVE: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.jaccard", "JaccardCaseInsensitive"
+ ),
+ MetricType.DICT_JACCARD_AGG_JACCARD: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.dict_jaccard_agg_jaccard", "DictJaccardAggJaccard"
+ ),
+ MetricType.SET_PRECISION: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.set_precision", "SetPrecision"
+ ),
+ MetricType.POSITIVE_INT_MATCH: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.positive_int_match", "PositiveIntMatch"
+ ),
+ MetricType.CHESS_MOVE_LIST_JACCARD_INDEX: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.chess_jaccard", "ChessMoveJaccard"
+ ),
+ MetricType.LONGEST_COMMON_LIST_PREFIX_RATIO: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.longest_common_list_prefix_ratio",
+ "LongestCommonListPrefixRatio",
+ ),
+ MetricType.ASCII_ART_GPT4O_JUDGE: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.ascii_art_gpt4o_judge",
+ "AsciiArtVLMJudgeScore",
+ ),
+ MetricType.NLI_ENTAILMENT: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.nli_entailment", "NliEntailment"
+ ),
+ MetricType.BLEU: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.sacrebleu_bleu",
+ "Bleu",
+ ),
+ MetricType.GLEU_CN: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.gleu",
+ "GLEUChinese",
+ ),
+ MetricType.XML_NORM_BBOX_IOU_SINGLE: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.xml_nbbox_iou", "XmlNbboxIouSingle"
+ ),
+ MetricType.BOXED_SINGLE_NUMERICAL_MATCH: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.general_numerical_match", "BoxedSingleNumericalMatch"
+ ),
+ MetricType.GENERAL_SINGLE_NUMERICAL_MATCH: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.general_numerical_match", "GeneralSingleNumericalMatch"
+ ),
+ MetricType.SEQUENCE_COORDS_SIMILARITY: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.coordinate_sequence_match", "CoordsSequenceSimilarity"
+ ),
+ MetricType.LATEX_EXPR_EQUALITY: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.latex_expr_equality",
+ "LatexExprEquality",
+ ),
+ MetricType.TEXT_WITH_LATEX_EXPR_EQUALITY: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.latex_expr_equality",
+ "TextLatexExprEquality",
+ ),
+ MetricType.NORM_BBOX_IOU_TUPLE: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.nbbox_iou", "NbboxIouTuple"
+ ),
+ MetricType.NORM_BBOX_IOU_SINGLE: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.nbbox_iou", "NbboxIouSingle"
+ ),
+ MetricType.NORM_BBOX_IOU_SEQUENCE: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.nbbox_iou", "NbboxIouSequence"
+ ),
+ MetricType.DICT_NORM_BBOX_IOU_TUPLE_AGG_JACCARD: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.dict_nbbox_iou_tuple_agg_jaccard",
+ "DictNbboxIouTupleAggJaccard",
+ ),
+ MetricType.XML_NORM_POINT_IN_BBOX: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.xml_norm_point_in_bbox",
+ "XmlNormPointInBbox",
+ ),
+ MetricType.XML_NORM_POINT_DISTANCE: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.xml_norm_point_distance",
+ "XmlNormPointDistance",
+ ),
+ MetricType.GEO_PROXIMITY_LOCATION_DICT: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.geo_proximity", "GeoProximityLocationDict"
+ ),
+ MetricType.NORMALIZED_RMSE: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.mse", "NormalizedRMSE"
+ ),
+ MetricType.PROGRAM_JUDGE: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.program_judge", "ProgramJudge"
+ ),
+ MetricType.STR_SET_EQUALITY_LINE_BREAK: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.set_equality", "StringSetEqualityLineSplit"
+ ),
+ MetricType.STR_SET_EQUALITY_COMMA: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.set_equality", "StringSetEqualityCommaSplit"
+ ),
+ MetricType.SEQUENCE_EQUALITY: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.sequence_equality", "SequenceEquality"
+ ),
+ MetricType.SEQUENCE_EQUALITY_CASE_INSENSITIVE: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.sequence_equality", "SequenceEqualityCaseInsensitive"
+ ),
+ MetricType.SEQUENCE_ACCURACY_CASE_INSENSITIVE: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.sequence_equality", "SequenceAccuracyCaseInsensitive"
+ ),
+ MetricType.ANGLE_SEQ_FLOAT_RMSE: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.mse", "AngleSeqFloatRMSE"
+ ),
+ MetricType.SYMBOLIC_PLANNING_TEST: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.symbolic_planning", "SymbolicPlanningMetricTest"
+ ),
+ MetricType.MULTI_REF_PHRASE_EVAL: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.multi_ref_phrase", "MultipleReferencePhraseEval"
+ ),
+ MetricType.CONSTRAINED_GENERATION: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.constrained_generation", "ConstrainedGenerationEval"
+ ),
+ MetricType.VLM_AS_JUDGE: lazy_import(
+ "vlmeval.dataset.utils.megabench.scoring.vlm_as_judge", "VLMJudgeScore"
+ ),
+ }
+
+ if self not in lazy_imports:
+ logging.error(f"Metric {self} not implemented...")
+
+ importer = lazy_imports.get(
+ self,
+ lazy_import("vlmeval.dataset.utils.megabench.scoring.unsupported_scoring", "UnsupportedScoring"),
+ )
+ return importer()
+
+ def match(self, response: str, correct_answer: str, task_info=None):
+ if not task_info:
+ return self.class_impl.match(response, correct_answer)
+ else:
+ return self.class_impl.match(response, correct_answer, task_info)
+
+ @classmethod
+ def from_string(cls, s):
+ try:
+ if s is None:
+ return cls("unsupported")
+ return cls(s.lower())
+ except KeyError as exc:
+ raise ValueError(f"Invalid metric type: {s}") from exc
+
+ @classmethod
+ def get_all_values(cls):
+ return list(cls)
+
+
+# List all of the supported metrics:
+if __name__ == "__main__":
+ print("All MetricType values:")
+ for metric_type in MetricType.get_all_values():
+ print(f"{metric_type.name}: {metric_type.value}")
diff --git a/vlmeval/dataset/utils/megabench/parsing/answer_str_parse.py b/vlmeval/dataset/utils/megabench/parsing/answer_str_parse.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ecdaf6c672b837909b52a7e2213fe457545111b
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/parsing/answer_str_parse.py
@@ -0,0 +1,137 @@
+import logging
+from .common.parsers import parse_json
+from .common.utils import (
+ extract_code_block_content,
+ extract_answer_content,
+ evaluate_as_string,
+ drop_additional_text,
+)
+
+logger = logging.getLogger("errorLogger")
+
+
+class AnswerStrParse:
+ """Parse the response for the single answer field."""
+
+ @classmethod
+ def _parse(
+ cls,
+ response: str,
+ *,
+ is_ascii_art: bool = False,
+ should_remove_surrounding_whitespace=True,
+ global_description: str = "",
+ query_question: str = "",
+ is_single_line_ans: bool = None,
+ ) -> dict:
+ """Try to parse a single answer."""
+ if response is None:
+ response = ""
+
+ # Extract the answer content based on "Answer: ..." format
+ answer_content = extract_answer_content(
+ response,
+ is_ascii_art=is_ascii_art,
+ should_remove_surrounding_whitespace=should_remove_surrounding_whitespace,
+ )
+
+ # Extract things from the code block if response is wrapped by a code block
+ answer_content, is_code = extract_code_block_content(
+ answer_content,
+ is_ascii_art=is_ascii_art,
+ should_remove_surrounding_whitespace=should_remove_surrounding_whitespace,
+ )
+
+ if not is_code and is_single_line_ans and not is_ascii_art:
+ answer_content = drop_additional_text(answer_content)
+
+ # Check if the content is a potential dict or list.
+ if answer_content.startswith("{") or answer_content.startswith("["):
+ # Attempt to parse the content as JSON
+ response_obj = parse_json(answer_content)
+ if response_obj == {}:
+ if "{}" not in answer_content:
+ return answer_content
+ elif response_obj == []:
+ # logger.error(
+ # f"Unexpected answer parsing error:\n{response=}\n{global_description=}\n{query_question=}\n{is_ascii_art=}"
+ # )
+ if "[]" not in answer_content:
+ return answer_content
+ return str(response_obj) # make sure the response to the metric is always a string
+ else:
+ # drop the redundant string quotes
+ answer_content = evaluate_as_string(answer_content)
+ return answer_content
+
+ @classmethod
+ def parse(
+ cls,
+ response: str,
+ answer_key: str,
+ *,
+ global_description: str = "",
+ query_question: str = "",
+ is_single_line_ans: bool = None,
+ ) -> dict:
+ """Try to parse a single answer."""
+ response_parsed = cls._parse(
+ response,
+ is_ascii_art=False,
+ global_description=global_description,
+ query_question=query_question,
+ is_single_line_ans=is_single_line_ans,
+ )
+ results = {answer_key: response_parsed}
+ return results
+
+
+class AsciiAnswerStrParse(AnswerStrParse):
+ """Parse the response for the single ASCII answer field."""
+
+ @classmethod
+ def parse(
+ cls,
+ response: str,
+ answer_key: str,
+ *,
+ global_description: str = "",
+ query_question: str = "",
+ is_single_line_ans: bool = None,
+ ) -> dict:
+ """Try to parse a single answer."""
+ response_parsed = cls._parse(
+ response,
+ is_ascii_art=True,
+ global_description=global_description,
+ query_question=query_question,
+ is_single_line_ans=is_single_line_ans,
+ )
+ results = {answer_key: response_parsed}
+ return results
+
+
+class VerbatimAnswerStrParse(AnswerStrParse):
+ """Parse the response for a single answer field that should not have preceding or trailing whitespace removed."""
+
+ @classmethod
+ def parse(
+ cls,
+ response: str,
+ answer_key: str,
+ *,
+ global_description: str = "",
+ query_question: str = "",
+ is_single_line_ans: bool = None,
+ ) -> dict:
+ """Try to parse a single answer."""
+ response_parsed = cls._parse(
+ response,
+ is_ascii_art=True,
+ should_remove_surrounding_whitespace=False,
+ global_description=global_description,
+ query_question=query_question,
+ is_single_line_ans=is_single_line_ans,
+ )
+ results = {answer_key: response_parsed}
+ return results
diff --git a/vlmeval/dataset/utils/megabench/parsing/common/parsers.py b/vlmeval/dataset/utils/megabench/parsing/common/parsers.py
new file mode 100644
index 0000000000000000000000000000000000000000..b3d652a83365b1ef162642390007f6c3651f7702
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/parsing/common/parsers.py
@@ -0,0 +1,145 @@
+import ast
+import json
+import re
+import regex # Supports the non-standard ?R regex operator
+from typing import List
+from .utils import extract_code_block_content, extract_answer_at_beginning_of_line
+
+
+PARSING_TIMEOUT = 0.1
+
+
+def parse_json(response: str):
+ """Parse the JSON object, including nested JSON strings."""
+
+ response_ = extract_answer_at_beginning_of_line(response)
+
+ # If it's wrapped in code block like json, drop it
+ response_, _ = extract_code_block_content(response_, "json")
+
+ # Regular expression to match JSON-like structures, including nested quotes
+ json_pattern = r"(\{(?:[^{}]|(?R))*\}|\[(?:[^{}]|(?R))*\])"
+ string_pattern = r'"(?:\\.|[^"\\])*"'
+
+ # Find all potential JSON objects
+ try:
+ potential_jsons = regex.findall(
+ json_pattern, response_, timeout=PARSING_TIMEOUT
+ )
+ except TimeoutError:
+ if response_.startswith("["):
+ return []
+ return {}
+
+ valid_jsons = []
+
+ for potential_json in potential_jsons:
+ # Replace escaped quotes with a placeholder
+ potential_json = potential_json.replace('\\"', "__DOUBLE_QUOTE__")
+ potential_json = potential_json.replace("\\'", "__SINGLE_QUOTE__")
+
+ # Find all string literals
+ strings = regex.findall(string_pattern, potential_json)
+
+ # Process each string literal
+ for s in strings:
+ # Unescape the string content
+ unescaped = (
+ s[1:-1]
+ .replace("__DOUBLE_QUOTE__", '"')
+ .replace("__SINGLE_QUOTE__", "'")
+ )
+ # Try to parse it as JSON
+ try:
+ parsed = json.loads(unescaped)
+ if isinstance(parsed, (dict, list)):
+ # If it's a valid JSON object or array, replace it in the original string
+ potential_json = potential_json.replace(s, json.dumps(parsed))
+ except json.JSONDecodeError:
+ pass
+
+ # Restore escaped quotes
+ potential_json = potential_json.replace("__DOUBLE_QUOTE__", '\\"')
+ potential_json = potential_json.replace("__SINGLE_QUOTE__", "\\'")
+
+ try:
+ # Attempt to parse the potential JSON
+ json_object = json.loads(potential_json)
+ valid_jsons.append(json_object)
+ except json.JSONDecodeError:
+ # try to update single quote to double quote for some special failure case
+ # caused by quote's type
+ potential_json_ = re.sub(r"(? List[List[int]]:
+ """Convert a bunch of syllable ranges into a list of intervals.
+
+ Examples:
+ parse_syllable_ranges('[7,10][7, 10][5,7][5,7][7,10]')
+ >>> [[7, 10], [7, 10], [5, 7], [5, 7], [7, 10]]
+ parse_syllable_ranges('575 575')
+ >>> [[5, 5], [7, 7], [5, 5], [0, 0], [5, 5], [7, 7], [5, 5]]
+ parse_syllable_ranges('[11]5')
+ >>> [[11, 11], [5, 5]]
+ """
+
+ def convert_to_range(match):
+ match = match.strip("[]")
+ if "," in match:
+ start, end = map(int, match.split(","))
+ return [start, end]
+ elif match == " ":
+ return [0, 0]
+ else:
+ num = int(match)
+ return [num, num]
+
+ # Split the input string into chunks
+ chunks = re.findall(r"(?:\[\d+(?:,\s*\d+)?\]|\d| )", input_str.strip())
+
+ # Convert each chunk to a range and create the result list
+ result = [convert_to_range(chunk) for chunk in chunks]
+
+ return result
diff --git a/vlmeval/dataset/utils/megabench/parsing/common/utils.py b/vlmeval/dataset/utils/megabench/parsing/common/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..75e6f5fae8e1e319faafa511a5838c31d6ef28e3
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/parsing/common/utils.py
@@ -0,0 +1,138 @@
+import re
+import ast
+
+
+def extract_code_block_content(
+ response,
+ code_type=None,
+ is_ascii_art: bool = False,
+ should_remove_surrounding_whitespace=True,
+):
+ # If code_type is specified, construct the pattern to match that specific code block
+ if code_type:
+ pattern = rf"```{code_type}\s*\n*(.*?)\s*```"
+ elif is_ascii_art:
+ if not response.strip() or len(response) > 10000:
+ # handle the special case of pure whitespace or super long empty string
+ response = response.rstrip()
+ if should_remove_surrounding_whitespace:
+ pattern = r"```\w*(?:\s*\n+)?(.*?)\s*```"
+ else:
+ pattern = r"```\w*(?:\s*\n+)?(.*?)(?:\n+\s*)?```"
+ else:
+ # If code_type is None, match any code block
+ pattern = r"```\w*\s*\n*(.*?)\s*```"
+
+ # Search for the code block in the response
+ match = re.search(pattern, response, flags=re.DOTALL)
+
+ if match:
+ # If a match is found, return the content inside the code block
+ if is_ascii_art:
+ return match.group(1), True
+ else:
+ return match.group(1).strip(), True
+ else:
+ # If no code block is found, return the original string
+ return response, False
+
+
+def extract_answer_content(
+ response, is_ascii_art=False, should_remove_surrounding_whitespace=True
+):
+ if is_ascii_art:
+ match = re.search(r"\*\*?Answer:(.*?)\*\*?|\bAnswer:(.*)", response, re.DOTALL)
+ else:
+ match = re.search(
+ r"\*\*?Answer:\s*(.*?)\*\*?|\bAnswer:\s*(.*)", response, re.DOTALL
+ )
+ if match:
+ # Extract the content after "Answer:"
+ response = match.group(1) or match.group(
+ 2
+ ) # Return the first capturing group or second if the first is None
+ if response is None:
+ response = ""
+ if is_ascii_art:
+ # Reduce anything that is more than one blank line to a single blank line.
+ response = re.sub(r"^\s*$(\n^\s*$)+", "", response, flags=re.MULTILINE)
+
+ if should_remove_surrounding_whitespace:
+ # Remove trailing whitespace
+ response = response.rstrip()
+ else:
+ # Remove trailing blank lines
+ response = re.sub(r"(\n\s*)+$", "", response)
+ # Remove leading blank lines
+ response = re.sub(r"^(\s*\n)+", "", response)
+ else:
+ response = response.strip()
+
+ return response
+
+
+def extract_answer_at_beginning_of_line(response):
+ # Regular expression to match either "Answer:" or "**Answer:**" at the beginning of a new line
+ match = re.search(r"^(?:\*\*Answer:|Answer:)\s*(.+)", response, re.MULTILINE)
+
+ if match:
+ # Return the content after "Answer:" or "**Answer: **"
+ return match.group(1).strip()
+ else:
+ # Return None if no match is found
+ return response.strip()
+
+
+def drop_additional_text(result):
+ # Heuristic to catch multiple-choice queries. Does not use metadata.json.
+ result_first_paragraph = result.split("\n\n")[0].strip()
+ potential_ans_in_single_line = re.search(
+ r"^(?:(?:[a-zA-Z0-9_-]+)(?:,\s*[a-zA-Z0-9_-]+)*|(?:[a-zA-Z0-9_-]+)\.|\((?:[a-zA-Z0-9_-]+)\)$)",
+ result_first_paragraph,
+ )
+
+ only_return_first_paragraph = (
+ potential_ans_in_single_line
+ and result_first_paragraph.strip() != ""
+ and not _is_multiline_answer(result)
+ )
+
+ if only_return_first_paragraph:
+ return result_first_paragraph
+ else:
+ return result
+
+
+def _is_multiline_answer(text):
+ # Split the text into lines
+ lines = text.splitlines()
+
+ # Find the "Answer:" line
+ for i, line in enumerate(lines):
+ stripped_line = line.strip()
+ if stripped_line != "":
+ # Check if the next line (second line after "Answer:") is blank
+ if i + 1 < len(lines) and lines[i + 1].strip() == "":
+ return False # Second line is blank, single-line answer,
+ # remaining parts are additional
+ return True # Second line is not blank, multi-line answer
+
+ return False # empty result found, treat as single-line
+
+
+def evaluate_as_string(s):
+ try:
+ # Try to evaluate the string using ast.literal_eval
+ evaluated = ast.literal_eval(s)
+ # If it's a valid Python string, return it
+ if isinstance(evaluated, str):
+ return evaluated
+ else:
+ # If it's not a string, return the original input
+ return s
+ except (ValueError, SyntaxError):
+ # If it's not valid, return the original input
+ return s
+ except MemoryError:
+ # the result overflows, simply return an empty string
+ return ""
diff --git a/vlmeval/dataset/utils/megabench/parsing/dummy_parse.py b/vlmeval/dataset/utils/megabench/parsing/dummy_parse.py
new file mode 100644
index 0000000000000000000000000000000000000000..21b5a2b15148cbd5416f61a1d72d39a46eb6b35a
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/parsing/dummy_parse.py
@@ -0,0 +1,6 @@
+class DummyParse:
+
+ @staticmethod
+ def parse(response: str, *args, **kwargs) -> dict:
+ """return the raw string without doing anything"""
+ return response.strip()
diff --git a/vlmeval/dataset/utils/megabench/parsing/json_parse.py b/vlmeval/dataset/utils/megabench/parsing/json_parse.py
new file mode 100644
index 0000000000000000000000000000000000000000..1bc91313a4ce9c49e586f7b81acc92198fa68fe8
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/parsing/json_parse.py
@@ -0,0 +1,17 @@
+from .common.parsers import parse_json
+from .common.utils import evaluate_as_string
+
+
+class JsonParse:
+ """Load the response as a JSON object."""
+
+ @staticmethod
+ def parse(response: str):
+ """Parse the JSON object, including nested JSON strings."""
+ parsed_res = parse_json(response)
+ # Drop the potentially duplicated string quotes
+ if isinstance(parsed_res, dict):
+ for key, val in parsed_res.items():
+ parsed_res[key] = evaluate_as_string(val)
+
+ return parsed_res
diff --git a/vlmeval/dataset/utils/megabench/requirements.txt b/vlmeval/dataset/utils/megabench/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bc7e2d9758a7c1e2b97ab147aa16189e320ac912
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/requirements.txt
@@ -0,0 +1,15 @@
+antlr4-python3-runtime==4.11.0
+filelock==3.16.1
+geopy==2.4.1
+jieba==0.42.1
+nltk==3.9.1
+numpy==1.26.4
+pronouncing==0.2.0
+rapidfuzz==3.9.5
+regex==2024.7.24
+requests==2.32.3
+requests_cache==1.2.1
+sacrebleu==2.4.3
+sympy==1.13.2
+tqdm==4.66.4
+Unidecode==1.3.8
diff --git a/vlmeval/dataset/utils/megabench/response_parse_type.py b/vlmeval/dataset/utils/megabench/response_parse_type.py
new file mode 100644
index 0000000000000000000000000000000000000000..9db9b7ff7bf260c3dad3df8a1ca55cedff3f17bb
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/response_parse_type.py
@@ -0,0 +1,54 @@
+from functools import cached_property
+from enum import Enum
+from .parsing.json_parse import JsonParse
+from .parsing.answer_str_parse import (
+ AnswerStrParse,
+ AsciiAnswerStrParse,
+ VerbatimAnswerStrParse,
+)
+from vlmeval.dataset.utils.megabench.parsing.dummy_parse import DummyParse
+
+
+class ResponseParseType(Enum):
+ """Parse the response."""
+
+ JSON = "json"
+ ANSWER_STR = "answer_string"
+ ASCII_ANSWER_STR = "ascii_answer_string"
+ VERBATIM_ANSWER_STR = "verbatim_answer_string"
+ DUMMY = "dummy"
+ UNSUPPORTED = "unsupported"
+
+ @cached_property
+ def class_impl(self):
+ if self == ResponseParseType.ANSWER_STR:
+ return AnswerStrParse
+ elif self == ResponseParseType.ASCII_ANSWER_STR:
+ return AsciiAnswerStrParse
+ elif self == ResponseParseType.VERBATIM_ANSWER_STR:
+ return VerbatimAnswerStrParse
+ elif self == ResponseParseType.DUMMY:
+ return DummyParse
+ else:
+ return JsonParse
+
+ def is_single_field_parser(self):
+ return self in [
+ ResponseParseType.ANSWER_STR,
+ ResponseParseType.ASCII_ANSWER_STR,
+ ResponseParseType.VERBATIM_ANSWER_STR,
+ ]
+
+ def parse(self, response: str, *args, **kwargs):
+ """Parse the response."""
+ return self.class_impl.parse(response, *args, **kwargs)
+
+ @staticmethod
+ def from_string(s):
+ """Initialize the response parsing type from a string."""
+ try:
+ if s is None:
+ return ResponseParseType("unsupported")
+ return ResponseParseType(s.lower())
+ except KeyError as exc:
+ raise ValueError(f"Invalid metric type: {s}") from exc
diff --git a/vlmeval/dataset/utils/megabench/scoring/ascii_art_gpt4o_judge.py b/vlmeval/dataset/utils/megabench/scoring/ascii_art_gpt4o_judge.py
new file mode 100644
index 0000000000000000000000000000000000000000..412d7a11492e1423561938ddb2fc671a941f1ad0
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/ascii_art_gpt4o_judge.py
@@ -0,0 +1,126 @@
+"""Return if two ASCII art images depict the same thing."""
+
+import logging
+from numbers import Number
+import os
+import requests
+from .common.conversions import ascii_text_to_image
+from .vlm_as_judge import OpenAIVLMJudger
+"""Return if two ASCII art images depict the same thing."""
+
+
+class AsciiArtGPT4OJudge(OpenAIVLMJudger):
+ """A GPT-4o judge for assessing if two ASCII art images depict the same thing."""
+
+ def __init__(self, metric_config, model="gpt-4o-2024-08-06"):
+ self.eval_prompt = """Determine if the following two ASCII art images depict the same object.
+ Your answer should be either "yes" or "no", but without the quotation marks."""
+ super().__init__(
+ metric_config,
+ model,
+ )
+
+ def encode_image(self, image):
+ """Encode an image into base64 and return its mime type."""
+ mime_type = "image/jpeg"
+ image_format = "JPEG"
+
+ if image.mode == "RGBA":
+ image = self._rgba_to_rgb(image)
+
+ if self.resize and max(image.size) > self.max_side:
+ image = self._resize_image(image)
+ encoded_image = self._encode_image(image, image_format)
+ else:
+ encoded_image = self._encode_image(image, image_format)
+
+ return encoded_image, mime_type
+
+ def create_image_content(self, image):
+ base64_image, mime_type = self.encode_image(image)
+ return {
+ "type": "image_url",
+ "image_url": {"url": f"data:{mime_type};base64,{base64_image}"},
+ }
+
+ def prepare_eval_prompt(self, images):
+ """Prepare the evaluation prompt."""
+ content = []
+ for image_path in images:
+ content.append(self.create_image_content(image_path))
+
+ content.append({"type": "text", "text": self.eval_prompt})
+ return content
+
+ def query(self, images):
+ """Query GPT4o to determine if the ASCII images show the same thing."""
+ headers = {
+ "Content-Type": "application/json",
+ "Authorization": f"Bearer {self.api_key}",
+ }
+
+ context = self.prepare_eval_prompt(images)
+
+ query_payload = {
+ "model": self.model,
+ "messages": [{"role": "user", "content": context}],
+ "temperature": 0.0,
+ }
+
+ response_data = None
+ while response_data is None:
+ try:
+ response = requests.post(
+ self.url,
+ headers=headers,
+ json=query_payload,
+ )
+ except (requests.exceptions.JSONDecodeError, requests.exceptions.ConnectionError) as e:
+ print(f'Error in requests: {e}')
+ print('Retry...')
+ continue
+
+ response_ = response.json()
+ if "error" in response_:
+ error_info = response_["error"]
+ print(
+ f"Got error with type: {error_info['type']}. Message: {error_info['message']}"
+ )
+ print("Retry...")
+ else:
+ response_data = response_
+ break
+
+ total_tokens = response_data.get("usage", {}).get("total_tokens", "N/A")
+
+ if response_data and "choices" in response_data:
+ choices = response_data["choices"]
+ if choices and "message" in choices[0]:
+ message_content = choices[0]["message"]["content"]
+ print(
+ f"gpt-4o judge results: {message_content}; tokens:{total_tokens}"
+ )
+ else:
+ print("gpt-4o judge query failed...")
+ message_content = ""
+
+ return message_content
+
+
+class AsciiArtVLMJudgeScore:
+ """Compute the cosine similarity between two pieces of ASCII art."""
+
+ def __init__(self, metric_config):
+ self.model = AsciiArtGPT4OJudge(metric_config)
+
+ def match(self, response, correct_answer) -> Number:
+ """Compute the cosine similarity between two pieces of ASCII art."""
+ if not isinstance(response, str) or not isinstance(correct_answer, str):
+ return 0
+ if not response:
+ return 0
+ response_image = ascii_text_to_image(response, 224, 224)
+ correct_answer_image = ascii_text_to_image(correct_answer, 224, 224)
+
+ eval_results = self.model.query([response_image, correct_answer_image])
+ return 1 if "yes" in eval_results.lower() else 0
diff --git a/vlmeval/dataset/utils/megabench/scoring/chess_jaccard.py b/vlmeval/dataset/utils/megabench/scoring/chess_jaccard.py
new file mode 100644
index 0000000000000000000000000000000000000000..e128e1cd09c78e0b73c25248ace0e4af31d5536d
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/chess_jaccard.py
@@ -0,0 +1,24 @@
+import logging
+from typing import Dict, Any
+from .common.conversions import str_to_set
+from .common.metrics import jaccard_index
+
+
+def chess_transform(move_sequence: str) -> set:
+ """Transform a sequence of chess moves encoded in SAN into a set."""
+ move_sequence = str_to_set(move_sequence)
+ return {move_san.removesuffix("!").removesuffix("#") for move_san in move_sequence}
+
+
+class ChessMoveJaccard:
+ """Calculates the Jacard index for chess moves."""
+
+ @classmethod
+ def match(cls, responses: str | None, targets: str) -> float:
+ """Exact match between targets and responses."""
+ if responses is None:
+ return 0
+ responses = chess_transform(responses)
+ targets = chess_transform(targets)
+
+ return jaccard_index(responses, targets)
diff --git a/vlmeval/dataset/utils/megabench/scoring/common/conversions.py b/vlmeval/dataset/utils/megabench/scoring/common/conversions.py
new file mode 100644
index 0000000000000000000000000000000000000000..932132323d2c78e0fb8f07cd421bc034bad6cf95
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/common/conversions.py
@@ -0,0 +1,244 @@
+import ast
+import json
+import re
+from matplotlib import font_manager
+from PIL import Image, ImageDraw, ImageFont
+from ...parsing.common.parsers import parse_json
+from numbers import Number
+from typing import Tuple, Union
+
+
+def freeze_structure(obj):
+ """Freeze a structure and make it hashable."""
+ if isinstance(obj, dict):
+ return frozenset((k, freeze_structure(v)) for k, v in obj.items())
+ elif isinstance(obj, (list, tuple)):
+ return tuple(freeze_structure(item) for item in obj)
+ elif isinstance(obj, set):
+ return frozenset(obj)
+ else:
+ return obj
+
+
+def cast_to_set(object) -> set:
+ """Try to cast an object as a set."""
+ object = freeze_structure(object)
+ if isinstance(object, (frozenset, set, tuple)):
+ return set(object)
+ return str_to_set(object)
+
+
+def cast_to_dict(object) -> dict:
+ """Try to cast an object as a dict."""
+ if isinstance(object, dict):
+ return {key: cast_to_dict(val) for key, val in object.items()}
+ elif isinstance(object, str):
+ extract_json_attempt = parse_json(object)
+ if extract_json_attempt:
+ return extract_json_attempt
+ return object
+ else:
+ return object
+
+
+def str_to_iterable(func, iterable_str):
+ """Converts a string representation of an iterable to an iterable."""
+ if not isinstance(iterable_str, str):
+ return func()
+
+ iterable_str = iterable_str.strip(" ")
+ if not iterable_str:
+ return func()
+
+ is_in_iterable = True
+ if iterable_str[0] == "(":
+ if not iterable_str.endswith(")"):
+ return func()
+ elif iterable_str[0] == "{":
+ if not iterable_str.endswith("}"):
+ return func()
+ elif iterable_str[0] == "[":
+ if not iterable_str.endswith("]"):
+ return func()
+ else:
+ is_in_iterable = False
+
+ # We may have a nested object, so try to use eval first
+ try:
+ eval_ = ast.literal_eval(iterable_str)
+ if eval_ is None:
+ return ""
+ if isinstance(eval_, (int, float)):
+ eval_ = [
+ eval_,
+ ]
+ return func(eval_)
+ except (SyntaxError, ValueError):
+ if is_in_iterable:
+ iterable_str = iterable_str[1:-1]
+ items = [item.strip() for item in iterable_str.split(",")]
+ return func(items)
+
+
+def str_to_set(iterable_str) -> set:
+ """Converts a string representation of an iterable to a set."""
+ return str_to_iterable(set, iterable_str)
+
+
+def str_to_list(iterable_str) -> set:
+ """Converts a string representation of an iterable to a set."""
+ return str_to_iterable(list, iterable_str)
+
+
+def str_to_bboxes(bbox_list) -> list:
+ if not isinstance(bbox_list, str):
+ return []
+ try:
+ bboxes = ast.literal_eval(bbox_list)
+ except (SyntaxError, ValueError):
+ try:
+ bboxes = json.loads(bbox_list)
+ except json.JSONDecodeError:
+ return []
+
+ if len(bboxes) == 4 and isinstance(bboxes[0], Number):
+ bboxes = [bboxes]
+
+ if not isinstance(bboxes, (tuple | list)):
+ return []
+
+ new_bboxes = []
+ for bbox in bboxes:
+ if not isinstance(bbox, (tuple, list)) or len(bbox) != 4:
+ continue
+ if any(not isinstance(coord, (float, int)) for coord in bbox):
+ continue
+ new_bboxes.append(bbox)
+ return new_bboxes
+
+
+def str_to_coords(coord_list, dim=2) -> list:
+ if not isinstance(coord_list, str):
+ return []
+ try:
+ coords = ast.literal_eval(coord_list)
+ except SyntaxError:
+ try:
+ coords = json.loads(coord_list)
+ except json.JSONDecodeError:
+ return []
+
+ new_coords = []
+ for coord in coords:
+ if not isinstance(coord, (tuple, list)) or len(coord) != dim:
+ continue
+ if any(not isinstance(coord, (float, int)) for coord in coord):
+ continue
+ new_coords.append(coord)
+ return new_coords
+
+
+def parse_point_2d_from_xml(xml_string) -> Union[Tuple[float, float], None]:
+ """Parse an (x, y) point from XML formatted like this: x, y """
+ if not isinstance(xml_string, str):
+ return None
+
+ point_pattern = re.compile(r"(.*?)<\/point>")
+ matches = point_pattern.findall(xml_string)
+ if len(matches) >= 2:
+ return None
+
+ if matches:
+ coords = matches[0].split(",")
+ if len(coords) != 2:
+ return None
+ try:
+ return tuple(float(coord.strip()) for coord in coords)
+ except ValueError:
+ return None
+
+
+def parse_bboxes_from_xml(xml_string: str) -> list:
+
+ if not isinstance(xml_string, str):
+ return []
+
+ bbox_pattern = re.compile(r"(.*?)<\/box>")
+ matches = bbox_pattern.findall(xml_string)
+
+ new_bboxes = []
+ for match in matches:
+
+ coords = match.split(",")
+ if len(coords) != 4:
+ continue
+ try:
+ bbox = tuple(float(coord.strip()) for coord in coords)
+ except ValueError:
+ continue
+
+ if len(bbox) == 4 and all(isinstance(coord, float) for coord in bbox):
+ new_bboxes.append(bbox)
+
+ return new_bboxes
+
+
+MONOSPACE_FONTS = ("Courier New", "DejaVu Sans Mono", "Consolas", "SF Mono")
+
+MONOSPACE_FONT_FILES = []
+for font_name in MONOSPACE_FONTS:
+ try:
+ MONOSPACE_FONT_FILES.append(
+ font_manager.findfont(font_name, fallback_to_default=False)
+ )
+ except ValueError:
+ continue
+
+
+def ascii_text_to_image(
+ text,
+ width,
+ height,
+ font_size=20,
+ padding=10,
+ line_spacing=1,
+ bg_color="white",
+ text_color="black",
+):
+ """Convert ASCII text into an image."""
+ # Split the text into lines
+ lines = text.splitlines()
+
+ # Calculate initial image size based on text
+ char_width = font_size * 0.6 # Approximate width of a character
+ init_width = int(max(len(line) for line in lines) * char_width + 2 * padding)
+ init_height = int(
+ (len(lines) * font_size * line_spacing) + 2 * padding
+ ) # 1.2 for line spacing
+
+ # Create a new image with the calculated size
+ image = Image.new("RGB", (init_width, init_height), color=bg_color)
+ draw = ImageDraw.Draw(image)
+
+ # Load a monospace font
+ font = None
+ for font_name in MONOSPACE_FONT_FILES:
+ try:
+ font = ImageFont.truetype(font_name, font_size)
+ break
+ except IOError:
+ continue
+ if font is None:
+ raise ValueError("Cannot properly render ASCII art: missing monospace font.")
+
+ # Draw each line of text
+ y_text = padding
+ for line in lines:
+ draw.text((padding, y_text), line, font=font, fill=text_color)
+ y_text += font_size * line_spacing # Move to the next line
+
+ # Resize the image to the specified dimensions
+ image = image.resize((width, height), Image.Resampling.LANCZOS)
+
+ # Convert the image to a NumPy array
+ return image
diff --git a/vlmeval/dataset/utils/megabench/scoring/common/metrics.py b/vlmeval/dataset/utils/megabench/scoring/common/metrics.py
new file mode 100644
index 0000000000000000000000000000000000000000..8b7b2807910413593187c94c91259fb1b16d5151
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/common/metrics.py
@@ -0,0 +1,102 @@
+from collections.abc import Iterable
+import math
+from numbers import Number
+
+
+def calculate_iou(predicted: Iterable[Number], target: Iterable[Number]):
+ """Calculate the IoU between predicted and target bounding boxes."""
+
+ def box_area(box):
+ return (box[2] - box[0]) * (box[3] - box[1])
+
+ def box_iou(box1, box2):
+ # Calculate intersection coordinates
+ x1 = max(box1[0], box2[0])
+ y1 = max(box1[1], box2[1])
+ x2 = min(box1[2], box2[2])
+ y2 = min(box1[3], box2[3])
+
+ # Calculate intersection area
+ intersection = max(0, x2 - x1) * max(0, y2 - y1)
+
+ # Calculate union area
+ box1_area = box_area(box1)
+ box2_area = box_area(box2)
+ union = box1_area + box2_area - intersection
+
+ # Calculate IoU
+ iou = intersection / union if union > 0 else 0
+ return iou
+
+ # Calculate IoU for each pair of predicted and target boxes
+ iou_scores = []
+ for pred_box in predicted:
+ best_iou = 0
+ for target_box in target:
+ iou = box_iou(pred_box, target_box)
+ best_iou = max(best_iou, iou)
+ iou_scores.append(best_iou)
+
+ return iou_scores
+
+
+def set_relevance_score(denominator_fn, predicted: Iterable, target: Iterable) -> float:
+ """Calculate the relevance score."""
+ pred = set(predicted)
+ tget = set(target)
+ denominator = denominator_fn(pred, tget)
+ if not denominator:
+ return 1
+ return len(pred & tget) / denominator
+
+
+def _union_denominator(pred: set, tget: set) -> int:
+ return len(pred | tget)
+
+
+def _pred_denominator(pred: set, _: set) -> int:
+ return len(pred)
+
+
+def _tget_denominator(_: set, tget: set) -> int:
+ return len(tget)
+
+
+def jaccard_index(predicted: Iterable, target: Iterable) -> float:
+ """Calculate the Jaccard Index."""
+ return set_relevance_score(_union_denominator, predicted, target)
+
+
+def set_precision(predicted: Iterable, target: Iterable) -> float:
+ """Calculate the precision, using sets."""
+ return set_relevance_score(_pred_denominator, predicted, target)
+
+
+def set_recall(predicted: Iterable, target: Iterable) -> float:
+ """Calculate the recall, using sets."""
+ return set_relevance_score(_tget_denominator, predicted, target)
+
+
+def longest_common_prefix(list1: list, list2: list) -> list:
+ """Return the longest common prefix."""
+ index_first_difference = next(
+ (i for i, (a, b) in enumerate(zip(list1, list2)) if a != b),
+ min(len(list1), len(list2)),
+ )
+ return list1[:index_first_difference]
+
+
+def mse(predicted: Number, target: Number) -> Number:
+ """Return the mean squared error."""
+ return (predicted - target) ** 2
+
+
+def point_distance(predicted: tuple[float, ...], target: tuple[float, ...]):
+ """Return the distance between two points."""
+ if len(predicted) != len(target):
+ raise ValueError(
+ "point_distance: Predicted and target points have different dimensions."
+ )
+ return math.sqrt(
+ sum((comp_res - comp_tar) ** 2 for comp_res, comp_tar in zip(predicted, target))
+ )
diff --git a/vlmeval/dataset/utils/megabench/scoring/common/transformations.py b/vlmeval/dataset/utils/megabench/scoring/common/transformations.py
new file mode 100644
index 0000000000000000000000000000000000000000..380d26e061de532af3fd75705c07a896d5b08b63
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/common/transformations.py
@@ -0,0 +1,120 @@
+"""Like-to-like data transformations."""
+
+import re
+import unicodedata
+
+
+def remove_def_indef_articles(text: str) -> str:
+ """Remove definite and indefinite articles."""
+ text_list = [t for t in text.split(" ") if t.lower() not in {"the", "a"}]
+ return " ".join(text_list)
+
+
+def replace_macrons_with_latex_overline(text: str) -> str:
+ """Replace letters with macrons with the LaTeX bar."""
+ result = []
+ for char in text:
+ if char.isalpha():
+ decomposed = unicodedata.normalize("NFD", char)
+ if len(decomposed) > 1 and decomposed[1] == "\u0304": # Macron accent
+ result.append(f"\\overline{{{decomposed[0]}}}")
+ else:
+ result.append(char)
+ elif char != "\u0304":
+ result.append(char)
+ else:
+ result[-1] = f"\\overline{{{result[-1]}}}"
+
+ return "".join(result)
+
+
+def fix_overline_underscores(text: str) -> str:
+ """Puts underscores that are outside \overline within overline."""
+ pattern = r"\\overline\{([^}]*)\}_([^{}\\ ]*)"
+ return re.sub(pattern, r"\\overline{\1_\2}", text)
+
+
+# Dictionary mapping Unicode Greek letters to LaTeX equivalents
+greek_to_latex = {
+ # Lowercase Greek letters
+ "α": "\\alpha",
+ "β": "\\beta",
+ "γ": "\\gamma",
+ "δ": "\\delta",
+ "ε": "\\epsilon",
+ "ζ": "\\zeta",
+ "η": "\\eta",
+ "θ": "\\theta",
+ "ι": "\\iota",
+ "κ": "\\kappa",
+ "λ": "\\lambda",
+ "μ": "\\mu",
+ "ν": "\\nu",
+ "ξ": "\\xi",
+ "ο": "\\omicron",
+ "π": "\\pi",
+ "ρ": "\\rho",
+ "σ": "\\sigma",
+ "τ": "\\tau",
+ "υ": "\\upsilon",
+ "φ": "\\phi",
+ "χ": "\\chi",
+ "ψ": "\\psi",
+ "ω": "\\omega",
+ # Uppercase Greek letters
+ "Α": "\\Alpha",
+ "Β": "\\Beta",
+ "Γ": "\\Gamma",
+ "Δ": "\\Delta",
+ "Ε": "\\Epsilon",
+ "Ζ": "\\Zeta",
+ "Η": "\\Eta",
+ "Θ": "\\Theta",
+ "Ι": "\\Iota",
+ "Κ": "\\Kappa",
+ "Λ": "\\Lambda",
+ "Μ": "\\Mu",
+ "Ν": "\\Nu",
+ "Ξ": "\\Xi",
+ "Ο": "\\Omicron",
+ "Π": "\\Pi",
+ "Ρ": "\\Rho",
+ "Σ": "\\Sigma",
+ "Τ": "\\Tau",
+ "Υ": "\\Upsilon",
+ "Φ": "\\Phi",
+ "Χ": "\\Chi",
+ "Ψ": "\\Psi",
+ "Ω": "\\Omega",
+}
+
+
+def replace_greek_letters(text: str) -> str:
+ """Replace Greek letters in Unicode with their LaTeX equivalents."""
+ return re.sub(r"[α-ωΑ-Ω]", lambda match: greek_to_latex[match.group()] + " ", text)
+
+
+def remove_latex_math_delimiters(latex_str):
+ # Pattern to match \begin{...}[...] and \end{...}[...] commands
+ env_pattern = r"\\(begin|end)\{.*?\}(?:\[[^\[\]]*\])?"
+ latex_str = re.sub(env_pattern, "", latex_str)
+
+ # Remove \( and \)
+ inline_math_pattern = r"\\\(|\\\)"
+ latex_str = re.sub(inline_math_pattern, "", latex_str)
+
+ # Remove \[ and \]
+ display_math_pattern = r"\\\[|\\\]"
+ latex_str = re.sub(display_math_pattern, "", latex_str)
+
+ return latex_str
+
+
+def normalize_latex(text: str) -> str:
+ """Normalize the LaTeX expression."""
+ text = text.replace("\\bar", "\\overline")
+ text = replace_macrons_with_latex_overline(text)
+ text = fix_overline_underscores(text)
+ text = replace_greek_letters(text)
+ text = remove_latex_math_delimiters(text)
+ return text
diff --git a/vlmeval/dataset/utils/megabench/scoring/constrained_generation.py b/vlmeval/dataset/utils/megabench/scoring/constrained_generation.py
new file mode 100644
index 0000000000000000000000000000000000000000..66c1f88d26c4b564a9a32bacb8766319ac1943c1
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/constrained_generation.py
@@ -0,0 +1,512 @@
+import collections
+import itertools
+import logging
+from numbers import Number
+import re
+from nltk.tokenize import sent_tokenize, word_tokenize
+from nltk.stem import WordNetLemmatizer
+from nltk.corpus import wordnet
+import pronouncing
+from .common.conversions import str_to_iterable
+from ..parsing.common.parsers import parse_nested_str_list, parse_syllable_ranges
+import signal
+
+
+def custom_lemmatize(word, lemmatizer):
+ """
+ Custom lemmatization to handle special cases like 'puppies' -> 'puppy'.
+ """
+ lemma = lemmatizer.lemmatize(word, wordnet.NOUN)
+
+ # Handle irregular plural forms manually
+ if word.endswith("ies") and lemma.endswith("y"):
+ lemma = lemma[:-1] + "y"
+ elif word.endswith("ves") and lemma.endswith("f"):
+ lemma = lemma[:-1] + "f"
+
+ return lemma
+
+
+def lemmatize_phrase(phrase, lemmatizer):
+ """
+ Lemmatizes a phrase (multiple words).
+ """
+ words = word_tokenize(phrase.lower())
+ lemmatized_words = [custom_lemmatize(word, lemmatizer) for word in words]
+ return " ".join(lemmatized_words)
+
+
+custom_phones_for_word = {
+ "'gainst": ["G EH1 N S T", "G EY1 N S T"],
+ "'midst": ["M IH1 D S T"],
+ "'mongst": ["M AH1 NG S T"],
+ "'neath": ["N IY1 TH"],
+ "beguiles": ["B IH0 G AY1 L Z"],
+ "cerulean": ["S ER0 UW1 L IY0 AH0 N"],
+ "doggo": ["D AO1 G OW0"],
+ "downtorn": ["D AW1 N T AO2 R N"],
+ "enthrall": ["EH0 N TH R AO1 L"],
+ "fam'ly": ["F AE1 M L IY0"],
+ "fiery": ["F AY1 ER0 IY0", "F AY1 R IY0"],
+ "flits": ["F L IH1 T S"],
+ "furred": ["F ER1 D"],
+ "kneels": ["N IY1 L Z"],
+ "o'er": ["OW1 ER0"],
+ "orbs": ["AO1 R B Z"],
+ "quenched": ["K W EH1 N CH D"],
+ "quietude": ["K W AY1 AH0 T UW0 D"],
+ "retold": ["R IY0 T OW1 L D"],
+ "scurries": ["S K ER1 IY0 Z"],
+ "sunbeams": ["S AH1 N B IY2 M Z"],
+ "syncs": ["S IH1 NG K S"],
+ "'twixt": ["T W IH1 K S T"],
+}
+
+
+file_logger = logging.getLogger("errorLogger")
+
+
+def phones_for_word(text: str) -> list[str]:
+ """A wrapper for pronouncingpy's phones_for_word to handle out-of-vocab issues."""
+ text = text.replace("’", "'").lower()
+
+ suffixes = [""]
+ prefixes = [""]
+ prefixes_to_remove = [""]
+ if text.endswith("'s"):
+ suffixes = [" Z"]
+ text = text.removesuffix("'s")
+
+ if text in custom_phones_for_word:
+ return [
+ pr + suffix
+ for pr, suffix in itertools.product(custom_phones_for_word[text], suffixes)
+ ]
+
+ pronunciations = pronouncing.phones_for_word(text)
+
+ # Guess pronunciation from word stem
+ if not pronunciations:
+ if suffixes[0] != "": # "'s doesn't really work with the rest."
+ file_logger.error(f"OOV: {text}")
+ return []
+
+ if text.endswith("ed"):
+ suffixes = [" D", " T", " AH0 D", " IH0 D"]
+ text = text.removesuffix("ed")
+ elif text.endswith("s"):
+ # Some words, like bustles, end with es but the plural suffix is s.
+ if pronouncing.phones_for_word(text.removesuffix("s")):
+ # On the other hand, pierces is two syllables but pierce is one.
+ if text.endswith("es"):
+ suffixes = [" S", " Z", " AH0 Z", " IH0 Z"]
+ text = text.removesuffix("s")
+ else:
+ suffixes = [" S", " Z"]
+ text = text.removesuffix("s")
+ elif text.endswith("es"):
+ suffixes = [" AH0 Z", " IH0 Z"]
+ text = text.removesuffix("es")
+ if text.startswith("un"):
+ prefixes = ["AH0 N "]
+ text = text.removeprefix("un")
+ elif text.startswith("'"):
+ if pronouncing.phones_for_word("a" + text.removeprefix("'")):
+ prefixes_to_remove = ["AH0 "]
+ text = "a" + text.removeprefix("'")
+ pronunciations = pronouncing.phones_for_word(text)
+ pronunciations = [
+ (prefix + pr + suffix).removeprefix(prefix_to_remove)
+ for prefix, pr, suffix, prefix_to_remove in itertools.product(
+ prefixes, pronunciations, suffixes, prefixes_to_remove
+ )
+ ]
+
+ if not pronunciations:
+ file_logger.error(f"OOV: {text}")
+ return pronunciations
+
+
+def rhyming_part_include_unstressed(phones: str) -> str:
+ """Get the "rhyming part" of a string with CMUdict phones.
+
+ "Rhyming part" here means everything from the vowel in the
+ last syllable up to the end of the word.
+
+ Example:
+ >>> import pronouncing
+ >>> phones = pronouncing.phones_for_word("purple")
+ >>> rhyming_part_include_unstressed(phones[0])
+ 'AH0 L'
+
+ Args:
+ phones: a string containing space-separated CMUdict phones
+
+ Returns:
+ a string with just the "rhyming part" of those phones
+ """
+ phones_list = phones.split()
+ for i in range(len(phones_list) - 1, 0, -1):
+ if phones_list[i][-1] in "012":
+ phones = " ".join(phones_list[i:])
+ break
+ return re.sub(r"\d", "", phones)
+
+
+def count_syllables(text: str) -> list[int]:
+ """Count the number of syllables in a piece of text."""
+ pronunciations = [phones_for_word(p) for p in text.split()]
+ syllable_counts = []
+ for pronun_possibility in itertools.product(*pronunciations):
+ syllable_counts.append(
+ sum([pronouncing.syllable_count(p) for p in pronun_possibility])
+ )
+ return syllable_counts
+
+
+def find_string_occurrences_with_variations(text, search_string):
+ lemmatizer = WordNetLemmatizer()
+
+ # Lemmatize the entire search phrase
+ search_lemma = lemmatize_phrase(search_string, lemmatizer)
+
+ # Tokenize the text into sentences
+ sentences = sent_tokenize(text)
+
+ occurrences = []
+ total_count = 0
+
+ # Iterate over each sentence
+ for i, sentence in enumerate(sentences, 1): # Sentence numbers start from 1
+ # Lemmatize the entire sentence
+ lemmatized_sentence = lemmatize_phrase(sentence, lemmatizer)
+
+ # Count occurrences of the lemmatized search phrase in the lemmatized sentence
+ count_in_sentence = lemmatized_sentence.count(search_lemma)
+ if count_in_sentence > 0:
+ occurrences.append((i, count_in_sentence))
+ total_count += count_in_sentence
+
+ return total_count, occurrences
+
+
+def word_to_stresses(word: str) -> list[list[int]]:
+ """Convert a word to a list of stresses, for each valid pronunciation."""
+ pronunciations = phones_for_word(word)
+ stresses = {
+ tuple(int(stress) for stress in pronouncing.stresses(pronunc))
+ for pronunc in pronunciations
+ }
+ return [list(pronunc_stresses) for pronunc_stresses in stresses]
+
+
+def is_iambic_pair(stress1: int, stress2: int) -> bool:
+ """Whether the pair of stresses is a valid iambic pair."""
+ valid_pairs = {(2, 1), (0, 2), (0, 1), (0, 0), (1, 1), (2, 2)}
+ return (stress1, stress2) in valid_pairs
+
+
+def grouper_ignore_last(iterable, n):
+ "Collect data into fixed-length chunks or blocks"
+ # grouper('ABCDEFG', 3) --> ABC DEF
+ args = [iter(iterable)] * n
+ return zip(*args)
+
+
+def is_line_iambic(line: str) -> bool:
+ """Determine if a line is iambic."""
+ words = line.split()
+ stress_options = [word_to_stresses(word) for word in words]
+
+ def backtrack(word_index: int, syllable_index: int, prev_stress: int) -> bool:
+ """Using backtracking, determine if there is a sequence of pronunciations that is in iambic pentameter."""
+ if word_index == len(words):
+ # At this point, syllable_index is the number of syllables
+ return syllable_index % 2 == 0
+
+ for stress_pattern in stress_options[word_index]:
+ word_syllable_index = 0
+ if syllable_index % 2 != 0:
+ current_stress = stress_pattern[word_syllable_index]
+ if not is_iambic_pair(prev_stress, current_stress):
+ continue
+ word_syllable_index += 1
+
+ word_valid_iambic_pairs = True
+ for stress1, stress2 in grouper_ignore_last(
+ stress_pattern[word_syllable_index:], 2
+ ):
+ if not is_iambic_pair(stress1, stress2):
+ word_valid_iambic_pairs = False
+ break
+ word_syllable_index += 2
+ if not word_valid_iambic_pairs:
+ continue
+
+ if word_syllable_index < len(stress_pattern):
+ assert word_syllable_index + 1 == len(stress_pattern)
+ next_stress = stress_pattern[word_syllable_index]
+ if backtrack(
+ word_index + 1,
+ syllable_index + word_syllable_index + 1,
+ next_stress,
+ ):
+ return True
+ else:
+ assert word_syllable_index == len(stress_pattern)
+ if backtrack(word_index + 1, syllable_index + word_syllable_index, -1):
+ return True
+
+ return False
+
+ return backtrack(
+ 0, 0, -1
+ ) # Start with -1 as prev_stress as a placeholder for the first syllable
+
+
+def parse_constraints(key_string, value_string):
+ key_components = key_string.strip().split("##")
+ # Remove trailing numbers from each key
+ key_components = [re.sub(r"\d+$", "", key) for key in key_components]
+ # Extract value components by splitting on ##
+ value_components = value_string.strip().split("##")
+ # Clean value components by removing brackets and spaces
+ value_components = [comp.strip().strip('"').strip() for comp in value_components]
+
+ # Handle cases where we expect integers
+ for i, value in enumerate(value_components):
+ if value.isdigit():
+ value_components[i] = int(value)
+
+ # Combine keys and values into a dictionary
+ if len(key_components) == len(value_components):
+ result = {
+ key.lower(): value for key, value in zip(key_components, value_components)
+ }
+ elif len(key_components) == 1 and len(value_components) == 1:
+ result = {key_components[0].lower(): value_components[0]}
+ else:
+ raise ValueError("Mismatch between number of keys and values.")
+
+ return result
+
+
+def check_constraint(response, constraint, constraint_val):
+ if constraint_val.strip() == "":
+ # empty contraint (placeholder), directly return 1
+ return 1
+ elif "contain" in constraint:
+ occurs_records = {}
+ parsed_constraint = parse_constraints(constraint, constraint_val)
+ response = response.replace("**", "") # Remove markdown around bolded letters
+ if "contain_only" in parsed_constraint:
+ num_satisfied = 0
+ conditions = parse_nested_str_list(parsed_constraint["contain_only"])
+ for cond in conditions:
+ count, occurs = 0, []
+ for item in cond: # check one condition
+ count_, occurs_ = find_string_occurrences_with_variations(
+ response, item
+ )
+ if count_ > 0:
+ count += count_
+ occurs.extend(occurs_)
+ if count > 0:
+ num_satisfied += 1
+ occurs_records[tuple(cond)] = occurs
+ score = 1 if num_satisfied == 1 else 0
+ else: # the vanilla "contain" constraint
+ items = str_to_iterable(list, parsed_constraint["contain"])
+ count, occurs = 0, []
+ for item in items:
+ count_, occurs_ = find_string_occurrences_with_variations(
+ response, item
+ )
+ if count_ > 0:
+ count += count_
+ occurs.extend(occurs_)
+ if count > 0:
+ occurs_records[tuple(items)] = occurs
+ score = 0 if count == 0 else 1
+
+ ## Other logics like position or repeat, only check when
+ ## previous "contain" consraint passes
+ if score > 0:
+ occurs = list(occurs_records.values())[0]
+ if "position_only" in parsed_constraint:
+ pos = parsed_constraint["position_only"]
+ score = 1 if len(occurs) == 1 and occurs[0][0] == pos else 0
+ return score
+ elif "position" in parsed_constraint:
+ pos = parsed_constraint["position"]
+ occurs_sent_ids = [item[0] for item in occurs]
+ score = 1 if pos in occurs_sent_ids else 0
+
+ # check occurance times
+ if "times" in parsed_constraint:
+ repeat_times = parsed_constraint["times"]
+ total_occurs = sum([item[1] for item in occurs])
+ score = 1 if total_occurs == repeat_times else 0
+
+ elif "length" in constraint:
+ try:
+ len_constraint = int(constraint_val[1:])
+ words = re.findall(r"\b\w+\b", response)
+ if constraint_val.strip() == "":
+ score = 1 ## dummy placeholder constraint, score is 1
+ elif constraint_val[0] == "<":
+ score = 1 if len(words) < len_constraint else 0
+ elif constraint_val[0] == ">":
+ score = 1 if len(words) > len_constraint else 0
+ else:
+ file_logger.warning(f"Unknown length info {constraint_val}")
+ except ValueError:
+ file_logger.warning(f"Wrong length info {constraint_val}")
+ score = 0
+ elif "acrostic" in constraint:
+ response = response.replace("**", "")
+
+ lines = response.strip().lower().split("\n")
+ if len(lines) != len(constraint_val):
+ return 0
+ all_match = True
+ if "acrostic_alliteration" in constraint:
+ for line, letter in zip(lines, constraint_val.lower()):
+ line = line.strip()
+ if letter == " ":
+ if line != "":
+ all_match = False
+ break
+ elif not line or not all(word[0] == letter for word in line.split(" ")):
+ all_match = False
+ break
+ else:
+ for line, letter in zip(lines, constraint_val.lower()):
+ line = line.strip()
+ if letter == " ":
+ if line != "":
+ all_match = False
+ break
+ elif not line or not line[0] == letter:
+ all_match = False
+ break
+ score = 1 if all_match else 0
+ else:
+ response = response.strip()
+ response = response.replace(".", "")
+ response = response.replace(",", "")
+ response = response.replace("!", "")
+ response = response.replace("?", "")
+ response = response.replace(":", "")
+ response = response.replace(";", "")
+ response = response.replace('"', "")
+ response = response.replace("-", " ")
+ response = response.replace("—", " ")
+ response = re.sub(
+ " *\(\w\) *(?=\n|$)", "", response
+ ) # The parenthesized letter in the rhyming scheme
+
+ lines = response.lower().split("\n")
+ match constraint:
+ case "syllables":
+ syllable_count_intervals = parse_syllable_ranges(constraint_val)
+ if len(lines) != len(syllable_count_intervals):
+ return 0
+ try:
+ all_match = all(
+ any(
+ min_count <= syll_count <= max_count
+ for syll_count in count_syllables(line)
+ )
+ for line, (min_count, max_count) in zip(
+ lines, syllable_count_intervals
+ )
+ )
+ except IndexError:
+ all_match = None
+ score = 1 if all_match else 0
+ case "rhyming_scheme":
+ # Ensure that the number of lines is the same as the number in the rhyming scheme
+ if len(lines) != len(constraint_val):
+ return 0
+ last_words = [line.split()[-1] if line != "" else "" for line in lines]
+
+ # Map each rhyming scheme letter to the last word of a line
+ letter_to_words = collections.defaultdict(set)
+ for rhyme_letter, word in zip(constraint_val, last_words):
+ if rhyme_letter == " ":
+ if word != "":
+ return 0
+ else:
+ letter_to_words[rhyme_letter].add(word)
+
+ # Check that 1. The words for the same letter all rhyme
+ letter_to_rhyming_parts = {}
+ for letter, words in letter_to_words.items():
+ rhyming_parts: list[set[str]] = [
+ {
+ rhyming_part_include_unstressed(pronunciations)
+ for pronunciations in phones_for_word(word)
+ }
+ for word in words
+ ]
+ common_rhyming_parts = set.intersection(*rhyming_parts)
+ if not common_rhyming_parts:
+ return 0
+ letter_to_rhyming_parts[letter] = common_rhyming_parts
+ # Check that 2. The words for different letters do not rhyme
+ for a, b in itertools.combinations(letter_to_rhyming_parts, 2):
+ # To simplify things, if there are any shared pronunciations between two different letters, we reject it
+ if letter_to_rhyming_parts[a] & letter_to_rhyming_parts[b]:
+ return 0
+ score = 1
+ case "poetry_meter":
+ all_match = all(is_line_iambic(line) for line in lines)
+ score = 1 if all_match else 0
+ case _:
+ file_logger.warning(f"Unknown constraint type {constraint}")
+ score = 0
+
+ return score
+
+
+class ConstrainedGenerationEval:
+ """
+ Constrained generation metric
+ """
+
+ timeout = 10
+
+ @classmethod
+ def match(cls, response, constraints) -> Number:
+ scores = []
+ eval_results = {}
+
+ def handler(signum, frame):
+ raise TimeoutError()
+
+ def check_with_timeout(constraint, constraint_val):
+ # Set the signal handler and a timeout
+ signal.signal(signal.SIGALRM, handler)
+ signal.alarm(cls.timeout) # Set the timeout
+
+ try:
+ # Try to check the constraint
+ score = check_constraint(response, constraint, constraint_val)
+ except TimeoutError:
+ print(f"Timeout reached for constraint: {constraint}")
+ score = 0 # Set score to 0 if timeout occurs
+ finally:
+ signal.alarm(0) # Reset the alarm
+
+ return score
+
+ for constraint, constraint_val in constraints.items():
+ score = check_with_timeout(constraint, constraint_val)
+ scores.append(score)
+ eval_results[constraint] = score
+
+ final_score = min(scores)
+ eval_info = "\t".join([f"{key}: {val}" for key, val in eval_results.items()])
+
+ return final_score, eval_info
diff --git a/vlmeval/dataset/utils/megabench/scoring/coordinate_sequence_match.py b/vlmeval/dataset/utils/megabench/scoring/coordinate_sequence_match.py
new file mode 100644
index 0000000000000000000000000000000000000000..8f384d9ad69e135847553947ea97c41c03709fa8
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/coordinate_sequence_match.py
@@ -0,0 +1,65 @@
+import logging
+from .common.conversions import str_to_coords
+import numpy as np
+
+
+class CoordsSequenceSimilarity:
+ """
+ Measure the similarity between two list of coordinates, used for keypoint estimation tasks
+ """
+
+ @staticmethod
+ def compute_score(pred_keypoints, gt_keypoints, k=10):
+ """
+ Compute the evaluation score for keypoint estimation.
+
+ Args:
+ pred_keypoints (list or np.ndarray): List or array of predicted keypoint coordinates,
+ each as (x, y), normalized to [0, 1].
+ gt_keypoints (list or np.ndarray): List or array of ground truth keypoint coordinates,
+ each as (x, y), normalized to [0, 1].
+
+ Returns:
+ float: A score between 0 and 1, where 1 indicates perfect accuracy,
+ and 0 indicates completely wrong.
+ """
+ # Convert inputs to NumPy arrays
+ try:
+ pred_keypoints = np.array(pred_keypoints)
+ except ValueError:
+ # Format is not a correct
+ return 0
+
+ gt_keypoints = np.array(gt_keypoints)
+
+ # shape mismatch, directly assign 0 score
+ if pred_keypoints.shape != gt_keypoints.shape:
+ return 0
+
+ # Compute Euclidean distances between corresponding keypoints
+ distances = np.linalg.norm(pred_keypoints - gt_keypoints, axis=1)
+
+ # Maximum possible distance in normalized coordinate space
+ max_distance = np.sqrt(2)
+
+ # Normalize distances
+ normalized_distances = distances / max_distance
+
+ # Compute per-keypoint scores using exponential decay
+ per_keypoint_scores = np.exp(-k * normalized_distances)
+
+ # Compute the average score across all keypoints
+ score = np.mean(per_keypoint_scores)
+
+ return score
+
+ @classmethod
+ def match(cls, responses, targets) -> float:
+ """Exact match between targets and responses."""
+ logging.debug(f"{responses=}, {targets=}")
+ if not isinstance(responses, (tuple | list)):
+ responses = str_to_coords(responses, dim=2)
+ if not isinstance(targets, (tuple | list)):
+ targets = str_to_coords(targets, dim=2)
+
+ return cls.compute_score(responses, targets)
diff --git a/vlmeval/dataset/utils/megabench/scoring/dict_equality.py b/vlmeval/dataset/utils/megabench/scoring/dict_equality.py
new file mode 100644
index 0000000000000000000000000000000000000000..326e0bd34a31a70f574d2dfa46b08f19cd6e9e96
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/dict_equality.py
@@ -0,0 +1,44 @@
+from .common.conversions import cast_to_dict
+from .simple_str_match import ExactStrMatch
+
+
+class DictEquality:
+ """Calculates the exact string match across the dict.
+
+ 1. Calculates the exact match for all keys in the solution
+ 2. Calculates the total, then divides by the size of the solution
+ """
+
+ @classmethod
+ def match(cls, responses, targets) -> float:
+ """Return the aggregated Jaccard index between targets and responses."""
+ responses = cast_to_dict(responses)
+ targets = cast_to_dict(targets)
+
+ if not isinstance(responses, dict):
+ return 0
+
+ return 1 if responses == targets else 0
+
+
+class DictPrecision:
+
+ @classmethod
+ def match(cls, responses, targets) -> float:
+ """Return the aggregated Jaccard index between targets and responses."""
+ responses = cast_to_dict(responses)
+ targets = cast_to_dict(targets)
+
+ if not isinstance(responses, dict):
+ return 0
+
+ if len(responses) == 0:
+ return 0
+
+ matched = 0
+ for key, val in responses.items():
+ if key in targets:
+ if ExactStrMatch.match(val, targets[key]):
+ matched += 1
+
+ return matched / len(responses)
diff --git a/vlmeval/dataset/utils/megabench/scoring/dict_exact_match_agg_recall.py b/vlmeval/dataset/utils/megabench/scoring/dict_exact_match_agg_recall.py
new file mode 100644
index 0000000000000000000000000000000000000000..5f1901e56df6348cc8a08857aaec8dc069252637
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/dict_exact_match_agg_recall.py
@@ -0,0 +1,27 @@
+from .common.conversions import cast_to_dict
+from .exact_str_match import ExactStrMatch
+
+
+class DictExactStrMatchAggRecall:
+ """Calculates the exact string match across the dict.
+
+ 1. Calculates the exact match for all keys in the solution
+ 2. Calculates the total, then divides by the size of the solution
+ """
+
+ @classmethod
+ def match(cls, responses, targets) -> float:
+ """Return the aggregated Jaccard index between targets and responses."""
+ responses = cast_to_dict(responses)
+ targets = cast_to_dict(targets)
+
+ if not isinstance(responses, dict):
+ return 0
+
+ num_keys = 0
+ total_score = 0
+ for key, answer in targets.items():
+ total_score += ExactStrMatch.match(responses.get(key), answer)
+ num_keys += 1
+
+ return total_score / num_keys
diff --git a/vlmeval/dataset/utils/megabench/scoring/dict_jaccard_agg_jaccard.py b/vlmeval/dataset/utils/megabench/scoring/dict_jaccard_agg_jaccard.py
new file mode 100644
index 0000000000000000000000000000000000000000..5f578ff2e7e4e489a77f2923bbafd2a4b6a91455
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/dict_jaccard_agg_jaccard.py
@@ -0,0 +1,28 @@
+from .jaccard import Jaccard
+from .common.conversions import cast_to_dict
+
+
+class DictJaccardAggJaccard:
+ """Calculates the Jaccard index, dividing by the union of the predictions.
+
+ 1. Calculates the Jaccard index for all sets with the same key,
+ if it appears in either pred or targets
+ 2. Calculates the total, then divides by the size of the union
+ """
+
+ @classmethod
+ def match(cls, responses, targets) -> float:
+ """Return the aggregated Jaccard index between targets and responses."""
+ responses = cast_to_dict(responses)
+ if not isinstance(responses, dict):
+ return 0
+
+ all_keys = set(responses) | set(targets)
+
+ num_keys = 0
+ total_score = 0
+ for key in all_keys:
+ total_score += Jaccard.match(responses.get(key, []), targets.get(key, []))
+ num_keys += 1
+
+ return total_score / num_keys
diff --git a/vlmeval/dataset/utils/megabench/scoring/dict_nbbox_iou_tuple_agg_jaccard.py b/vlmeval/dataset/utils/megabench/scoring/dict_nbbox_iou_tuple_agg_jaccard.py
new file mode 100644
index 0000000000000000000000000000000000000000..9a225d44b4a6dce7c587d04c21aba6f6f0ce0b22
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/dict_nbbox_iou_tuple_agg_jaccard.py
@@ -0,0 +1,27 @@
+from .nbbox_iou import NbboxIouTuple
+
+
+class DictNbboxIouTupleAggJaccard:
+ """Calculates the average precision IoU across the dict.
+
+ 1. Calculates the precision IoU for all sets with the same key,
+ if it appears in either pred or targets
+ 2. Calculates the total, then divides by the size of the union
+ """
+
+ @classmethod
+ def match(cls, responses, targets) -> float:
+ """Return the aggregated Jaccard index between targets and responses."""
+ if not isinstance(responses, dict):
+ return 0
+ all_keys = set(responses) | set(targets)
+
+ num_keys = 0
+ total_score = 0
+ for key in all_keys:
+ total_score += NbboxIouTuple.match(
+ responses.get(key, []), targets.get(key, [])
+ )
+ num_keys += 1
+
+ return total_score / num_keys
diff --git a/vlmeval/dataset/utils/megabench/scoring/dict_set_equality_agg_jaccard.py b/vlmeval/dataset/utils/megabench/scoring/dict_set_equality_agg_jaccard.py
new file mode 100644
index 0000000000000000000000000000000000000000..bc5cf47e492bd80a9f7c1506caec09c576c684eb
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/dict_set_equality_agg_jaccard.py
@@ -0,0 +1,28 @@
+from vlmeval.dataset.utils.megabench.scoring.set_equality import SetEquality
+
+
+class DictSetEqualityAggJaccard:
+ """Calculates the average set equality across the dict.
+
+ 1. Calculates the set equality for all sets with the same key,
+ if it appears in either pred or targets
+ 2. Calculates the total, then divides by the size of the union
+ """
+
+ @classmethod
+ def match(cls, responses, targets) -> float:
+ """Return the aggregated Jaccard index between targets and responses."""
+ if not isinstance(responses, dict):
+ return 0
+
+ all_keys = set(responses) | set(targets)
+
+ num_keys = 0
+ total_score = 0
+ for key in all_keys:
+ total_score += SetEquality.match(
+ responses.get(key, []), targets.get(key, [])
+ )
+ num_keys += 1
+
+ return total_score / num_keys
diff --git a/vlmeval/dataset/utils/megabench/scoring/exact_str_match.py b/vlmeval/dataset/utils/megabench/scoring/exact_str_match.py
new file mode 100644
index 0000000000000000000000000000000000000000..9cee6c9c6f9511cd2118951d89374cfe9614620c
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/exact_str_match.py
@@ -0,0 +1,48 @@
+import re
+from ..parsing.common.utils import extract_code_block_content
+
+
+def parse_single_letter(s):
+ # Regular expression to match (A)XXXXX, A . XXXXXXX, or A.XXXXXX
+ match = re.match(r"^\(?([A-Za-z])\)?(?:\s*\.\s*|\.)?(.*)", s)
+
+ if match:
+ # Extract and return the single letter
+ return match.group(1)
+ else:
+ # Return the original string if no match is found
+ return s
+
+
+class ExactStrMatch:
+ """Exact string matching."""
+
+ @staticmethod
+ def match(response: str, correct_answer: str) -> int:
+ """Exact match between targets and responses."""
+ if not isinstance(response, str):
+ response = str(response)
+ if not isinstance(correct_answer, str):
+ correct_answer = str(correct_answer)
+
+ if len(correct_answer) == 1 and correct_answer.isalpha() and len(response) > 1:
+ # handle special case of choice letter,
+ # drop the potential parenthesis
+ response = parse_single_letter(response)
+
+ return 1 if response == correct_answer else 0
+
+
+class CodeResultExactStrMatch:
+ """Exact string matching, with the results from a results code block."""
+
+ @staticmethod
+ def match(response: str, correct_answer: str) -> int:
+ """Exact match between targets and responses."""
+ correct_answer, is_code = extract_code_block_content(
+ correct_answer,
+ is_ascii_art=True,
+ should_remove_surrounding_whitespace=False,
+ )
+ # assert is_code
+ return ExactStrMatch.match(response, correct_answer)
diff --git a/vlmeval/dataset/utils/megabench/scoring/exact_str_match_case_insensitive.py b/vlmeval/dataset/utils/megabench/scoring/exact_str_match_case_insensitive.py
new file mode 100644
index 0000000000000000000000000000000000000000..7dee848b6a0c2086f090823653a36e6b93ba7339
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/exact_str_match_case_insensitive.py
@@ -0,0 +1,12 @@
+from .exact_str_match import ExactStrMatch
+
+
+class ExactStrMatchCaseInsensitive:
+ """Case-insensitive exact string matching."""
+
+ @staticmethod
+ def match(response, correct_answer) -> int:
+ """Case-insensitive exact match between targets and responses."""
+ if not isinstance(response, str) and isinstance(correct_answer, str):
+ return 0
+ return ExactStrMatch.match(response.lower(), correct_answer.lower())
diff --git a/vlmeval/dataset/utils/megabench/scoring/general_numerical_match.py b/vlmeval/dataset/utils/megabench/scoring/general_numerical_match.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe3ea14c3cedfc5a4a065b638a0ace44f406d9c3
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/general_numerical_match.py
@@ -0,0 +1,253 @@
+import re
+from .simple_str_match import SimpleStrMatch
+
+from sympy.parsing.latex import parse_latex
+import math
+import multiprocessing
+
+import signal
+
+
+class TimeoutException(Exception):
+ pass
+
+
+def timeout_handler(signum, frame):
+ raise TimeoutException()
+
+
+E = 2.718
+
+############## Begin
+# Numerical comparison from https://github.com/TIGER-AI-Lab/MAmmoTH/blob/main/math_eval/number_utils.py
+
+
+def run_eval(expression, output):
+ try:
+ # Safely evaluate the expression
+ result = eval(expression)
+ output.put(result)
+ except Exception as e:
+ output.put(e)
+
+
+def eval_with_timeout(expression, timeout=5):
+ # Create a multiprocessing.Queue to receive the output
+ output = multiprocessing.Queue()
+
+ # Define and start the process
+ process = multiprocessing.Process(target=run_eval, args=(expression, output))
+ process.start()
+
+ # Wait for the process to complete or timeout
+ process.join(timeout)
+
+ if process.is_alive():
+ # Terminate the process
+ process.terminate()
+ process.join()
+ return "Timeout or error during evaluation"
+
+ # Get result from the queue
+ try:
+ return output.get_nowait()
+ except Exception as e:
+ return "Error retrieving result"
+
+
+def compare_two_list(pred, gt):
+ if not isinstance(pred, list):
+ return False
+ elif len(pred) != len(gt):
+ return False
+ elif any([not isinstance(x, (int, float)) for x in pred]):
+ return False
+ else:
+ pred = sorted(pred)
+ gt = sorted(gt)
+ return all([compare_two_numbers(p, g) for p, g in zip(pred, gt)])
+
+
+def compare_two_numbers(p, gt):
+ try:
+ if math.isnan(p):
+ return False
+ else:
+ return within_eps(pred=p, gt=gt)
+ except Exception:
+ return False
+
+
+def within_eps(pred: float, gt: float):
+ eps = abs(gt) * 0.01
+ if pred >= gt - eps and pred <= gt + eps:
+ return True
+ else:
+ return False
+
+
+def clean_units(pred_str: str):
+ """Clean the units in the number."""
+
+ def convert_pi_to_number(code_string):
+ code_string = code_string.replace("\\pi", "π")
+ # Replace \pi or π not preceded by a digit or } with 3.14
+ code_string = re.sub(r"(? "3*3.14"
+ code_string = re.sub(r"(\d)(\\?π)", r"\1*3.14", code_string)
+ # Handle cases where π is within braces or followed by a multiplication symbol
+ # This replaces "{π}" with "3.14" directly and "3*π" with "3*3.14"
+ code_string = re.sub(r"\{(\\?π)\}", "3.14", code_string)
+ code_string = re.sub(r"\*(\\?π)", "*3.14", code_string)
+ return code_string
+
+ pred_str = convert_pi_to_number(pred_str)
+ pred_str = pred_str.replace("%", "/100")
+ pred_str = pred_str.replace("$", "")
+ pred_str = pred_str.replace("¥", "")
+ pred_str = pred_str.replace("°C", "")
+ pred_str = pred_str.replace(" C", "")
+ pred_str = pred_str.replace("°", "")
+ return pred_str
+
+
+def number_it(num):
+ if isinstance(num, (int, float)):
+ return num
+
+ num = clean_units(num)
+ try:
+ num = str(parse_latex(num))
+ except Exception:
+ pass
+
+ if floatify(num) is not None:
+ return floatify(num)
+ else:
+ try:
+ num = eval_with_timeout(num)
+ if isinstance(num, list) or isinstance(num, tuple):
+ return num # return num list
+ if floatify(num) is not None:
+ return floatify(num)
+ else:
+ return None
+ except Exception:
+ return None
+
+
+def floatify(num: str):
+ try:
+ num = float(num)
+ if num.is_integer():
+ return round(num)
+ else:
+ return num
+ except Exception:
+ return None
+
+
+def remove_latex_math_brackets(latex_str):
+ """
+ Removes LaTeX math mode delimiters (\( ... \) and \[ ... \]) from a string
+ while preserving the contents inside the delimiters.
+ If no such delimiters are found, the original string is returned.
+ """
+ # Regex pattern for inline math \( ... \)
+ inline_pattern = re.compile(r"\\\((.*?)\\\)")
+ # Regex pattern for TeX inline math $...$
+ tex_inline_pattern = re.compile(r"$(.*?)$")
+ # Regex pattern for display math \[ ... \]
+ display_pattern = re.compile(r"\\\[(.*?)\\\]")
+
+ latex_patterns = (inline_pattern, tex_inline_pattern, display_pattern)
+
+ if any(pattern.search(latex_str) for pattern in latex_patterns):
+ # Remove inline math mode brackets
+ latex_str = inline_pattern.sub(r"\1", latex_str)
+ # Remove display math mode brackets
+ latex_str = display_pattern.sub(r"\1", latex_str)
+ return latex_str
+
+
+def parse_assignment(expression):
+ # match the content after "=", "≈", or "\approx"
+ pattern = r"(?:=|≈|\\approx)\s*(.+)"
+
+ match = re.search(pattern, expression)
+ if match:
+ # Return the content after the sign
+ return match.group(1).strip()
+ else:
+ return expression
+
+
+############## End
+
+
+class GeneralSingleNumericalMatch:
+ """
+ Extract the results from ```\\boxed{xxxx}``` and match with the anaswer
+ """
+
+ @classmethod
+ def match(cls, responses, targets) -> float:
+ if not isinstance(responses, str):
+ responses = str(responses)
+ responses = remove_latex_math_brackets(responses)
+ responses = parse_assignment(responses)
+ targets = remove_latex_math_brackets(targets)
+ targets = parse_assignment(targets)
+ res = number_it(responses)
+ tgt = number_it(targets)
+
+ if res is not None and tgt is not None:
+ if (
+ isinstance(res, list)
+ and isinstance(tgt, list)
+ or isinstance(res, tuple)
+ and isinstance(tgt, tuple)
+ ):
+ score = float(compare_two_list(res, tgt))
+ else:
+ score = float(compare_two_numbers(res, tgt))
+ else:
+ score = SimpleStrMatch.match(responses, targets)
+
+ return score
+
+
+class BoxedSingleNumericalMatch:
+ """
+ Extract the results from ```\\boxed{xxxx}``` and match with the anaswer
+ """
+
+ @staticmethod
+ def parse_boxed_content(text):
+ ###
+ # Pattern: r'\\boxed\{((?:[^\{\}]+|\{[^\{\}]*\})*)\}':
+ # \\boxed\{: Matches the literal \boxed{.
+ # ((?:[^\{\}]+|\{[^\{\}]*\})*): This part matches the content inside the \boxed{}.
+ # (?:...): A non-capturing group that allows us to match both non-brace content and brace-enclosed content.
+ # [^\{\}]+: Matches any content that is not an opening { or closing } brace.
+ # \{[^\{\}]*\}: Matches balanced braces containing non-nested content (e.g., {5} or {3} in the LaTeX expression \frac{5}{3}).
+ ###
+ pattern = r"\\boxed\{((?:[^\{\}]+|\{[^\{\}]*\})*)\}"
+ match = re.search(pattern, text)
+ return match.group(1) if match else text
+
+ @classmethod
+ def match(cls, responses, targets, timeout_duration=10) -> float:
+ if not isinstance(responses, str):
+ responses = str(responses)
+ signal.signal(signal.SIGALRM, timeout_handler)
+ signal.alarm(timeout_duration) # Set the timeout duration in seconds
+ try:
+ parsed_res = cls.parse_boxed_content(responses)
+ targets = cls.parse_boxed_content(targets)
+ score = GeneralSingleNumericalMatch.match(parsed_res, targets)
+ return score
+ except TimeoutException:
+ return SimpleStrMatch.match(responses, targets)
+ finally:
+ signal.alarm(0)
diff --git a/vlmeval/dataset/utils/megabench/scoring/geo_proximity.py b/vlmeval/dataset/utils/megabench/scoring/geo_proximity.py
new file mode 100644
index 0000000000000000000000000000000000000000..4422516197f8b009158e26244a1f0bddb548b8c5
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/geo_proximity.py
@@ -0,0 +1,100 @@
+import functools
+import logging
+import math
+import random
+from geopy.distance import distance
+from geopy.geocoders import Nominatim
+from geopy.extra.rate_limiter import RateLimiter
+
+
+USER_AGENT_SUFFIX = hex(random.getrandbits(128))[2:]
+geolocator = Nominatim(user_agent=f"vlm-mega-benchmark_{USER_AGENT_SUFFIX}")
+
+
+error_logger = logging.getLogger("errorLogger")
+
+
+def calculate_proximity_score(guess_coords, actual_coords, k=100):
+ """Calculate the proximity score based on the location.
+
+ Exponentially decreases depending on the distance.
+
+ Args:
+ guess_coords (float, float): The longitude and latitude of the guessed coordinates.
+ actual_coords (float, float): The longitude and latitude of the actual coordinates.
+ k (numbers.Number): The threshold (in km) at which we get a score of 0.5.
+ """
+ dist = distance(guess_coords, actual_coords).km
+ proximity_score = math.exp(-dist / k)
+ return proximity_score
+
+
+GEOLOCATION_TIMEOUT = 1
+MAX_RETRIES = 30
+
+
+geocode = RateLimiter(
+ geolocator.geocode, min_delay_seconds=GEOLOCATION_TIMEOUT, max_retries=MAX_RETRIES
+)
+
+
+@functools.cache
+def try_geolocate(query):
+ """Try to look up the location."""
+ location = geocode(query)
+ if location is None:
+ error_logger.error(
+ f"Geolocation API request failed due to timeout: exceeded {MAX_RETRIES} retries!"
+ )
+ return location
+
+
+def location_to_coords(
+ country: str, province_or_state: str, municipality: str
+) -> tuple[float, float] | None:
+ if country == "" or province_or_state == "" or municipality == "":
+ return None
+ """Convert the location to longitude and latitude."""
+ location = geolocator.geocode(
+ query={"country": country, "state": province_or_state, "city": municipality}
+ )
+ if location is not None:
+ return (location.latitude, location.longitude)
+ # Try searching without the province/state, as it can be non-standard for some questions
+ location = geolocator.geocode(query={"country": country, "city": municipality})
+ if location is None:
+ return None
+ return (location.latitude, location.longitude)
+
+
+class GeoProximityLocationDict:
+ """Return a score based on the distance between two locations."""
+
+ @classmethod
+ def match(cls, responses, targets) -> float:
+ """Return a score based on how far two targets are away from each other,
+ where each field is a dict with the following schema:
+ {
+ country: str,
+ province_or_state: str,
+ municipality: str
+ }
+ """
+ try:
+ guess_coords = location_to_coords(**responses)
+ except:
+ return 0
+
+ if guess_coords is None:
+ error_logger.error(
+ f"GeoProximityLocationDict: could not load co-ordinates for {responses=}"
+ )
+ return 0
+ actual_coords = location_to_coords(**targets)
+ if actual_coords is None:
+ error_logger.error(
+ f"GeoProximityLocationDict: could not load co-ordinates for {targets=}"
+ )
+ return 0
+
+ return calculate_proximity_score(guess_coords, actual_coords)
diff --git a/vlmeval/dataset/utils/megabench/scoring/gleu.py b/vlmeval/dataset/utils/megabench/scoring/gleu.py
new file mode 100644
index 0000000000000000000000000000000000000000..6fb514fba2da103c9c22235fd9aa2c83ca83e0c7
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/gleu.py
@@ -0,0 +1,17 @@
+from numbers import Number
+import jieba
+from nltk.translate.gleu_score import sentence_gleu
+
+
+class GLEUChinese:
+ """Compute GLEU score for Chinese text."""
+
+ @staticmethod
+ def match(response, correct_answer) -> Number:
+ """Compute the BLEU scores between two strings."""
+ if isinstance(response, str) and isinstance(correct_answer, str):
+ reference_tokens = list(jieba.cut_for_search(response))
+ translation_tokens = list(jieba.cut_for_search(correct_answer))
+ else:
+ return 0
+ return sentence_gleu([reference_tokens], translation_tokens)
diff --git a/vlmeval/dataset/utils/megabench/scoring/jaccard.py b/vlmeval/dataset/utils/megabench/scoring/jaccard.py
new file mode 100644
index 0000000000000000000000000000000000000000..7695e473ae66060b02795e370f94fc67642ee14a
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/jaccard.py
@@ -0,0 +1,75 @@
+from .common.conversions import cast_to_set
+from .common.metrics import jaccard_index
+
+
+class Jaccard:
+ """Calculates the Jacard index for iterables."""
+
+ @classmethod
+ def match(cls, responses, targets) -> float:
+ """Exact match between targets and responses."""
+ if responses is None:
+ return 0
+ responses = cast_to_set(responses)
+ targets = cast_to_set(targets)
+
+ return jaccard_index(responses, targets)
+
+
+class JaccardCaseInsensitive:
+ """Calculates the Jacard index for iterables of strings,
+ Do not consider the case
+ """
+
+ @classmethod
+ def match(cls, responses, targets) -> float:
+ """Exact match between targets and responses."""
+ if responses is None:
+ return 0
+ responses = cast_to_set(responses)
+ targets = cast_to_set(targets)
+
+ if isinstance(list(targets)[0], str):
+ new_responses = {
+ item.lower() if isinstance(item, str) else str(item).lower()
+ for item in responses
+ }
+ new_targets = {item.lower() for item in targets}
+ elif isinstance(list(targets)[0], tuple):
+ new_responses = set()
+ new_targets = set()
+ try:
+ for res in responses:
+ new_res = tuple(
+ [
+ item.lower()
+ .replace(" ", "")
+ .replace("-", "")
+ .replace("\n", "")
+ .replace("\t", "")
+ .replace("_", "")
+ .replace(".", "")
+ for item in res
+ ]
+ )
+ new_responses.add(new_res)
+ except: # the data type of the response might be wrong, return 0 in this case
+ return 0
+ for tgt in targets:
+ new_tgt = tuple(
+ [
+ item.lower()
+ .replace(" ", "")
+ .replace("-", "")
+ .replace("\n", "")
+ .replace("\t", "")
+ .replace("_", "")
+ .replace(".", "")
+ for item in tgt
+ ]
+ )
+ new_targets.add(new_tgt)
+ else:
+ return 0
+
+ return jaccard_index(new_responses, new_targets)
diff --git a/vlmeval/dataset/utils/megabench/scoring/latex_expr_equality.py b/vlmeval/dataset/utils/megabench/scoring/latex_expr_equality.py
new file mode 100644
index 0000000000000000000000000000000000000000..79a14a3dde269df68f76e572e67693844f294a61
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/latex_expr_equality.py
@@ -0,0 +1,96 @@
+import re
+from sympy.parsing.latex import parse_latex
+from sympy.parsing.latex.errors import LaTeXParsingError
+from sympy.core.sympify import SympifyError
+from .common.transformations import normalize_latex
+from .simple_str_match import SimpleStrMatch
+import signal
+
+
+class TimeoutException(Exception):
+ pass
+
+
+def timeout_handler(signum, frame):
+ raise TimeoutException()
+
+
+class LatexExprEquality:
+ """Determines if two LaTeX expressions are equal."""
+
+ @classmethod
+ def match(cls, responses, targets, timeout_duration=15) -> int:
+ """Whether two LaTeX expressions are equal."""
+ if not isinstance(responses, str) or not isinstance(targets, str):
+ return 0
+ signal.signal(signal.SIGALRM, timeout_handler)
+ signal.alarm(timeout_duration) # Set the timeout duration in seconds
+ try:
+ # seems that this eval can get stuck when evaluating all tasks..
+ responses = normalize_latex(responses)
+ targets = normalize_latex(targets)
+ responses_expr = parse_latex(responses)
+ targets_expr = parse_latex(targets)
+ result = 1 if responses_expr.equals(targets_expr) else 0
+ return result
+ except (
+ LaTeXParsingError,
+ SympifyError,
+ TypeError,
+ TimeoutException,
+ NotImplementedError,
+ ):
+ return SimpleStrMatch.match(responses, targets)
+ finally:
+ signal.alarm(0) # Cancel the alarm if it completes successfully
+
+
+def separate_text_and_latex(text):
+ # Regular expression to match LaTeX content between $ symbols
+ pattern = r"(\$[^$]*\$)"
+
+ # Split the text based on LaTeX parts
+ parts = re.split(pattern, text)
+
+ # Separate plain text and LaTeX
+ latex_content = []
+ plain_text = []
+
+ for part in parts:
+ if part.startswith("$") and part.endswith("$"):
+ latex_content.append(part)
+ else:
+ plain_text.append(part.strip())
+
+ return plain_text, latex_content
+
+
+def join_latex(latex_exps):
+ result = []
+ for exp in latex_exps:
+ result.append(exp[1:-1].strip().replace(",", ""))
+ result = f"{' '.join(result)}"
+ return result
+
+
+class TextLatexExprEquality:
+ """Determines if two LaTeX expressions are equal."""
+
+ @classmethod
+ def match(cls, responses, targets) -> int:
+ """Whether two LaTeX expressions are equal."""
+ if not isinstance(responses, str) or not isinstance(targets, str):
+ return 0
+
+ tgt_texts, tgt_latex = separate_text_and_latex(targets)
+ res_texts, res_latex = separate_text_and_latex(responses)
+
+ res_text_join = "".join(res_texts).replace(",", "")
+ tgt_text_join = "".join(tgt_texts).replace(",", "")
+ text_match = SimpleStrMatch.match(res_text_join, tgt_text_join)
+
+ res_latex_join = join_latex(res_latex)
+ tgt_latex_join = join_latex(tgt_latex)
+ latex_match = LatexExprEquality.match(res_latex_join, tgt_latex_join)
+
+ return 1 if text_match and latex_match else 0
diff --git a/vlmeval/dataset/utils/megabench/scoring/longest_common_list_prefix_ratio.py b/vlmeval/dataset/utils/megabench/scoring/longest_common_list_prefix_ratio.py
new file mode 100644
index 0000000000000000000000000000000000000000..ebe652dda47c7525c2a78e0b6496a374fca8b100
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/longest_common_list_prefix_ratio.py
@@ -0,0 +1,15 @@
+from .common.conversions import str_to_list
+from .common.metrics import longest_common_prefix
+
+
+class LongestCommonListPrefixRatio:
+ """Determines how much of the first part of the list
+ was predicted correctly.
+ """
+
+ @classmethod
+ def match(cls, responses, targets) -> int:
+ """Exact match between targets and responses."""
+ responses = str_to_list(responses)
+ targets = str_to_list(targets)
+ return len(longest_common_prefix(responses, targets)) / len(targets)
diff --git a/vlmeval/dataset/utils/megabench/scoring/mse.py b/vlmeval/dataset/utils/megabench/scoring/mse.py
new file mode 100644
index 0000000000000000000000000000000000000000..c342240c11d45fc8ff9ba963146686dbedabcadd
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/mse.py
@@ -0,0 +1,64 @@
+import ast
+import numpy as np
+import math
+from .common.metrics import mse
+from .common.conversions import str_to_list
+
+
+class MSE:
+ """Mean Squared Error."""
+
+ @staticmethod
+ def match(response: str, correct_answer: str) -> int:
+ """Return the mean squared error."""
+ try:
+ return mse(ast.literal_eval(response), ast.literal_eval(correct_answer))
+ except (SyntaxError, ValueError):
+ return 0
+
+
+class NormalizedRMSE:
+ """Mean Squared Error."""
+
+ MIN = 0.0
+ MAX = 0.1
+
+ @classmethod
+ def match(cls, response: str, correct_answer: str) -> int:
+ """Return the mean squared error."""
+ try:
+ mse_val = mse(ast.literal_eval(response), ast.literal_eval(correct_answer))
+ rmse = np.clip(np.sqrt(mse_val), cls.MIN, cls.MAX)
+ norm_rmse = 1 - (rmse - cls.MIN) / (cls.MAX - cls.MIN)
+ return norm_rmse
+ except (SyntaxError, ValueError):
+ return 0
+
+
+class AngleSeqFloatRMSE:
+ """Whether the sequence of numbers is close enough to the real answer."""
+
+ MIN = 0.0
+ MAX = 10.0
+
+ @classmethod
+ def match(cls, responses, targets) -> float:
+ """Determines whether the sequence of floats are close enough to the real answer."""
+ responses = str_to_list(responses)
+ targets = str_to_list(targets)
+
+ if len(responses) != len(targets):
+ return 0
+
+ try:
+ res = np.array(responses)
+ tgt = np.array(targets)
+ rmse = np.sqrt(mse(res, tgt)).sum() / len(targets)
+ except: # cannot obtain the rmse from the response, return 0
+ return 0
+
+ rmse = np.clip(rmse, cls.MIN, cls.MAX)
+ norm_rmse = 1 - (rmse - cls.MIN) / (cls.MAX - cls.MIN)
+ if math.isnan(norm_rmse):
+ return 0
+ return norm_rmse
diff --git a/vlmeval/dataset/utils/megabench/scoring/multi_ref_phrase.py b/vlmeval/dataset/utils/megabench/scoring/multi_ref_phrase.py
new file mode 100644
index 0000000000000000000000000000000000000000..5645be8981c0e4a67daeba9beba461543521bdfd
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/multi_ref_phrase.py
@@ -0,0 +1,26 @@
+from numbers import Number
+from .common.conversions import str_to_iterable
+from .simple_str_match import SimpleStrMatch
+
+
+def replace_potential_chinese_comma(input_string):
+ return input_string.replace("，", ",")
+
+
+class MultipleReferencePhraseEval:
+ """
+ Check the response with multiple correct references
+ As long as one is matched, the score is 1, otherwise the score is 0
+ """
+
+ @staticmethod
+ def match(response, targets) -> Number:
+ targets = replace_potential_chinese_comma(targets)
+ refs = str_to_iterable(list, targets)
+ matched = False
+ for ref in refs:
+ str_ref = ref if isinstance(ref, str) else str(ref)
+ if SimpleStrMatch.match(response, str_ref):
+ matched = True
+ break
+ return 1 if matched else 0
diff --git a/vlmeval/dataset/utils/megabench/scoring/nbbox_iou.py b/vlmeval/dataset/utils/megabench/scoring/nbbox_iou.py
new file mode 100644
index 0000000000000000000000000000000000000000..3e4021030de1969885b302bd9ad5e2e825de4ce1
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/nbbox_iou.py
@@ -0,0 +1,104 @@
+import logging
+import ast
+from .common.conversions import str_to_bboxes
+from .common.metrics import calculate_iou
+import numpy as np
+
+
+class NbboxIouTuple:
+ """Calculates the IoU, for all bounding boxes, for all predicted bounding boxes.
+ For each predicted bounding box, it uses the IoU with the target bounding box with
+ the highest IoU.
+
+ Assumes that co-ordinates are normalized between 0 and 1 and that the bounding boxes
+ are of the form (x1, y1, x2, y2), where (x1, y1) is the top-left corner and (x2, y2)
+ is the bottom-right.
+ """
+
+ @classmethod
+ def match(cls, responses, targets) -> float:
+ """Exact match between targets and responses."""
+ logging.debug(f"{responses=}, {targets=}")
+ if not isinstance(responses, (tuple | list)):
+ responses = str_to_bboxes(responses)
+ if not isinstance(targets, (tuple | list)):
+ targets = str_to_bboxes(targets)
+
+ try:
+ iou_scores = calculate_iou(responses, targets)
+ except:
+ return 0
+
+ if not iou_scores:
+ return 0
+
+ # Take the mean IoU score for now.
+ return sum(iou_scores) / len(iou_scores)
+
+
+class NbboxIouSingle:
+ """
+ Single bbox IoU metric
+ """
+
+ @classmethod
+ def match(cls, responses, targets) -> float:
+ """Exact match between targets and responses."""
+ logging.debug(f"{responses=}, {targets=}")
+ targets = ast.literal_eval(targets)
+ try:
+ responses = ast.literal_eval(responses)
+ except SyntaxError:
+ return 0
+
+ try:
+ iou_scores = calculate_iou(
+ [
+ responses,
+ ],
+ [
+ targets,
+ ],
+ )
+ if not iou_scores:
+ return 0
+ except:
+ return 0
+
+ # Take the mean IoU score for now.
+ return sum(iou_scores) / len(iou_scores)
+
+
+class NbboxIouSequence:
+ """
+ Metric for a sequence of bboxes (used for single object tracking).
+ The number of predicted boxes must match the ground truth.
+ """
+
+ @classmethod
+ def match(cls, responses, targets) -> float:
+ """Exact match between targets and responses."""
+ if not isinstance(responses, (tuple | list)):
+ responses = str(responses) if not isinstance(responses, str) else responses
+ responses = str_to_bboxes(responses)
+ if not isinstance(targets, (tuple | list)):
+ targets = str_to_bboxes(targets)
+
+ if len(targets) != len(responses):
+ return 0
+
+ scores = []
+ for res, tgt in zip(responses, targets):
+ scores.append(
+ calculate_iou(
+ [
+ res,
+ ],
+ [
+ tgt,
+ ],
+ )
+ )
+ avg_iou = np.mean(scores)
+
+ return avg_iou
diff --git a/vlmeval/dataset/utils/megabench/scoring/near_str_match.py b/vlmeval/dataset/utils/megabench/scoring/near_str_match.py
new file mode 100644
index 0000000000000000000000000000000000000000..ad41909878f921a4dc676bccd69d0a2e07bb9ede
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/near_str_match.py
@@ -0,0 +1,23 @@
+import rapidfuzz
+import unidecode
+from .common.transformations import remove_def_indef_articles
+
+
+def approximate(text: str) -> str:
+ """Return an approximation of the original string."""
+ return unidecode.unidecode(remove_def_indef_articles(text)).lower()
+
+
+class NearStrMatch:
+ """Near string matching."""
+
+ @staticmethod
+ def match(response, correct_answer: str, threshold=0.9) -> int:
+ """Simple string match between response and correct_answer."""
+ if not isinstance(response, str) or not isinstance(correct_answer, str):
+ return 0
+ response = approximate(response)
+ correct_answer = approximate(correct_answer)
+ return rapidfuzz.distance.DamerauLevenshtein.normalized_similarity(
+ response, correct_answer, score_cutoff=threshold
+ )
diff --git a/vlmeval/dataset/utils/megabench/scoring/nli_entailment.py b/vlmeval/dataset/utils/megabench/scoring/nli_entailment.py
new file mode 100644
index 0000000000000000000000000000000000000000..71a29042a0b71f8775f7324b988cb96d51b32c9d
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/nli_entailment.py
@@ -0,0 +1,20 @@
+import torch
+from transformers import pipeline
+
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+pipe = pipeline(
+ "text-classification", model="microsoft/deberta-large-mnli", device=device
+)
+
+
+class NliEntailment:
+ """NLI entailment, where the correct answer is used as the premise."""
+
+ @staticmethod
+ def match(response, correct_answer) -> int:
+ """Return whether the response and correct answer agree with each other."""
+ if not isinstance(response, str) or isinstance(correct_answer, str):
+ return 0
+ resp = pipe(f"[CLS] {correct_answer.strip()} [SEP] {response.strip()} [SEP]")
+ return 1 if resp[0]["label"] == "ENTAILMENT" else 0
diff --git a/vlmeval/dataset/utils/megabench/scoring/normalized_similarity_damerau_levenshtein.py b/vlmeval/dataset/utils/megabench/scoring/normalized_similarity_damerau_levenshtein.py
new file mode 100644
index 0000000000000000000000000000000000000000..110ed84665d541dd9bc510b3c9faaad4bdd12ddc
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/normalized_similarity_damerau_levenshtein.py
@@ -0,0 +1,14 @@
+import rapidfuzz
+
+
+class NormalizedSimilarityDamerauLevenshtein:
+ """Normalized Damerau-Levenshtein Similarity."""
+
+ @staticmethod
+ def match(response, correct_answer) -> int:
+ """Normalized indel similarityuiio do between targets and responses."""
+ if not isinstance(response, str) and isinstance(correct_answer, str):
+ return 0
+ return rapidfuzz.distance.DamerauLevenshtein.normalized_similarity(
+ response, correct_answer
+ )
diff --git a/vlmeval/dataset/utils/megabench/scoring/number_rel_diff_ratio.py b/vlmeval/dataset/utils/megabench/scoring/number_rel_diff_ratio.py
new file mode 100644
index 0000000000000000000000000000000000000000..070023f2ab3516866eb121cd1121df67eac6ae55
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/number_rel_diff_ratio.py
@@ -0,0 +1,22 @@
+import ast
+import math
+from numbers import Number
+
+
+class NumberRelDiffRatio:
+ """Number relative difference ratio scoring = min(0, 1 - |pred - gt| / gt)"""
+
+ @staticmethod
+ def match(response: str | Number, correct_answer: str) -> int:
+ """Return the relative difference ratio."""
+ try:
+ if isinstance(response, Number):
+ pred = response
+ else:
+ pred = ast.literal_eval(response)
+ if not isinstance(pred, Number):
+ return 0
+ gt = ast.literal_eval(correct_answer)
+ return max(0, 1 - math.fabs((pred - gt) / gt))
+ except (SyntaxError, ValueError):
+ return 0
diff --git a/vlmeval/dataset/utils/megabench/scoring/positive_int_match.py b/vlmeval/dataset/utils/megabench/scoring/positive_int_match.py
new file mode 100644
index 0000000000000000000000000000000000000000..bd72d416dd22de6228a00e530174038cd9bbd08d
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/positive_int_match.py
@@ -0,0 +1,31 @@
+import ast
+
+
+class PositiveIntMatch:
+ """Positive int matching."""
+
+ @staticmethod
+ def match(response: str, correct_answer: str) -> int:
+ """If the correct answer or response is a positive integer, then it returns if the predicted and correct answers are identical.
+
+ Otherwise, it returns -1.
+ """
+ try:
+ response_obj = ast.literal_eval(response)
+ except (SyntaxError, ValueError):
+ return 0
+
+ if not correct_answer:
+ return 0
+
+ correct_answer_obj = ast.literal_eval(correct_answer)
+
+ assert isinstance(correct_answer_obj, int)
+ if not isinstance(response_obj, int):
+ return 0
+
+ # We only want to score the fields with a positive amount
+ if correct_answer_obj <= 0 and response_obj <= 0:
+ return -1
+
+ return 1 if response_obj == correct_answer_obj else 0
diff --git a/vlmeval/dataset/utils/megabench/scoring/program_judge.py b/vlmeval/dataset/utils/megabench/scoring/program_judge.py
new file mode 100644
index 0000000000000000000000000000000000000000..276be817a1558190d6c95cc0200ad837222bcba8
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/program_judge.py
@@ -0,0 +1,141 @@
+import io
+import pathlib
+import json
+import multiprocessing
+from unittest.mock import patch
+from multiprocessing.queues import Empty
+
+BIG_BENCH_PATH = pathlib.Path(__file__).resolve().parent.parent.parent
+
+
+class ProgramJudge:
+ """Program Judging."""
+
+ # Check if results have been saved for this metric instance
+ # prevent duplicate saving results
+ task_saved = {}
+
+ @classmethod
+ def save_test_results(cls, task_name, results, query_file):
+ query_base = pathlib.Path(query_file).parent
+ output_dir = query_base / "code_eval"
+ output_dir.mkdir(parents=True, exist_ok=True)
+ output_file = output_dir / f"{task_name}_test_case.json"
+
+ saved = cls.task_saved.get(task_name, False)
+ if output_file.is_file() and saved:
+ with open(output_file, "r") as f:
+ existing_data = json.load(f)
+ existing_data.extend(results)
+ else:
+ existing_data = results
+ cls.task_saved[task_name] = True
+ with open(output_file, "w") as f:
+ json.dump(existing_data, f, indent=4)
+
+ @staticmethod
+ def match(response: str, eval_context: str, task_info: str = None) -> int:
+ # Load all test cases from the benchmark_tasks directory
+ # task_name = task_info["task_name"]
+ # task_folder = task_info["task_folder"]
+ # query_results_file = task_info["results_file"]
+
+ test_cases = eval_context["test_case"]
+
+ # Create a CodeTester instance with the response and the found test cases
+ tester = CodeTester(response, test_cases)
+ score, results = tester.run_tests()
+
+ # ProgramJudge.save_test_results(task_name, results, query_results_file)
+ return score
+
+
+#########################################################
+### Implementation of the automatic code tester
+#########################################################
+
+
+class CodeTester:
+ def __init__(self, user_code, test_cases, timeout=2, verbose=True):
+ self.user_code = user_code
+ self.test_cases = test_cases
+ self.timeout = timeout
+ self.verbose = verbose
+
+ def run_user_code(self, input_data):
+ input_str = "\n".join(input_data) + "\n"
+ output_queue = multiprocessing.Queue()
+ process = multiprocessing.Process(
+ target=self.target, args=(output_queue, input_str)
+ )
+ process.start()
+
+ process.join(self.timeout)
+ if process.is_alive():
+ process.terminate()
+ return f"ERROR: Code execution exceeded the time limit."
+
+ try:
+ result = output_queue.get(timeout=10) # Add timeout for queue retrieval
+ except Empty:
+ return "ERROR: No output was produced before timeout."
+ finally:
+ output_queue.close() # Close the queue to release resources
+ output_queue.join_thread() # Ensure all items in the queue are processed
+
+ return result
+
+ def target(self, output_queue, input_str):
+ contains_main_block = 'if __name__ == "__main__":' in self.user_code
+ stdout = io.StringIO()
+ try:
+ with patch("builtins.input", side_effect=input_str.splitlines()):
+ with patch("sys.stdout", new=stdout):
+ if contains_main_block:
+ # If the user code contains the main block, execute in the context of __name__ == "__main__"
+ exec(self.user_code, {"__name__": "__main__"})
+ else:
+ # Otherwise, just execute the user code directly
+ exec(self.user_code)
+ except Exception as e:
+ output_queue.put(f"ERROR during execution: {e}")
+ else:
+ output_queue.put(stdout.getvalue().rstrip())
+
+ def evaluate_test_case(self, input_data, expected_output):
+ output = self.run_user_code(input_data)
+ return output == expected_output.rstrip(), output
+
+ def run_tests(self):
+ if isinstance(self.test_cases, dict):
+ self.test_cases = [self.test_cases]
+ total_tests = len(self.test_cases)
+ passed_tests = 0
+ results = []
+
+ for i, test_case in enumerate(self.test_cases, 1):
+ result, output = self.evaluate_test_case(
+ test_case["input"], test_case["expected"]
+ )
+
+ test_result = {
+ "response": self.user_code,
+ "test_case": test_case["input"],
+ "output": output,
+ "expected": test_case["expected"],
+ "result": "Passed" if result else "Failed",
+ }
+ results.append(test_result)
+
+ if result:
+ if self.verbose:
+ print(f"Test case {i}: Passed")
+ passed_tests += 1
+ else:
+ if self.verbose:
+ print(
+ f"Test case {i}: Failed - Expected {test_case['expected']} but got {output}"
+ )
+
+ score = passed_tests / total_tests if total_tests > 0 else 0
+ return score, results
diff --git a/vlmeval/dataset/utils/megabench/scoring/sacrebleu_bleu.py b/vlmeval/dataset/utils/megabench/scoring/sacrebleu_bleu.py
new file mode 100644
index 0000000000000000000000000000000000000000..63a2a265ce644f7cf483a77565bcb8e1c92b4164
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/sacrebleu_bleu.py
@@ -0,0 +1,22 @@
+from numbers import Number
+import sacrebleu
+
+
+class Bleu:
+ """Compute BLEU score, using SacreBLEU."""
+
+ @staticmethod
+ def match(response, correct_answer) -> Number:
+ """Compute the BLEU scores between two strings."""
+ if isinstance(response, str) and isinstance(correct_answer, str):
+ resp = [response]
+ corr = [correct_answer]
+ elif isinstance(response, (list, tuple)) and isinstance(
+ correct_answer, (list, tuple)
+ ):
+ resp = tuple(response)
+ corr = tuple(correct_answer)
+ else:
+ return 0
+ result = sacrebleu.corpus_bleu(corr, [resp]).score / 100
+ return result
diff --git a/vlmeval/dataset/utils/megabench/scoring/sequence_equality.py b/vlmeval/dataset/utils/megabench/scoring/sequence_equality.py
new file mode 100644
index 0000000000000000000000000000000000000000..7ef21103de37b8649b65f11b1af668a3c1c6859e
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/sequence_equality.py
@@ -0,0 +1,62 @@
+from .common.conversions import str_to_list
+from numbers import Number
+
+
+class SequenceEquality:
+ """Determines how much of the first part of the list
+ was predicted correctly.
+ """
+
+ @classmethod
+ def match(cls, responses, targets) -> int:
+ """Exact match between targets and responses."""
+ if not isinstance(responses, str):
+ responses = str(responses)
+ responses = str_to_list(responses)
+ targets = str_to_list(targets)
+ return 1 if responses == targets else 0
+
+
+class SequenceEqualityCaseInsensitive:
+ """Determines how much of the first part of the list
+ was predicted correctly.
+ """
+
+ @classmethod
+ def match(cls, responses, targets) -> int:
+ """Exact match between targets and responses."""
+ if not isinstance(responses, str):
+ responses = str(responses)
+ responses = str_to_list(responses)
+ targets = str_to_list(targets)
+
+ responses = [
+ item.lower() if isinstance(item, str) else str(item) for item in responses
+ ]
+ targets = [item.lower() for item in targets]
+ return 1 if responses == targets else 0
+
+
+class SequenceAccuracyCaseInsensitive:
+ """Determines how much of the first part of the list
+ was predicted correctly.
+ """
+
+ @classmethod
+ def match(cls, responses, targets) -> int:
+ """Exact match between targets and responses."""
+ responses = str_to_list(responses)
+ targets = str_to_list(targets)
+ if len(targets) != len(responses):
+ return 0
+ correct = 0
+ for res, tgt in zip(responses, targets):
+ if isinstance(tgt, str):
+ if res.lower() == tgt.lower():
+ correct += 1
+ elif isinstance(tgt, Number) and isinstance(res, Number):
+ if res == tgt:
+ correct += 1
+ else:
+ pass
+ return correct / len(targets)
diff --git a/vlmeval/dataset/utils/megabench/scoring/set_equality.py b/vlmeval/dataset/utils/megabench/scoring/set_equality.py
new file mode 100644
index 0000000000000000000000000000000000000000..01745bcf7cffe32c04573eae89edbbeba521033d
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/set_equality.py
@@ -0,0 +1,74 @@
+from .common.conversions import cast_to_set, str_to_set
+
+
+def _convert_to_hashable(item):
+ """将不可哈希的类型转换为可哈希类型"""
+ if isinstance(item, (list, tuple)):
+ return tuple(item) # 将列表转换为元组
+ return item
+
+
+class SetEquality:
+ """Determines whether two sets are equal."""
+
+ @classmethod
+ def match(cls, responses, targets) -> int:
+ """Exact match between targets and responses."""
+ if isinstance(responses, (list, tuple)):
+ responses = {_convert_to_hashable(item) for item in responses}
+ if isinstance(targets, (list, tuple)):
+ targets = {_convert_to_hashable(item) for item in targets}
+ return 1 if responses == targets else 0
+
+
+class SetEqualityCaseInsensitive:
+ """Determines whether two sets are equal, ignoring string case."""
+
+ @classmethod
+ def match(cls, responses, targets) -> int:
+ """Exact match between targets and responses."""
+ try:
+ responses: set[str] = {text.upper() for text in cast_to_set(responses)}
+ targets: set[str] = {text.upper() for text in cast_to_set(targets)}
+ except AttributeError:
+ return 0
+ return 1 if responses == targets else 0
+
+
+class StringSetEqualityLineSplit:
+ """Determines whether two sets are equal, for string inputs, separated by line breaks"""
+
+ @classmethod
+ def match(cls, responses, targets) -> int:
+ if "\\n" in targets:
+ targets = targets.replace("\\n", "\n")
+ if "\\n" in responses:
+ responses = responses.replace("\\n", "\n")
+ responses_set = set(responses.split("\n"))
+ targets_set = set(targets.split("\n"))
+ responses_set = {
+ item.lower() if isinstance(item, str) else item for item in responses_set
+ }
+ targets_set = {
+ item.lower() if isinstance(item, str) else item for item in targets_set
+ }
+ return 1 if responses_set == targets_set else 0
+
+
+class StringSetEqualityCommaSplit:
+ """Determines whether two sets are equal, for string inputs, separated by commas
+ Handles some corner cases that would fail the general SetEquality metric, like the string
+ with "None", which fails the eval. Also do case-insensitive eval.
+ """
+
+ @classmethod
+ def match(cls, responses, targets) -> int:
+ responses_set = str_to_set(responses)
+ targets_set = str_to_set(targets)
+ responses_set = {
+ item.lower() if isinstance(item, str) else item for item in responses_set
+ }
+ targets_set = {
+ item.lower() if isinstance(item, str) else item for item in targets_set
+ }
+ return 1 if responses_set == targets_set else 0
diff --git a/vlmeval/dataset/utils/megabench/scoring/set_precision.py b/vlmeval/dataset/utils/megabench/scoring/set_precision.py
new file mode 100644
index 0000000000000000000000000000000000000000..b030131f3fc04c2aa619195f5df385721ac0678f
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/set_precision.py
@@ -0,0 +1,16 @@
+from .common.conversions import cast_to_set
+from .common.metrics import set_precision
+
+
+class SetPrecision:
+ """Calculates the set precision for iterables."""
+
+ @classmethod
+ def match(cls, responses, targets) -> float:
+ """Exact match between targets and responses."""
+ if responses is None:
+ return 0
+ responses = cast_to_set(responses)
+ targets = cast_to_set(targets)
+
+ return set_precision(responses, targets)
diff --git a/vlmeval/dataset/utils/megabench/scoring/simple_str_match.py b/vlmeval/dataset/utils/megabench/scoring/simple_str_match.py
new file mode 100644
index 0000000000000000000000000000000000000000..e117410d7cfe4ca7498514839d344fbacf297ef4
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/simple_str_match.py
@@ -0,0 +1,29 @@
+from .exact_str_match import ExactStrMatch
+
+
+class SimpleStrMatch:
+ """Basic string matching, without spaces or hyphens."""
+
+ @staticmethod
+ def match(response, correct_answer: str) -> int:
+ """Simple string match between response and correct_answer."""
+ if not isinstance(response, str):
+ response = str(response) # If it is JSON-like
+ response = (
+ response.replace(" ", "")
+ .replace("-", "")
+ .replace("\n", "")
+ .replace("\t", "")
+ .replace(".", "")
+ .lower()
+ )
+ correct_answer = (
+ correct_answer.replace(" ", "")
+ .replace("-", "")
+ .replace("\n", "")
+ .replace("\t", "")
+ .replace(".", "")
+ .lower()
+ )
+
+ return ExactStrMatch.match(response, correct_answer)
diff --git a/vlmeval/dataset/utils/megabench/scoring/symbolic_planning.py b/vlmeval/dataset/utils/megabench/scoring/symbolic_planning.py
new file mode 100644
index 0000000000000000000000000000000000000000..165a43d4ed4d01e2a27cd49155d433c43d650b07
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/symbolic_planning.py
@@ -0,0 +1,266 @@
+import re
+
+PARAM_LIST_MATCHER = re.compile(r"((?:\?\S+\s*)+)(?:-\s+([^\?$]+)\s*)?")
+PARAM_NAME_MATCHER = re.compile(r"\?([^\s\?\)]+)\s*")
+
+
+##### Parsing functions and parentheses matching
+def parse_pddl_param_list(s):
+ s = s.strip()
+ assert s[0] == "(" and s[-1] == ")"
+ s = s[1:-1]
+ param_type_dict = {}
+ for params, p_type in PARAM_LIST_MATCHER.findall(s):
+ for p in PARAM_NAME_MATCHER.findall(params):
+ p_type = p_type.strip()
+ if p_type.startswith("("):
+ p_type = p_type[1:-1].strip()
+ assert "either"
+ param_type_dict[p] = re.split(r"\s+", p_type)[1:]
+ else:
+ param_type_dict[p] = p_type
+ return s.split("?")[0].strip(), param_type_dict
+
+
+def parse_outer_inner_str(s, str_ender, inner_starter, inner_ender):
+ inner_count = 0
+ start_id = 0
+ matched_str = []
+ for i, c in enumerate(s):
+ if inner_count == 0 and c == str_ender:
+ return s[: i + 1], matched_str, i + 1
+ elif c == inner_starter:
+ if inner_count == 0:
+ start_id = i
+ inner_count += 1
+ elif c == inner_ender:
+ inner_count -= 1
+ if inner_count == 0:
+ matched_str.append(s[start_id : i + 1])
+ return s, matched_str, len(s)
+
+
+def parse_pddl_attr_from_string(
+ s,
+ attr_starter="(:",
+ attr_ender=")",
+ inner_starter="(",
+ inner_ender=")",
+ overlap=False,
+):
+ s_attr = s.split(attr_starter)
+ if len(s_attr) == 1:
+ return "", []
+ elif len(s_attr) == 2:
+ outer_str, inner_str, _ = parse_outer_inner_str(
+ s_attr[1], attr_ender, inner_starter, inner_ender
+ )
+ return attr_starter + outer_str, inner_str
+ else:
+ matched_dict = {}
+ outer_list = []
+ if not overlap:
+ while len(s.split(attr_starter)) > 1:
+ s = s.split(attr_starter, 1)[1]
+ name = re.split(r"\s+", s.strip())[0]
+ outer_str, inner_str, end_point = parse_outer_inner_str(
+ s, attr_ender, inner_starter, inner_ender
+ )
+ outer_list.append(attr_starter + outer_str)
+ matched_dict[name] = inner_str
+ s = s[end_point:]
+ else:
+ for seg in s_attr[1:]:
+ name = re.split(r"\s+", seg.strip())[0]
+ outer_str, inner_str, _ = parse_outer_inner_str(
+ seg, attr_ender, inner_starter, inner_ender
+ )
+ outer_list.append(attr_starter + outer_str)
+ matched_dict[name] = inner_str
+ return outer_list, matched_dict
+
+
+def remove_type_in_cnf(s):
+ s_split_type = s.split(" - ")
+ if len(s_split_type) > 1:
+ for i in range(1, len(s_split_type)):
+ if len(s_split_type[i].strip().split(")")[0].split()) == 1:
+ s_split_type[i] = ")" + s_split_type[i].strip().split(")", 1)[1]
+ else:
+ s_split_type[i] = " " + s_split_type[i].strip().split(" ", 1)[1]
+ return "".join(s_split_type).strip()
+ else:
+ return s
+
+
+def split_cnf_by_parentheses(s):
+ assert s.startswith("(and")
+ matches = set()
+ p_count = 0
+ clause_start_id = 0
+ for i in range(len(s)):
+ if s[i] == "(":
+ p_count += 1
+ if p_count == 2:
+ clause_start_id = i
+ elif s[i] == ")":
+ p_count -= 1
+ if p_count == 0:
+ break
+ elif p_count == 1:
+ matches.add(remove_type_in_cnf(s[clause_start_id : i + 1]))
+ return matches
+
+
+##### End of parsing functions
+
+
+####### Domain (the env for each planning task)
+class Domain:
+ def __init__(self, name, domain_pddl):
+ # self.name = name
+
+ # Domain files
+ self.domain_pddl = domain_pddl
+ self.action_name, self.action_params, self.action_params_dict = (
+ self.get_domain_action()
+ )
+ self.gt_cond_dict = self.parse_gt_pre_post_cond()
+
+ def get_domain_action(self):
+ action_pddl_str_list, all_actions = parse_pddl_attr_from_string(
+ self.domain_pddl, attr_starter="(:action"
+ )
+ action_name, action_params, action_params_dict = [], [], []
+ for action_pddl_str, (name, action_attr) in zip(
+ action_pddl_str_list, all_actions.items()
+ ):
+ assert len(action_attr) == 3
+ param_str, pre_cond_str, post_cond_str = action_attr
+ action_name.append(name)
+ action_params.append(param_str)
+ action_params_dict.append(parse_pddl_param_list(param_str)[1])
+ return action_name, action_params, action_params_dict
+
+ def parse_gt_pre_post_cond(self):
+ cond_dict = {}
+ for a in self.action_name:
+ act_str = self.domain_pddl.split(f"(:action {a}")[1]
+ for postfix in ["pre", "post"]:
+ split_tag = ":precondition" if postfix == "pre" else ":effect"
+ cond_str = act_str.split(split_tag)[1].strip()
+ if cond_str.startswith("(and"):
+ cond_dict[f"{a}_{postfix}"] = split_cnf_by_parentheses(cond_str)
+ else:
+ cond_dict[f"{a}_{postfix}"] = {cond_str.split(")")[0].strip() + ")"}
+ cond_dict[f"{a}_{postfix}"] = sorted(
+ list(cond_dict[f"{a}_{postfix}"]),
+ key=lambda x: 0 if x.startswith("(not ") else 1,
+ )
+ return cond_dict
+
+
+##### Transition functions
+def construct_param_to_obj(domain, action):
+ action = action[1:-1]
+ a_name = action.split(" ")[0].strip()
+ objs = action.split(" ")[1:]
+ a_index = domain.action_name.index(a_name)
+ assert len(objs) == len(domain.action_params_dict[a_index])
+ return {p: obj for p, obj in zip(domain.action_params_dict[a_index], objs)}, a_name
+
+
+def state_transition(current_state, effects, param_to_obj):
+ for obj_cond in effects:
+ for param in param_to_obj:
+ obj_cond = re.sub(
+ r"\?{}(?=[^\w-])".format(param), param_to_obj[param], obj_cond
+ )
+ _, reversed_cond = parse_pddl_attr_from_string(obj_cond, attr_starter="(not ")
+ if reversed_cond:
+ assert len(reversed_cond) == 1
+ if reversed_cond[0] in current_state:
+ current_state.remove(reversed_cond[0])
+ elif obj_cond.strip() not in current_state:
+ current_state.append(obj_cond)
+ return current_state
+
+
+def check_pre_conds_satisfy(current_state, pre_conds, param_to_obj):
+ for obj_cond in pre_conds:
+ for param in param_to_obj:
+ obj_cond = re.sub(
+ r"\?{}(?=[^\w-])".format(param), param_to_obj[param], obj_cond
+ )
+ if (obj_cond.startswith("(not ") and obj_cond in current_state) or (
+ not obj_cond.startswith("(not ") and obj_cond not in current_state
+ ):
+ return False
+ return True
+
+
+##### End of transition functions
+
+
+class SymbolicPlanningMetricTest:
+ """An example metric for symbolic planning tasks"""
+
+ @classmethod
+ def match(cls, response, eval_context, task_info=None):
+ ## Initialize domain
+ # task_name = task_info["task_name"]
+ domain_pddl = eval_context["domain_pddl"]
+ domain = Domain(" ", domain_pddl)
+
+ ## Parse trajectory, setup initial and goal state
+ # response = eval_context["gt_plan"] # for debug
+ match response:
+ case str():
+ candidates = response.split("\n")
+ case tuple() | list():
+ candidates = list(response)
+ case _:
+ raise ValueError(
+ f"`response` has unsupported type: {type(response)=}, {response=}"
+ )
+ cand_traj = [cand_a.strip() for cand_a in candidates if cand_a.startswith("(")]
+ try:
+ task_pddl = eval_context["task_pddl"]
+ cur_state = parse_pddl_attr_from_string(task_pddl, attr_starter="(:init")[1]
+ goal_state = parse_pddl_attr_from_string(task_pddl, attr_starter="(and")[1]
+ except IndexError:
+ score = 0
+ return score
+
+ score = 1
+ try:
+ ## State transitions and check if satisfy the preconditions
+ for cand_a in cand_traj:
+ param_to_obj, a_name = construct_param_to_obj(domain, cand_a)
+ if not check_pre_conds_satisfy(
+ cur_state, domain.gt_cond_dict[f"{a_name}_pre"], param_to_obj
+ ):
+ print(f"precondition of the action {cand_a} is not satisfied!")
+ score = 0
+ break
+ cur_state = state_transition(
+ cur_state, domain.gt_cond_dict[f"{a_name}_post"], param_to_obj
+ )
+
+ ## Check if goal conditions are reached in the final state
+ if score == 1:
+ for g_state in goal_state:
+ if (g_state.startswith("(not ") and g_state in cur_state) or (
+ not g_state.startswith("(not ") and g_state not in cur_state
+ ):
+ print(f"goal state {g_state} is not reached!")
+ score = 0
+ break
+ except ValueError:
+ # grammar error in execution
+ score = 0
+ except AssertionError:
+ # assertion error in functions
+ score = 0
+
+ return score
diff --git a/vlmeval/dataset/utils/megabench/scoring/unsupported_scoring.py b/vlmeval/dataset/utils/megabench/scoring/unsupported_scoring.py
new file mode 100644
index 0000000000000000000000000000000000000000..baebd51e48a2e78f85c34f595b83a87c6d417889
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/unsupported_scoring.py
@@ -0,0 +1,7 @@
+class UnsupportedScoring:
+ """Unsupported scoring."""
+
+ @staticmethod
+ def match(response: str, correct_answer: str) -> int:
+ """Default response for unimplemented metrics."""
+ return -1
diff --git a/vlmeval/dataset/utils/megabench/scoring/vlm_as_judge.py b/vlmeval/dataset/utils/megabench/scoring/vlm_as_judge.py
new file mode 100644
index 0000000000000000000000000000000000000000..e911d416b96aa2b6cca26b9ab1eab42a8e908304
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/vlm_as_judge.py
@@ -0,0 +1,236 @@
+import abc
+import base64
+import os
+import requests
+import re
+from io import BytesIO
+from mimetypes import guess_type
+from PIL import Image
+
+
+class OpenAIVLMJudger(abc.ABC):
+ """
+ The OpenAI model class for calling GPT4o or textonly gpt as the juedge
+ for open-ended generation tasks
+ """
+
+ def __init__(
+ self,
+ metric_config,
+ model="gpt-4o-2024-08-06",
+ resize=True,
+ max_side=1000,
+ ):
+ if metric_config is not None and metric_config != {}:
+ self.judge_model_type = metric_config["judge_model_type"]
+ self.eval_prompt = metric_config["eval_criteria_prompt"]
+ self.reference_type = metric_config["reference_type"]
+ self.template_mapping = metric_config["template_mapping"]
+
+ self.api_key = os.getenv("OPENAI_API_KEY")
+ self.url = os.getenv("OPENAI_API_BASE")
+ self.model = model
+ self.resize = resize
+ self.max_side = max_side
+
+ # if os.getenv("MEGABENCH_OPEN_API_KEY") is not None:
+ # self.api_key = os.getenv("MEGABENCH_OPEN_API_KEY")
+ # self.url = os.getenv("MEGABENCH_OPEN_API_URL")
+ # if os.getenv("MEGABENCH_OPEN_API_MODEL") is not None:
+ # self.model = os.getenv("MEGABENCH_OPEN_API_MODEL")
+ # assert self.url, "You must set up the API URL for evaluating the Open tasks using your own API"
+
+ @staticmethod
+ def _update_image_path(image_path):
+ hf_home = os.getenv("HF_HOME", "~/.cache/huggingface")
+ base_cache_dir = os.path.expanduser(hf_home)
+ image_path = image_path.replace('./data/', f'{base_cache_dir}/megabench_data/data/')
+ return image_path
+
+ def create_image_content(self, image_path):
+ image_path = self._update_image_path(image_path)
+ base64_image, mime_type = self.encode_image(image_path)
+ return {
+ "type": "image_url",
+ "image_url": {"url": f"data:{mime_type};base64,{base64_image}"},
+ }
+
+ @property
+ def url(self) -> str:
+ """The server URL. We use OpenAI API by default. """
+ return self._url if hasattr(self, '_url') else "https://api.openai.com/v1/chat/completions"
+
+ @url.setter
+ def url(self, value: str) -> None:
+ """Set the server URL."""
+ self._url = value
+
+ @staticmethod
+ def _rgba_to_rgb(image):
+ background = Image.new("RGBA", image.size, (255, 255, 255, 255))
+ return Image.alpha_composite(background, image).convert("RGB")
+
+ def _resize_image(self, image):
+ resize_scale = self.max_side / max(image.size)
+ new_size = (
+ int(image.size[0] * resize_scale),
+ int(image.size[1] * resize_scale),
+ )
+ return image.resize(new_size)
+
+ def _encode_image(self, image, image_format):
+ with BytesIO() as output:
+ image.convert("RGB").save(output, format=image_format)
+ base64_encoded_data = base64.b64encode(output.getvalue()).decode("utf-8")
+ return base64_encoded_data
+
+ def encode_image(self, image_path, max_side=None):
+ mime_type, _ = guess_type(image_path)
+ if mime_type is None:
+ mime_type = "image/jpeg"
+ image_format = mime_type.split("/")[-1].upper() if mime_type else "JPEG"
+
+ image = Image.open(image_path)
+ # Handle the alpha channel
+ if image.mode == "RGBA":
+ image = self._rgba_to_rgb(image)
+ if not max_side and self.max_side:
+ max_side = self.max_side
+
+ if self.resize and max(image.size) > self.max_side:
+ image = self._resize_image(image)
+ encoded_image = self._encode_image(image, image_format)
+
+ return encoded_image, mime_type
+
+ def prepare_eval_prompt(
+ self, reference, response, images, question, eval_context=None
+ ):
+ content = []
+ if self.judge_model_type == "with image":
+ for image_path in images:
+ content.append(self.create_image_content(image_path))
+
+ prompt_mapping = {}
+ for key, val in self.template_mapping.items():
+ if val == "model_output":
+ prompt_mapping[key] = response
+ elif val == "example_question":
+ prompt_mapping[key] = question
+ elif val.split(".")[0] == "answers":
+ if isinstance(reference, str):
+ prompt_mapping[key] = reference
+ else:
+ # 如果是字典，则按原来的逻辑处理
+ key_name = val.split(".")[1]
+ prompt_mapping[key] = reference.get(key_name, '')
+ elif val.split(".")[0] == "eval_context":
+ key_name = val.split(".")[1]
+ prompt_mapping[key] = eval_context[key_name]
+
+ full_eval_prompt = self.eval_prompt.format(**prompt_mapping)
+
+ content.append({"type": "text", "text": full_eval_prompt})
+ return content
+
+ def query(self, reference_info, response, images, question, eval_context=None):
+ headers = {
+ "Content-Type": "application/json",
+ "Authorization": f"Bearer {self.api_key}",
+ }
+
+ context = self.prepare_eval_prompt(
+ reference_info, response, images, question, eval_context
+ )
+
+ query_payload = {
+ "model": self.model,
+ "messages": [{"role": "user", "content": context}],
+ "temperature": 0.0,
+ }
+
+ response_data = None
+ while response_data is None:
+ try:
+ response = requests.post(
+ self.url,
+ headers=headers,
+ json=query_payload,
+ )
+ response_ = response.json()
+ except (requests.exceptions.JSONDecodeError, requests.exceptions.ConnectionError) as e:
+ print(f'Error in requests: {e}')
+ print('Retry...')
+ continue
+
+ if "error" in response_:
+ error_info = response_["error"]
+ print(
+ f"Got error with type: {error_info['type']}. Message: {error_info['message']}"
+ )
+ if (
+ error_info["message"]
+ == """Sorry! We've encountered an issue with repetitive patterns in your prompt.
+ Please try again with a different prompt."""
+ ):
+ print(query_payload)
+ # If the model's response has too many repetitive tokens, then we give it a score of 0.
+ print("gpt-4o judge query failed...")
+ return f"**Score explanation**: {error_info['message']}\n\n**Score**: 0"
+ print("Retry...")
+ else:
+ response_data = response_
+ break
+
+ total_tokens = response_data.get("usage", {}).get("total_tokens", "N/A")
+
+ # Extracting the 'content' field from the response
+ if response_data and "choices" in response_data:
+ choices = response_data["choices"]
+ if choices and "message" in choices[0]:
+ message_content = choices[0]["message"]["content"]
+ print(
+ f"gpt-4o judge results: {message_content}; tokens:{total_tokens}"
+ )
+ else:
+ print("gpt-4o judge query failed...")
+ message_content = ""
+
+ return message_content
+
+
+class VLMJudgeScore:
+ """Using GPT-4o as a adjuge to evaluate open-ended generation tasks"""
+
+ def __init__(self, metric_config):
+ self.model = OpenAIVLMJudger(metric_config)
+
+ def parse_results(self, eval_results):
+ """
+ This parsing function is based on the output prompt setting in the
+ file "gpt4o_judge_prompt.json"
+ """
+ score_pattern = r"\*\*Score\*\*\s*:\s*(\d+)"
+ explanation_pattern = r"\*\*Score explanation\*\*\s*:\s*(.*)"
+
+ # Extract the score
+ score_match = re.search(score_pattern, eval_results)
+ score = int(score_match.group(1)) if score_match else None
+
+ # Extract the score explanation
+ explanation_match = re.search(explanation_pattern, eval_results, re.DOTALL)
+ explanation = explanation_match.group(1).strip() if explanation_match else ""
+ info_str = f"Score: {score}; Explanation: {explanation}"
+ if score is None:
+ return 0, f"Score is NULL: {eval_results};"
+
+ return score / 10.0, info_str
+
+ def match(
+ self, response, reference_dict, images, question, eval_context=None
+ ) -> int:
+ eval_results = self.model.query(
+ reference_dict, response, images, question, eval_context
+ )
+ score = self.parse_results(eval_results)
+ return score
diff --git a/vlmeval/dataset/utils/megabench/scoring/xml_nbbox_iou.py b/vlmeval/dataset/utils/megabench/scoring/xml_nbbox_iou.py
new file mode 100644
index 0000000000000000000000000000000000000000..7b61ce6e41cedbe0f59b02bf1b8f96a0b6bbcd47
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/xml_nbbox_iou.py
@@ -0,0 +1,33 @@
+import logging
+from .common.metrics import calculate_iou
+from .common.conversions import parse_bboxes_from_xml
+from numbers import Number
+
+
+class XmlNbboxIouSingle:
+ """Calculates the IoU of bounding box.
+
+ Assumes that co-ordinates are normalized between 0 and 1 and that the bounding boxes
+ are of the form top_left_x, top_left_y, bottom_right_x, bottom_right_y
+ """
+
+ @classmethod
+ def match(cls, responses, targets) -> float:
+
+ logging.debug(f"{responses=}, {targets=}")
+ if not isinstance(responses, (tuple | list)):
+ responses = parse_bboxes_from_xml(responses)
+ if not isinstance(targets, (tuple | list)):
+ targets = parse_bboxes_from_xml(targets)
+
+ if len(responses) == 0:
+ return 0
+ elif isinstance(responses[0], Number) and len(responses) == 4:
+ responses = [responses]
+
+ iou_scores = calculate_iou(responses, targets)
+ if not iou_scores:
+ return 0
+
+ # Take the mean IoU score for now.
+ return sum(iou_scores) / len(iou_scores)
diff --git a/vlmeval/dataset/utils/megabench/scoring/xml_norm_point_distance.py b/vlmeval/dataset/utils/megabench/scoring/xml_norm_point_distance.py
new file mode 100644
index 0000000000000000000000000000000000000000..e189596c8205ec0556c5b3aeebdee42894f0a16a
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/xml_norm_point_distance.py
@@ -0,0 +1,37 @@
+"""Return the normalized point distance."""
+
+from .common.conversions import parse_point_2d_from_xml
+from .common.metrics import point_distance
+
+
+class XmlNormPointDistance:
+ """Determines the distance between two points in XML notation.
+
+ Assumes that co-ordinates are normalized between 0 and 1 and that the 2D point is
+ of the form x, y .
+ """
+
+ @classmethod
+ def parse_2d_point(cls, point) -> tuple[float, float]:
+ """Parse a 2D point encoded in XML as x, y ."""
+ if not isinstance(point, (tuple | list)):
+ point = parse_point_2d_from_xml(point)
+ if not point:
+ raise ValueError("Point could not be parsed from XML string.")
+ elif len(point) != 2:
+ raise ValueError("Point is not 2D.")
+ if not all(0 <= comp <= 1 for comp in point):
+ raise ValueError("Point is not normalized.")
+ return tuple(point)
+
+ @classmethod
+ def match(cls, responses, targets) -> float:
+ """Determine the normalized distance between two points."""
+ try:
+ responses = cls.parse_2d_point(responses)
+ targets = cls.parse_2d_point(targets)
+ except ValueError:
+ return 0
+
+ # Instead of normalizing by 1/sqrt(2), we just set it to 0 if the distance is above 1.
+ return max(0, 1 - point_distance(responses, targets))
diff --git a/vlmeval/dataset/utils/megabench/scoring/xml_norm_point_in_bbox.py b/vlmeval/dataset/utils/megabench/scoring/xml_norm_point_in_bbox.py
new file mode 100644
index 0000000000000000000000000000000000000000..929a2dcf4923718f1baba48941905aa126246cc9
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/scoring/xml_norm_point_in_bbox.py
@@ -0,0 +1,35 @@
+from .common.conversions import parse_point_2d_from_xml, str_to_bboxes
+
+
+class XmlNormPointInBbox:
+ """Determines whether a point is located in a bounding box.
+
+ Assumes that co-ordinates are normalized between 0 and 1 and that the 2D point is
+ of the form x, y
+ """
+
+ @classmethod
+ def match(cls, responses, eval_context) -> int:
+ """Determine if the point is in the bounding box
+ and return which bounding box was matched, if any."""
+ bounding_box_has_match = {
+ bbox: False for bbox in eval_context["bounding_boxes"]
+ }
+ bounding_boxes = [
+ str_to_bboxes(bbox_str)[0] for bbox_str in eval_context["bounding_boxes"]
+ ]
+ assert bounding_boxes
+
+ if not isinstance(responses, (tuple | list)):
+ responses = parse_point_2d_from_xml(responses)
+ if not responses:
+ return 0, bounding_box_has_match
+ elif len(responses) != 2:
+ return 0, bounding_box_has_match
+
+ x, y = responses
+ for min_x, min_y, max_x, max_y in bounding_boxes:
+ if min_x <= x <= max_x and min_y <= y <= max_y:
+ bounding_box_has_match[str((min_x, min_y, max_x, max_y))] = True
+ return 1, bounding_box_has_match
+ return 0, bounding_box_has_match
diff --git a/vlmeval/dataset/utils/megabench/utils.py b/vlmeval/dataset/utils/megabench/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..8c32d27d6bf6c3624d2dc2e8bf32250bbb38ba95
--- /dev/null
+++ b/vlmeval/dataset/utils/megabench/utils.py
@@ -0,0 +1,69 @@
+import importlib
+from mimetypes import guess_type
+
+
+def lazy_import(module_name, class_name):
+ """Import the module lazily."""
+
+ def importer():
+ module = importlib.import_module(module_name)
+ return getattr(module, class_name)
+
+ return importer
+
+
+def is_video_file(file_path):
+ mime_type, _ = guess_type(file_path)
+ if not mime_type:
+ return False
+ return mime_type.startswith("video")
+
+
+
+def prepare_megabench_data(dataset_name, dataset_subset_name):
+ """
+ Prepare the MEGA-Bench dataset for evaluation.
+ Return:
+ subset_dataset: The organized data of the specified subset
+ all_dataset: The organized data of all tasks, used for evaluation
+ """
+ from datasets import load_dataset
+ if "single_image" in dataset_subset_name:
+ core_data = load_dataset(dataset_name, "core_single_image")
+ open_data = load_dataset(dataset_name, "open_single_image")
+ else:
+ core_data = load_dataset(dataset_name, "core")
+ open_data = load_dataset(dataset_name, "open")
+ core_test_samples = list(core_data["test"])
+ organized_core_dataset = organize_hf_dataset(core_test_samples)
+ open_test_samples = list(open_data["test"])
+ organized_open_dataset = organize_hf_dataset(open_test_samples)
+ subset_dataset = organized_core_dataset if "core" in dataset_subset_name else organized_open_dataset
+ all_dataset = organized_core_dataset + organized_open_dataset
+ return subset_dataset, all_dataset
+
+
+def organize_hf_dataset(dataset):
+ """
+ Organize the dataset with task-based manner
+
+ Return:
+ organized_dataset: list, each item is a dict, with the following keys:
+ - task_name: str
+ - task_query_samples: list of dicts, each dict contains the sample information
+ """
+ task_dict = {}
+ for sample in dataset:
+ task_name = sample["task_name"]
+ if task_name not in task_dict:
+ task_dict[task_name] = []
+ task_dict[task_name].append(sample)
+
+ organized_dataset = []
+ for task_name, samples in task_dict.items():
+ organized_dataset.append({
+ "task_name": task_name,
+ "task_samples": samples
+ })
+
+ return organized_dataset
diff --git a/vlmeval/dataset/utils/mlvu.py b/vlmeval/dataset/utils/mlvu.py
new file mode 100644
index 0000000000000000000000000000000000000000..c82fe3ee985d0560b4e34462ceb42d5690f57b5f
--- /dev/null
+++ b/vlmeval/dataset/utils/mlvu.py
@@ -0,0 +1,189 @@
+from ...smp import *
+from .multiple_choice import extract_answer_from_item
+from PIL import Image, ImageOps
+import numpy as np
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+system_prompt_sub_scene = """
+##TASK DESCRIPTION:
+You are required to evaluate a respondent's answer based on a provided question, some scoring points, and the respondent's answer. You should provide two scores. The first is the accuracy score, which should range from 1 to 5. The second is the relevance score, which should also range from 1 to 5. Below are the criteria for each scoring category.
+##ACCURACY Scoring Criteria:
+Evaluate the respondent's answer against specific scoring points as follows:
+Score 1: The response completely misses the scoring point.
+Score 3: The response mentions content related to the scoring point but is not entirely correct.
+Score 5: The response accurately addresses the scoring point.
+Calculate the average score across all scoring points to determine the final accuracy score.
+##RELEVANCE Scoring Criteria:
+Assess how the respondent's answer relates to the original question:
+Score 1: The response is completely off-topic from the question.
+Score 2: The response is partially related to the question but contains a significant amount of irrelevant content.
+Score 3: The response primarily addresses the question, but the respondent seems uncertain about their own answer.
+Score 4: The response mostly addresses the question and the respondent appears confident in their answer.
+Score 5: The response is fully focused on addressing the question with no irrelevant content and demonstrates complete certainty.
+----
+##INSTRUCTION:
+1. Evaluate Accuracy: First, assess and score each scoring point based on the respondent's answer. Calculate the average of these scores to establish the final accuracy score. Provide a detailed rationale before assigning your score.
+2. Evaluate RELEVANCE: Assess the relevance of the respondent’s answer to the question. Note that when evaluating relevance, the correctness of the answer is not considered; focus solely on how relevant the answer is to the question. Provide a comprehensive rationale before assigning your score.
+3. Output Scores in JSON Format: Present the scores in JSON format as follows:
+{'score_accuracy': score_acc, 'score_relevance': score_rele, 'total_score': score_acc + score_rele}
+""" # noqa
+
+system_prompt_summary = """
+##TASK DESCRIPTION:
+You are required to evaluate the performance of the respondent in the video summarization task based on the standard answer and the respondent's answer. You should provide two scores. The first is the COMPLETENESS score, which should range from 1 to 5. The second is the RELIABILITY score, which should also range from 1 to 5. Below are the criteria for each scoring category:
+##COMPLETENESS Scoring Criteria:
+The completeness score focuses on whether the summary covers all key points and main information from the video.
+Score 1: The summary hardly covers any of the main content or key points of the video.
+Score 2: The summary covers some of the main content and key points but misses many.
+Score 3: The summary covers most of the main content and key points.
+Score 4: The summary is very comprehensive, covering most to nearly all of the main content and key points.
+Score 5: The summary completely covers all the main content and key points of the video.
+##RELIABILITY Scoring Criteria:
+The reliability score evaluates the correctness and clarity of the video summary. It checks for factual errors, misleading statements, and contradictions with the video content. If the respondent's answer includes details that are not present in the standard answer, as long as these details do not conflict with the correct answer and are reasonable, points should not be deducted.
+Score 1: Contains multiple factual errors and contradictions; presentation is confusing.
+Score 2: Includes several errors and some contradictions; needs clearer presentation.
+Score 3: Generally accurate with minor errors; minimal contradictions; reasonably clear presentation.
+Score 4: Very accurate with negligible inaccuracies; no contradictions; clear and fluent presentation.
+Score 5: Completely accurate with no errors or contradictions; presentation is clear and easy to understand.
+----
+##INSTRUCTION:
+1. Evaluate COMPLETENESS: First, analyze the respondent's answer according to the scoring criteria, then provide an integer score between 1 and 5 based on sufficient evidence.
+2. Evaluate RELIABILITY: First, analyze the respondent's answer according to the scoring criteria, then provide an integer score between 1 and 5 based on sufficient evidence.
+3. Output Scores in JSON Format: Present the scores in JSON format as follows:
+{'score_completeness': score_comp, 'score_reliability': score_reli, 'total_score': score_comp + score_reli}
+""" # noqa
+
+
+def check_ans_with_model(pred, gt, model, item, dataset_name='MLVU_MCQ'):
+ flag = False
+
+ index = gt.index("(") # noqa
+ index2 = gt.index(")") # noqa
+ gt_option = gt[index + 1: index2]
+
+ if ")" in pred:
+ index3 = pred.index(")")
+ pred = pred[index3 - 1: index3]
+ if pred == gt_option:
+ flag = True
+ elif extract_answer_from_item(model, item, dataset_name)['opt'] == item['answer']:
+ flag = True
+
+ return flag
+
+
+def extract_scores_summary(text):
+ # Define the keys to locate in the text
+ keys = ["score_completeness", "score_reliability"]
+ scores = []
+
+ for key in keys:
+ # Find the index where each key starts
+ start_index = text.find(key)
+ if start_index == -1:
+ continue # Skip if key is not found
+
+ # Find the start of the number which is after the colon and space
+ start_number_index = text.find(":", start_index) + 2
+ end_number_index = text.find(",", start_number_index) # Assuming the number ends before a comma
+
+ # Extract and convert the number to float
+ score = float(text[start_number_index:end_number_index])
+ scores.append(score)
+
+ return scores
+
+
+def check_ans_with_model_summary(pred, gt, model, item, dataset_name='MLVU_OpenEnded'):
+ user_prompt = f"""
+ Please score the respondent's answer according to the steps in the Instructions. You must end with a JSON dict to store the scores.
+ Standard Answer: {gt}
+ Respondent's Answer: {pred}
+ """ # noqa
+ result = model.generate(user_prompt)
+ result = extract_scores_summary(result)
+ result = np.sum(result)
+ return result
+
+
+def extract_scores_sub_scene(text):
+ # Define the keys to locate in the text
+ keys = ["score_accuracy", "score_relevance"]
+ scores = []
+
+ for key in keys:
+ # Find the index where each key starts
+ start_index = text.find(key)
+ if start_index == -1:
+ continue # Skip if key is not found
+
+ # Find the start of the number which is after the colon and space
+ start_number_index = text.find(":", start_index) + 2
+ end_number_index = text.find(",", start_number_index) # Assuming the number ends before a comma
+
+ # Extract and convert the number to float
+ score = float(text[start_number_index:end_number_index])
+ scores.append(score)
+
+ return scores
+
+
+def check_ans_with_model_sub_scene(pred, gt, model, item, dataset_name='MLVU_OpenEnded'):
+ user_prompt = f"""
+ Please score the respondent's answer according to the steps in the Instructions. You must end with a JSON dict to store the scores.
+ Question: {item['question']}
+ Scoring Points: {item['scoring_points']}
+ Respondent's Answer: {pred}
+ """ # noqa
+ result = model.generate(user_prompt)
+ result = extract_scores_sub_scene(result)
+ result = np.sum(result)
+ return result
+
+
+def MLVU_OpenEnded_generate(model, line):
+ task_type = line['task_type']
+ if task_type == 'summary':
+ user_prompt = (
+ f"Please score the respondent's answer according to the steps in the Instructions. "
+ f"You must end with a JSON dict to store the scores.\n"
+ f"Standard Answer: {line['answer']}\n"
+ f"Respondent's Answer: {line['prediction']}\n"
+ )
+ elif task_type == 'sub_scene':
+ user_prompt = (
+ f"Please score the respondent's answer according to the steps in the Instructions. "
+ f"You must end with a JSON dict to store the scores.\n"
+ f"Question: {line['question']}\n"
+ f"Scoring Points: {line['scoring_points']}\n"
+ f"Respondent's Answer: {line['prediction']}\n"
+ )
+ else:
+ AssertionError(f'MLVU don\'t have {task_type} open ended task!')
+ result = model.generate(user_prompt)
+ return result
+
+
+def MLVU_OpenEnded_extract(gpt_generate_data, org_data):
+ extract_func = {
+ 'sub_scene': extract_scores_sub_scene,
+ 'summary': extract_scores_summary
+ }
+ for idx, item in org_data.iterrows():
+ func = extract_func[item['task_type']]
+ text = gpt_generate_data[idx]
+ org_data.loc[idx, 'score'] = np.sum(func(text))
+
+ return org_data
+
+
+def get_dimension_rating(data_path):
+ data = load(data_path)
+ result_dict = {}
+ for idx, item in data.iterrows():
+ if item['task_type'] not in result_dict:
+ result_dict[item['task_type']] = [0,0]
+ result_dict[item['task_type']][0] += int(item['score'])
+ result_dict[item['task_type']][1] += 1
+ return result_dict
diff --git a/vlmeval/dataset/utils/mmbench_video.py b/vlmeval/dataset/utils/mmbench_video.py
new file mode 100644
index 0000000000000000000000000000000000000000..75514b09bfd3b459b872059f6f0a7373b0b9c21f
--- /dev/null
+++ b/vlmeval/dataset/utils/mmbench_video.py
@@ -0,0 +1,70 @@
+from ...smp import *
+import numpy as np
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+system_prompt = """
+As an AI assistant, your task is to evaluate a candidate answer in comparison to a given correct answer.
+The question itself, the correct 'groundtruth' answer, and the candidate answer will be provided to you.
+Your assessment should range from 0 to 3, \
+based solely on the semantic similarity between the groundtruth and the candidate answer, \
+disregarding any grammatical differences.
+A rating of 0 suggests no similarity, implying the candidate answer is entirely incorrect.
+A rating of 1 suggests low similarity, meaning the candidate answer is largely incorrect.
+A rating of 2 suggests high similarity, meaning the candidate answer is largely correct.
+Lastly, a rating of 3 indicates complete similarity, which means the candidate answer is entirely correct.
+Your response should be a single integer from 0, 1, 2, or 3.
+"""
+
+MMV_DIMENSIONS = {
+ 'CP': ['Video Topic', 'Video Emotion', 'Video Scene', 'Video Style'],
+ 'FP-S': ['OCR', 'Object Recognition', 'Attribute Recognition', 'Event Recognition', 'Human Motion', 'Counting'],
+ 'FP-C': ['Spatial Relationship', 'Human-object Interaction', 'Human Interaction'],
+ 'HL': ['Hallucination'],
+ 'LR': ['Structuralized Image-Text Understanding', 'Mathematical Calculation'],
+ 'AR': ['Physical Property', 'Function Reasoning', 'Identity Reasoning'],
+ 'RR': ['Natural Relation', 'Physical Relation', 'Social Relation'],
+ 'CSR': ['Common Sense Reasoning'],
+ 'TR': ['Counterfactual Reasoning', 'Causal Reasoning', 'Future Prediction'],
+}
+L3_DIMS = []
+for k, v in MMV_DIMENSIONS.items():
+ L3_DIMS.extend(v)
+
+MMV_DIMENSIONS['Perception'] = []
+MMV_DIMENSIONS['Reasoning'] = []
+MMV_DIMENSIONS['Overall'] = []
+for k in ['CP', 'FP-C', 'FP-S', 'HL']:
+ MMV_DIMENSIONS['Perception'].extend(MMV_DIMENSIONS[k])
+ MMV_DIMENSIONS['Overall'].extend(MMV_DIMENSIONS[k])
+for k in ['LR', 'AR', 'RR', 'CSR', 'TR']:
+ MMV_DIMENSIONS['Reasoning'].extend(MMV_DIMENSIONS[k])
+ MMV_DIMENSIONS['Overall'].extend(MMV_DIMENSIONS[k])
+
+
+def get_dimension_rating(data_path):
+ data = load(data_path)
+ coarse_rating = {k: [] for k in MMV_DIMENSIONS}
+ fine_rating = {k: [] for k in L3_DIMS}
+
+ for i in range(len(data)):
+ cate = data.iloc[i]['dimensions']
+ cates = eval(cate)
+
+ for c in cates:
+ fine_rating[c].append(data.iloc[i]['score'])
+
+ for d in MMV_DIMENSIONS:
+ if np.any([x in MMV_DIMENSIONS[d] for x in cates]):
+ coarse_rating[d].append(data.iloc[i]['score'])
+
+ coarse_all = {k: f'{np.mean([max(x, 0) for x in v]):.2f}' for k, v in coarse_rating.items()}
+ coarse_valid = {k: f'{np.mean([x for x in v if x >= 0]):.2f}' for k, v in coarse_rating.items()}
+ fine_all = {k: f'{np.mean([max(x, 0) for x in v]):.2f}' for k, v in fine_rating.items()}
+ fine_valid = {k: f'{np.mean([x for x in v if x >= 0]):.2f}' for k, v in fine_rating.items()}
+ return dict(coarse_all=coarse_all, coarse_valid=coarse_valid, fine_all=fine_all, fine_valid=fine_valid)
+
+
+def build_prompt(item):
+ tmpl = 'Question: {}\nGroundtruth answer: {}\nCandidate answer: {}\nYour response: '
+ return tmpl.format(item['question'], item['answer'], item['prediction'])
diff --git a/vlmeval/dataset/utils/mmdocbench/extractor.py b/vlmeval/dataset/utils/mmdocbench/extractor.py
new file mode 100644
index 0000000000000000000000000000000000000000..e9e4c178dc3c1a802ddbd7d8155269da3bcf8a5a
--- /dev/null
+++ b/vlmeval/dataset/utils/mmdocbench/extractor.py
@@ -0,0 +1,357 @@
+import json
+import os
+import re
+
+import numpy as np
+import regex
+
+from vlmeval.dataset.utils.mmdocbench.parser import is_reasoning_task
+from vlmeval.smp.log import get_logger
+
+logger = get_logger('MMDocBench Evaluation')
+
+
+class PredictionExtractor:
+ @staticmethod
+ def string_to_bbox(input_text):
+ try:
+ return list(eval(input_text))
+ except:
+ co_list = re.findall(r'[\d.]+', input_text)
+ if len(co_list) == 4:
+ return [float(co) for co in co_list]
+ logger.debug(f'Fail to extract bbox: {input_text}')
+ return []
+
+ @staticmethod
+ def get_default(default_type='dict'):
+ if default_type == 'dict':
+ default_result = {}
+ elif default_type == '1d_array':
+ default_result = []
+ elif default_type == '2d_array':
+ default_result = []
+ else:
+ raise ValueError(f'Unexpected default type: {default_type}')
+
+ return default_result
+
+ @staticmethod
+ def form_outer_bbox(bbox_list):
+ if len(bbox_list) == 0:
+ return []
+ outer_x0 = min([bbox[0] for bbox in bbox_list])
+ outer_y0 = min([bbox[1] for bbox in bbox_list])
+ outer_x1 = max([bbox[2] for bbox in bbox_list])
+ outer_y1 = max([bbox[3] for bbox in bbox_list])
+ return [outer_x0, outer_y0, outer_x1, outer_y1]
+
+ @classmethod
+ def group_data_to_lines(cls, ids, words, bboxes):
+ block_matrix = []
+ not_allocate_pool = [[idx, word, bbox] for idx, word, bbox in zip(ids, words, bboxes)]
+ while len(not_allocate_pool) > 0:
+ remain_pool = []
+ # find first character # sort by y first and then x
+ sorted_block_list = sorted(not_allocate_pool, key=lambda x: (x[2][1] ** 2, x[2][0] ** 2))
+ first_block = sorted_block_list[0]
+
+ first_block_bbox = first_block[2]
+ line_block_list = [first_block]
+ for i in range(1, len(sorted_block_list)):
+ next_block = sorted_block_list[i]
+ next_block_bbox = next_block[2]
+ next_y_central = (next_block_bbox[1] + next_block_bbox[3]) * 0.5
+ if first_block_bbox[1] <= next_y_central <= first_block_bbox[3]:
+ line_block_list.append(next_block)
+ else:
+ remain_pool.append(next_block)
+ line_central_y_list = []
+ for one_block in line_block_list:
+ one_block_bbox = one_block[2]
+ line_central_y_list.append(one_block_bbox[1])
+ line_central_y_list.append(one_block_bbox[3])
+ line_central_y = np.mean(line_central_y_list)
+ line_block_list = sorted(line_block_list, key=lambda x: (x[2][0] + x[2][2]) / 2)
+ block_matrix.append((line_block_list, line_central_y))
+ not_allocate_pool = remain_pool
+
+ sorted_block_matrix = sorted(block_matrix, key=lambda x: x[1], reverse=False)
+
+ line_texts = []
+ line_bboxes = []
+
+ for line_block_list, _ in sorted_block_matrix:
+ line_text = ' '.join([w for _, w, _ in line_block_list])
+ line_bbox = cls.form_outer_bbox([b for _, _, b in line_block_list])
+ line_texts.append(line_text)
+ line_bboxes.append(line_bbox)
+
+ return line_texts, line_bboxes
+
+ @classmethod
+ def process_prediction_as_raw_string_for_textmonkey(cls, pred_str, task_name, sub_task_name, default='dict'):
+ default_result = cls.get_default(default_type=default)
+
+ prediction_results = None
+ if 'Bbox2Text' in sub_task_name:
+ return {'answer': pred_str, 'bbox': []}
+ elif 'Text2Bbox' in sub_task_name:
+ m = re.search(r'(\(\d+,\d+\)),(\(\d+,\d+\))', pred_str)
+ if m:
+ bbox = list(eval(m.group(1)) + eval(m.group(2)))
+ return {'answer': '', 'bbox': bbox}
+ elif default != '2d_array':
+ words = re.findall(r'(.*?)(\(\d+,\d+\)),(\(\d+,\d+\))', pred_str)
+ if words:
+ word_texts = [w_tuple[0] for w_tuple in words]
+ word_bboxes = [list(eval(w_tuple[1]) + eval(w_tuple[2])) for w_tuple in words]
+ ids = list(range(len(word_texts)))
+ line_texts, line_bboxes = cls.group_data_to_lines(ids, word_texts, word_bboxes)
+ else:
+ line_bboxes = []
+ line_texts = [pred_str]
+ if default == 'dict':
+ return {'answer': '\n'.join(line_texts), 'bbox': cls.form_outer_bbox(line_bboxes)}
+ return [{'answer': line_text, 'bbox': line_bbox} for line_text, line_bbox in zip(line_texts, line_bboxes)]
+ elif default == '2d_array':
+ return default_result
+
+ return prediction_results
+
+ @staticmethod
+ def find_all_with_regex_list(text, regex_list):
+ for one in regex_list:
+ results = re.findall(one, text)
+ if results:
+ return results
+
+ @classmethod
+ def process_prediction_as_raw_string(cls, pred_str, task_name, default='dict', model_name='', sub_task_name=''):
+ if model_name == 'textmonkey':
+ return cls.process_prediction_as_raw_string_for_textmonkey(pred_str, task_name, sub_task_name, default)
+
+ default_result = cls.get_default(default_type=default)
+
+ prediction_results = None
+ if 'Text2Bbox' in sub_task_name:
+ m = re.search(r'answer":\s*(\[(?:\d+|[0-1]\.\d+)(?:,\s*(?:\d+|[0-1]\.\d+)){3}\])', pred_str)
+ if m:
+ prediction_results = {'answer': '', 'bbox': cls.string_to_bbox(m.group(1))}
+ elif not is_reasoning_task(task_name) and default not in ['2d_array']:
+ # simple or 1d array
+ regex_list = [
+ r'is\s*"([^"]+)"[^[]+(\[(?:\d+|[0-1]\.\d+)(?:,\s*(?:\d+|[0-1]\.\d+)){3}\])',
+ r'is\s*"([^"]+)".+?\((\d+(?:,\s*\d+){3})\)',
+ # answer must exist; bbox can be empty
+ r'answer":\s*"([^"]+)",?\s*"bbox":\s*(\[(?:(?:\d+|[0-1]\.\d+)(?:,\s*(?:\d+|[0-1]\.\d+)){3})?\])',
+ ]
+ candidates = cls.find_all_with_regex_list(pred_str, regex_list)
+ if candidates:
+ candidates = list(dict.fromkeys(candidates))
+ prediction_results = [{'answer': c[0], 'bbox': cls.string_to_bbox(c[1])} for c in candidates]
+ if default == 'dict':
+ prediction_results = prediction_results[0]
+ else:
+ candidates = re.findall(r'answer":\s*"([^"]+)', pred_str)
+ if candidates:
+ candidates = list(dict.fromkeys(candidates))
+ prediction_results = [{'answer': c, 'bbox': []} for c in candidates]
+ if default == 'dict':
+ prediction_results = prediction_results[0]
+ elif default == 'dict':
+ prediction_results = {'answer': pred_str, 'bbox': []}
+ else:
+ prediction_results = [{'answer': pred_str, 'bbox': []}]
+
+ elif is_reasoning_task(task_name):
+ # reasoning
+ # answer must exit; bbox can be empty
+ m = re.search(
+ r'answer":\s*"([^"]+)",?\s*"bbox":\s*(\[(?:(?:\d+|[0-1]\.\d+)(?:,\s*(?:\d+|[0-1]\.\d+)){3})?\])',
+ pred_str,
+ )
+ if m:
+ final_answer = m.group(1)
+ final_answer_bbox = cls.string_to_bbox(m.group(2))
+ # text and bbox can be empty
+ evidence_candidates = re.findall(
+ r'text":\s*"([^"]*)",?\s*"bbox":\s*(\[(?:(?:\d+|[0-1]\.\d+)(?:,\s*(?:\d+|[0-1]\.\d+)){3})?\])',
+ pred_str,
+ )
+ if evidence_candidates:
+ evidence_candidates = list(dict.fromkeys(evidence_candidates))
+ one_candidate = {
+ 'answer': final_answer,
+ 'bbox': final_answer_bbox,
+ 'supporting_evidence': [
+ {'text': c[0], 'bbox': cls.string_to_bbox(c[1])} for c in evidence_candidates
+ ],
+ }
+ prediction_results = one_candidate
+ else:
+ prediction_results = {
+ 'answer': final_answer,
+ 'bbox': final_answer_bbox,
+ 'supporting_evidence': [{'text': pred_str[m.end():], 'bbox': []}],
+ }
+ else:
+ prediction_results = {'answer': pred_str, 'bbox': [], 'supporting_evidence': []}
+ elif default == '2d_array':
+ # answer and bbox can be empty
+ row_candidates = re.finditer(
+ (
+ r'\[(?:[^[]*answer":\s*"[^"]*",?\s*"bbox":\s*\['
+ r'(?:(?:\d+|[0-1]\.\d+)(?:,\s*(?:\d+|[0-1]\.\d+)){3})?\])+[^\[\]]*\]'
+ ),
+ pred_str,
+ )
+ tmp_results = []
+ pointer = None
+ for one_row_m in row_candidates:
+ try:
+ tmp_results.append(json.loads(one_row_m.group()))
+ except:
+ cells = re.findall(
+ (
+ r'answer":\s*"([^"]*)",?\s*"bbox":\s*(\[(?:(?:\d+|[0-1]\.\d+)'
+ r'(?:,\s*(?:\d+|[0-1]\.\d+)){3})?\])'
+ ),
+ one_row_m.group(),
+ )
+ row = [{'answer': c[0], 'bbox': cls.string_to_bbox(c[1])} for c in cells]
+ tmp_results.append(row)
+ pointer = one_row_m.end()
+ if pointer:
+ remains = re.findall(
+ r'answer":\s*"([^"]*)",?\s*"bbox":\s*(\[(?:(?:\d+|[0-1]\.\d+)(?:,\s*(?:\d+|[0-1]\.\d+)){3})?\])',
+ pred_str[pointer:],
+ )
+ if remains:
+ remains = list(dict.fromkeys(remains))
+ last_row = [{'answer': c[0], 'bbox': cls.string_to_bbox(c[1])} for c in remains]
+ tmp_results.append(last_row)
+ max_column_count = max([len(row) for row in tmp_results])
+ prediction_results = []
+ for row in tmp_results:
+ row = row + [{'answer': '', 'bbox': []}] * (max_column_count - len(row))
+ prediction_results.append(row)
+
+ if not prediction_results:
+ prediction_results = default_result
+
+ return prediction_results
+
+ @classmethod
+ def process_prediction_as_json(cls, pred_str, task_name, default='dict', model_name='', sub_task_name=''):
+ # clear noise which hinder json parsing
+ pred_str = re.sub(r'"bbox":\s*\[empty\]', '"bbox": []', pred_str)
+ if model_name == 'MiniCPM-Llama3-V-2_5':
+ pred_str = re.sub(r'', '[', pred_str)
+ pred_str = re.sub(r' \]?', ']', pred_str)
+
+ # First match content enclosed in a JSON comment block
+ json_comment_pattern = regex.compile(r'```json\s*({.*?})\s*```', regex.DOTALL)
+ json_comment_match = json_comment_pattern.search(pred_str)
+ json_string_candidates = []
+ if json_comment_match:
+ try:
+ json_string = json_comment_match.group(1)
+ json_dict = json.loads(json_string)
+ json_string_candidates = [json_string]
+ except json.JSONDecodeError:
+ logger.debug(f'Failed to decode JSON from comment block: {json_comment_match.group(1)}')
+
+ # If no JSON comment block is found, continue searching for JSON strings
+ if not json_string_candidates:
+ pattern = regex.compile(r'\{(?:(?R)|[^{}]*)++\}|\[(?:(?R)|[^[{}\]]*)++\]')
+
+ json_string_candidates = pattern.findall(pred_str)
+
+ default_result = cls.get_default(default_type=default)
+ json_dict = default_result
+ if json_string_candidates:
+ for json_string in json_string_candidates:
+ try:
+ tmp_dict = json.loads(json_string)
+ if default == '1d_array':
+ is_valid = isinstance(tmp_dict, list) and len(tmp_dict) > 0 and isinstance(tmp_dict[0], dict)
+ elif default == '2d_array':
+ is_valid = (
+ isinstance(tmp_dict, list)
+ and len(tmp_dict) > 0
+ and isinstance(tmp_dict[0], list)
+ and len(tmp_dict[0]) > 0
+ and isinstance(tmp_dict[0][0], dict)
+ )
+ elif default == 'dict':
+ is_valid = isinstance(tmp_dict, dict) and len(tmp_dict) > 0
+ if is_valid and is_reasoning_task(task_name):
+ is_valid = len(
+ {'answer', 'bbox', 'supporting_evidence'} - tmp_dict.keys()
+ ) == 0 and isinstance(tmp_dict['supporting_evidence'], list)
+ else:
+ raise ValueError(default)
+ if is_valid:
+ json_dict = tmp_dict
+ if 'Text2Bbox' in sub_task_name:
+ if 'first_occurrence' in json_dict:
+ json_dict['bbox'] = json_dict.pop('first_occurrence')
+ json_dict['answer'] = ''
+ elif 'answer' in json_dict and 'bbox' not in json_dict:
+ json_dict['bbox'] = json_dict.pop('answer')
+ json_dict['answer'] = ''
+ elif is_reasoning_task(task_name):
+ if 'supporting_evidence' in json_dict:
+ if isinstance(json_dict['supporting_evidence'], dict):
+ json_dict['supporting_evidence'] = [json_dict['supporting_evidence']]
+ # remove string type
+ json_dict['supporting_evidence'] = [
+ e for e in json_dict['supporting_evidence'] if isinstance(e, dict)
+ ]
+ break
+ except:
+ pass
+
+ return json_dict, json_string_candidates
+
+ @classmethod
+ def process_na(cls, pred_str, task_name, default='dict'):
+ default_answer = cls.get_default(default_type=default)
+ blacklist = [
+ 'not possible to answer',
+ 'cannot provide an answer',
+ 'there are no supporting evidences to provide',
+ 'I cannot answer the question',
+ 'the task cannot be completed',
+ ]
+ forgery_blacklist = ['would conclude that there are no forged texts', 'no forged texts', 'there are no']
+
+ blacklist_to_use = blacklist if 'Forgery' not in task_name else forgery_blacklist
+ for i in blacklist_to_use:
+ if i in pred_str.lower():
+ return default_answer
+
+ return None
+
+ @classmethod
+ def process_prediction(cls, pred_str, task_name, default='dict', model_name='', raw_question='', sub_task_name=''):
+ # check if no answer
+ na = cls.process_na(pred_str, task_name, default=default)
+ if na is not None:
+ return na
+
+ prediction_dict, json_string_candidates = cls.process_prediction_as_json(
+ pred_str, task_name, default, model_name, sub_task_name
+ )
+ if not prediction_dict:
+ prediction_dict = cls.process_prediction_as_raw_string(
+ pred_str, task_name, default, model_name, sub_task_name
+ )
+
+ if not prediction_dict:
+ candidate_str = '\n +'.join([repr(c) for c in json_string_candidates])
+ logger.debug(f'[{task_name}]Unable to parse as json. Candidates: {candidate_str}')
+ logger.debug(f'[{task_name}]Unable to parse as raw string either: {repr(pred_str)}')
+
+ return prediction_dict
diff --git a/vlmeval/dataset/utils/mmdocbench/parser.py b/vlmeval/dataset/utils/mmdocbench/parser.py
new file mode 100644
index 0000000000000000000000000000000000000000..143bec53d955fff3b136f40067894aea4b2e0677
--- /dev/null
+++ b/vlmeval/dataset/utils/mmdocbench/parser.py
@@ -0,0 +1,934 @@
+import math
+import os
+import re
+import string
+import unicodedata
+from dataclasses import dataclass
+from decimal import Decimal, InvalidOperation
+from typing import Optional
+
+import regex
+
+from vlmeval.smp.log import get_logger
+
+logger = get_logger('MMDocBench Evaluation')
+
+
+def digit_fix(text):
+ manualMap = {
+ 'zero': '0',
+ 'one': '1',
+ 'two': '2',
+ 'three': '3',
+ 'four': '4',
+ 'five': '5',
+ 'six': '6',
+ 'seven': '7',
+ 'eight': '8',
+ 'nine': '9',
+ 'ten': '10',
+ }
+ ori_text = text
+ for string_number, digit_number in manualMap.items():
+ text = re.sub(rf'\b{string_number}\b', digit_number, text, flags=re.I)
+
+ if ori_text != text:
+ logger.debug(f'[Digit Fix] {repr(ori_text)} -----> {repr(text)}')
+
+ return text
+
+
+def month_fix(text):
+ month_abbreviations = {
+ 'jan': 'January',
+ 'feb': 'February',
+ 'mar': 'March',
+ 'apr': 'April',
+ 'may': 'May', # May is the same abbreviation and full form
+ 'jun': 'June',
+ 'jul': 'July',
+ 'aug': 'August',
+ 'sep': 'September',
+ 'oct': 'October',
+ 'nov': 'November',
+ 'dec': 'December',
+ }
+ # Create a regex pattern that matches any of the abbreviations.
+ # The r'\b' ensures that we match whole words (word boundaries).
+ pattern = r'\b(' + '|'.join(month_abbreviations.keys()) + r')(?:\b|(?=\d))'
+
+ def replace_match(match):
+ abbr = match.group(0)
+ return month_abbreviations[abbr.lower()]
+
+ return re.sub(pattern, replace_match, text, flags=re.IGNORECASE)
+
+
+def normalize_text(s, keep_newline=False):
+ """Removing articles and punctuation, and standardizing whitespace are all typical text processing steps."""
+
+ def remove_articles(text):
+ _regex = regex.compile(r'\b(a|an|the)\b', regex.UNICODE)
+ return regex.sub(_regex, ' ', text)
+
+ def white_space_fix(text):
+ if keep_newline:
+ text = text.replace('\n', '⚽')
+ text = ' '.join(text.split())
+ text = text.replace('⚽', '\n')
+ return text
+ return ' '.join(text.split())
+
+ def remove_punc(text):
+ exclude = set(string.punctuation)
+ return ''.join(ch for ch in text if ch not in exclude)
+
+ def lower(text):
+ return text.lower()
+
+ return white_space_fix(digit_fix(remove_articles(remove_punc(lower(s)))))
+
+
+def normalize_narrative_text(text: str, raw_question: str, sub_task_name: str) -> str:
+ if re.search(r'\bdate\b', raw_question, re.I):
+ # replace month abbreviations with full value, e.g., Dec -> December
+ text = month_fix(text)
+
+ # Remove diacritics
+ text = ''.join(c for c in unicodedata.normalize('NFKD', text) if unicodedata.category(c) != 'Mn')
+ # Normalize quotes and dashes
+ text = re.sub(r'[‘’´`]', "'", text)
+ text = re.sub(r'[“”]', '"', text)
+ text = re.sub(r'[‐‑‒–—−]', '-', text)
+ while sub_task_name == 'WTQ':
+ old_x = text
+ # Remove citations
+ text = re.sub(r'((? len(s2):
+ s1, s2 = s2, s1
+
+ distances = range(len(s1) + 1)
+ for i2, c2 in enumerate(s2):
+ distances_ = [i2 + 1]
+ for i1, c1 in enumerate(s1):
+ if c1 == c2:
+ distances_.append(distances[i1])
+ else:
+ distances_.append(1 + min((distances[i1], distances[i1 + 1], distances_[-1])))
+ distances = distances_
+ return distances[-1]
+
+
+def anls_compute(groundtruth, prediction):
+ gt_answer = ' '.join(groundtruth.strip().lower().split())
+ det_answer = ' '.join(prediction.strip().lower().split())
+ dist = levenshtein_distance(gt_answer, det_answer)
+ length = max(len(groundtruth.upper()), len(prediction.upper()))
+ values = 0.0 if length == 0 else float(dist) / float(length)
+ return values
+
+
+def is_reasoning_task(task_name):
+ return task_name in [
+ 'Arithmetic Reasoning',
+ 'Logical Reasoning',
+ 'Spatial Reasoning',
+ 'Comparison',
+ 'Sorting',
+ 'Counting',
+ ]
+
+
+def is_narrative_kie(task_name: str, raw_question: str):
+ narrative_tags = [
+ 'item name',
+ 'add-on name',
+ 'date',
+ 'address',
+ 'company',
+ 'Store_addr_value',
+ 'Store_name_value',
+ 'Tel_value',
+ 'Date_value',
+ 'Time_value'
+ ]
+ if task_name == 'Key Information Extraction':
+ return re.search(fr'"(?:{"|".join(narrative_tags)})"', raw_question, re.I)
+
+ return False
+
+
+@dataclass
+class NumberValue:
+ parsed_value: str
+ status: bool
+ from_percentage: bool = False
+ decimal_num: Optional[int] = None
+
+ def __post_init__(self):
+ self.decimal_num = self.decimal_num or 0
+
+ def restore_to_value_before_percentage(self):
+ self.decimal_num = max(0, self.decimal_num - 2)
+ if self.decimal_num == 0:
+ self.parsed_value = str(int(Decimal(self.parsed_value) * 100))
+ else:
+ self.parsed_value = str(float(Decimal(self.parsed_value) * 100))
+ self.from_percentage = False
+
+ def get_rounded_str(self, round_num: int = 2):
+ # make sure ('1.23', 3) -> '1.23'
+ try:
+ return str(float(round(Decimal(self.parsed_value), round_num)))
+ except InvalidOperation:
+ logger.warning(f'Invalid value: {self.parsed_value}')
+ return self.parsed_value
+
+ def get_int_str(self):
+ return str(int(float(self.parsed_value)))
+
+ def maybe_percentage_error(self, other_num: 'NumberValue'):
+ if self.status and other_num.status and Decimal(self.parsed_value) * 100 == Decimal(other_num.parsed_value):
+ return True
+ return False
+
+ def maybe_rounding_error(self, other_num: 'NumberValue'):
+ min_decimal_num = min(self.decimal_num, other_num.decimal_num)
+ diff_from_other = abs(Decimal(self.parsed_value) - Decimal(other_num.parsed_value))
+ tolerance = (Decimal('0.1') ** min_decimal_num) * Decimal('0.1')
+ if diff_from_other <= tolerance:
+ return True
+ return False
+
+ def maybe_sign_error(self, other_num: 'NumberValue'):
+ ori_unequal = self.parsed_value != other_num.parsed_value
+ if other_num.status and ori_unequal and abs(Decimal(self.parsed_value)) == abs(Decimal(other_num.parsed_value)):
+ return True
+ return False
+
+ def maybe_thousands_error(self, other_num: 'NumberValue'):
+ if self.status and other_num.status and Decimal(self.parsed_value) * 1000 == Decimal(other_num.parsed_value):
+ return True
+
+
+class TextParser:
+ @staticmethod
+ def parse_number(value):
+ if re.search(r',\s?\d{2}\D*$', value):
+ idx = value.rfind(r',')
+ if idx != -1:
+ value = value[:idx] + '.' + value[idx + 1:]
+ percentage_flag = False
+ percentage_exists = re.search(r'(\s[-+]?[\d.]*\d+ ?%)|(^[-+]?[\d.]*\d+ ?%)', value)
+ not_alternative = re.search(
+ r'(?:\d{1,3}(?:,\d{3})*|\d+\.\d+ million,)\s+or\s+\d{1,2}(?:\.\d+)? ?%', value
+ ) is None
+ if percentage_exists and not_alternative:
+ percentage_flag = True
+ # remove disturbing '-'
+ value = re.sub(r'(?<=[a-z] )-(?= [$€£¥]?\d+)', '', str(value), flags=re.I)
+ # remove disturbing '.'
+ value = re.sub(r'\([a-z,. ]+\)', '', str(value), flags=re.I)
+ # remove Rp.
+ value = re.sub(r'\brp\.', '', str(value), flags=re.I)
+ s = ''.join([ch for ch in str(value) if ch not in '\'"\\$€£¥%(),[]* '])
+ r_num = r'([+-]?\d+(\.\d+)?)|([+-]?\.\d+)'
+ groups = re.findall(r_num, s)
+ if len(groups) == 0:
+ return NumberValue(value, False, False, None)
+ num = groups[0][0] or groups[0][2]
+ if num == '':
+ return NumberValue(value, False, False, None)
+ if '.' in num:
+ if percentage_flag:
+ float_value = str(float(Decimal(num) / 100))
+ else:
+ float_value = str(float(num))
+ decimal_num = len(float_value) - float_value.rfind('.') - 1
+ return NumberValue(float_value, status=True, from_percentage=percentage_flag, decimal_num=decimal_num)
+ elif percentage_flag:
+ float_value = str(float(Decimal(num) / 100))
+ decimal_num = len(float_value) - float_value.rfind('.') - 1
+ return NumberValue(float_value, status=True, from_percentage=percentage_flag, decimal_num=decimal_num)
+ return NumberValue(str(int(num)), status=True, from_percentage=percentage_flag, decimal_num=None)
+
+ @staticmethod
+ def parse_ordinal_number(value):
+ pattern = r'(?:^|(?<=\s))(?:first|second|third|fourth|fifth|sixth|seventh|eighth|ninth|tenth)(?:$|(?=\s))'
+ m = re.search(pattern, value, re.I)
+ if m:
+ return m.group()
+ if re.search(r'(?:^|\s)1st(?:$|\s)', value, re.I):
+ return 'first'
+ if re.search(r'(?:^|\s)2nd(?:$|\s)', value, re.I):
+ return 'second'
+ if re.search(r'(?:^|\s)3rd(?:$|\s)', value, re.I):
+ return 'third'
+ if re.search(r'(?:^|\s)\dth(?:$|\s)', value, re.I):
+ idx = int(re.search(r'(?:^|\s)(\d)th(?:$|\s)', value, re.I).group(1)) - 4
+ return ['fourth', 'fifth', 'sixth', 'seventh', 'eighth', 'ninth', 'tenth'][idx]
+ return None
+
+ @staticmethod
+ def parse_date(value):
+ value = month_fix(value)
+ month_map = {
+ 'january': 1,
+ 'february': 2,
+ 'march': 3,
+ 'april': 4,
+ 'may': 5,
+ 'june': 6,
+ 'july': 7,
+ 'august': 8,
+ 'september': 9,
+ 'october': 10,
+ 'november': 11,
+ 'december': 12
+ }
+ month_pattern = r'january|february|march|april|may|june|july|august|september|october|november|december'
+ m = re.search(rf"({month_pattern})(\d{{1,2}})'(\d{{2}})", value, re.I)
+ if m:
+ year = int(m.group(3))
+ month = month_map[m.group(1).lower()]
+ day = int(m.group(2))
+ return year, month, day
+
+ m = re.search(rf"\b(\d{{2}})\s*({month_pattern})\s*(\d{{4}})\b", value, re.I)
+ if m:
+ month = month_map[m.group(2).lower()]
+ day = int(m.group(1))
+ year = int(m.group(3))
+ return year, month, day
+
+ m = re.search(rf"\b(\d{{2}})\s*({month_pattern})\s*(\d{{2}})\b", value, re.I)
+ if m:
+ # guess
+ month = month_map[m.group(2).lower()]
+ day = int(m.group(1))
+ year = int(m.group(3))
+ return year, month, day
+
+ m = re.search(rf'({month_pattern})\s+(\d{{1,2}}),\s*(\d{{4}})\b', value, re.I)
+ if m:
+ month = month_map[m.group(1).lower()]
+ day = int(m.group(2))
+ year = int(m.group(3))
+ return year, month, day
+
+ m = re.search(r'\b(\d{1,4})[-/](\d{1,4})[-/](\d{1,4})\b', value, re.I)
+ if m:
+ # guess
+ if len(m.group(1)) == 4 and int(m.group(2)) <= 12:
+ result_tuple = (int(m.group(1)), int(m.group(2)), int(m.group(3)))
+ elif len(m.group(1)) == 1 and int(m.group(2)) > 12:
+ result_tuple = (int(m.group(3)), int(m.group(1)), int(m.group(2)))
+ elif len(m.group(1)) == 1:
+ result_tuple = (int(m.group(3)), int(m.group(2)), int(m.group(1)))
+ else:
+ result_tuple = (int(m.group(1)), int(m.group(2)), int(m.group(3)))
+ return result_tuple
+
+ @classmethod
+ def number_in(cls, pred_text, gold_text):
+ """
+ Determines if the `gold_text` is mentioned within `pred_text`.
+ """
+ if len(gold_text) >= 3 or re.search(r'^\d+(?:, \d+){4,}$', pred_text):
+ if re.search(fr'(?:^| |\b){re.escape(gold_text)}\.?(?:\b(?![,.]\d)| |$)', pred_text, re.I):
+ return True
+ number_parts = re.findall(r'\b\d[\d,. ]*\b', pred_text)
+ number_parts = [pred_text] + number_parts
+ for one_part in number_parts:
+ pred_num = cls.parse_number(one_part)
+ gold_num = cls.parse_number(gold_text)
+ if pred_num.status and gold_num.status:
+ return pred_num.parsed_value == gold_num.parsed_value
+ return False
+
+ @staticmethod
+ def extract_from_equation(pred_text, gold_text, raw_question, is_evidence):
+ equation_m = re.search(
+ (
+ r'-?[$]?\d[\d,.]*(?:%| million)?(?:(?:\s*[+\-*/]\s*-?[$]?\d[\d,.]*(?:%| million)?)'
+ r'+\s*=\s*(-?[$]?\d[\d,.]*(?:%| million)?))+'
+ ),
+ pred_text,
+ )
+ if equation_m:
+ return equation_m.group(1).strip('.')
+ return None
+
+ @staticmethod
+ def extract_number_from_by(pred_text, gold_text, raw_question, is_evidence):
+ if re.search('(?:by how (?:much|many))|(?:how much .+ change by)', raw_question, re.I):
+ targets = [t for t in re.split(r'\bby\b', pred_text, re.I)[1:] if re.search(r'\d', t)]
+ if targets:
+ return targets[-1].strip('.')
+ return None
+
+ @classmethod
+ def extract_from_predicate(cls, pred_text, gold_text, raw_question, is_evidence):
+ predicates = re.findall(r'\b(?:is|be|was|are)\b', pred_text)
+ if len(predicates) <= 1:
+ targets = [t for t in re.split(r'\b(?:is|be|was|are)\b', pred_text)[1:] if re.search(r'\d', t)]
+ if targets:
+ return targets[-1] # cls.parse_number can be used safely later
+ else:
+ # return gold text if it is in
+ targets = [t for t in re.split(r'\b(?:is|be|was|are)\b', pred_text)[1:] if re.search(r'\d', t)]
+ for one_target in targets:
+ if cls.number_in(one_target, gold_text):
+ return gold_text
+
+ # return the part where the prediction number is likely in
+ indicator_m = re.search(r'\b(?:therefore|which(?= (?:is|would be|was|are)))\b', pred_text, re.I)
+ if indicator_m:
+ interested_pred_text = pred_text[indicator_m.end():]
+ predicates = re.findall(r'\b(?:is|be|was|are)\b', interested_pred_text)
+ if len(predicates) <= 1:
+ interested_pred_text = re.split(r'\b(?:is|be|was|are)\b', interested_pred_text)[-1]
+ if re.search(r'\d', interested_pred_text):
+ return interested_pred_text # parse_number can be used safely
+ # remove noises
+ pred_text = re.sub(r'bounding box[^.]*?is', '', pred_text, re.I)
+ # split into candidates
+ targets = re.split(r'\b(?:is|be|was|are)\b', pred_text)
+ targets = [t for t in targets if re.search(r'^\D{,20}[$()]*\d[\d,. ]*[$()]*', t)]
+ if len(targets):
+ return targets[-1]
+ return None
+
+ @staticmethod
+ def extract_from_date_value_pair(pred_text, gold_text, raw_question, is_evidence):
+ m = re.search(r'(\d{4}:) (\$)?\d', pred_text)
+ if m:
+ return pred_text[m.end(1):]
+
+ if is_evidence and re.search(r'\byears?\b', raw_question, re.I):
+ m = re.search(r'\d{4}\s+(\d[\d ,.]*)', pred_text)
+ if m:
+ return m.group(1)
+ m = re.search(r'^\d{4} [a-z ]+: ?(\$?\d+)$', pred_text)
+ if m:
+ return m.group(1)
+
+ return None
+
+ @staticmethod
+ def extract_from_year(pred_text, gold_text, raw_question, is_evidence):
+ if 'which year' in raw_question and not is_evidence:
+ number_parts = re.findall(r'\b\d{4}\b', pred_text)
+ if len(number_parts) == 1:
+ return number_parts[0]
+
+ return None
+
+ @staticmethod
+ def extract_from_synonym(pred_text, gold_text, raw_question, is_evidence):
+ if re.search(r'what was the change', raw_question, re.I) and gold_text == '0':
+ if re.search(r'no change', pred_text, re.I):
+ return gold_text
+ elif re.search(r'^\d+ million$', gold_text, re.I) and re.search(r'^\d+,000,000$', pred_text, re.I):
+ gold_num = int(re.search(r'^(\d+) million$', gold_text, re.I).group(1)) * 1000000
+ pred_num = int(pred_text.replace(',', ''))
+ if gold_num == pred_num:
+ return gold_text
+
+ return None
+
+ @classmethod
+ def extract_number_part(cls, pred_text, gold_text, raw_question='', is_evidence=False):
+ pred_text = digit_fix(pred_text)
+ trials = [
+ cls.extract_from_synonym,
+ cls.extract_number_from_by,
+ cls.extract_from_equation,
+ cls.extract_from_predicate,
+ cls.extract_from_date_value_pair,
+ cls.extract_from_year,
+ ]
+ for extract_fn in trials:
+ pred_number = extract_fn(pred_text, gold_text, raw_question, is_evidence)
+ if pred_number is not None:
+ return pred_number
+
+ number_parts = re.findall(r'\d[\d,. ]*', pred_text)
+ if len(pred_text) and len(number_parts) != 1:
+ if 'tax amount' in raw_question:
+ valid_number_parts = [
+ np for np in pred_text.split() if re.search(r'\d', np) and not re.search(r'[a-zA-Z%]', np)
+ ]
+ if len(valid_number_parts) == 1:
+ return valid_number_parts[0]
+ # if multiple numbers, choose the one with overlap
+ if is_evidence:
+ if cls.number_in(pred_text, gold_text):
+ return gold_text
+
+ logger.debug(f'Fail to extract number from {repr(pred_text)}. Returning ori value')
+ elif len(number_parts) == 1:
+ # pred: 1,422,313 1,437,708 304,413 3,164,434
+ # gold: 3,164,434
+ if len(number_parts[0]) > len(gold_text):
+ if cls.number_in(pred_text, gold_text):
+ return gold_text
+ return pred_text
+
+ @staticmethod
+ def is_gold_number(gold_text):
+ m = re.search(
+ (
+ r'^(-|rp|\$|£|€|eur)?[()\d,. %]+(pts|million|billion|bil\.|bn|articles?|ps|earth years|years?'
+ r'|months?|weeks?|days?|earth days?|cm|mm|m|km|deaths?|experts?|'
+ r'seconds?|minutes?|hours?|hrs|hours ahead|events?|bps|kg|g|gallons?'
+ r'|percent|inches|votes?|k|b\.c\.?|a\.c\.?)?$'
+ ),
+ gold_text,
+ re.I,
+ )
+ return m is not None
+
+ @staticmethod
+ def is_gold_yes(gold_text):
+ return re.search(r'^yes\b', gold_text, re.I) is not None
+
+ @staticmethod
+ def is_pred_yes(pred_text):
+ with_yes = re.search(r'^yes\b', pred_text, re.I) is not None
+ without_no = re.search(r'^no\b|\bnot\b', pred_text, re.I) is None
+ no_not = len(pred_text) > 0 and without_no
+ return no_not or with_yes
+
+ @staticmethod
+ def is_no_absolutely(gold_text):
+ return gold_text.lower() == 'no'
+
+ @staticmethod
+ def is_no_guessing(pred_text):
+ return re.search(r'^no\b|\bnot\b', pred_text, re.I) is not None
+
+ @staticmethod
+ def to_string(pred_text):
+ if pred_text is None:
+ return ''
+ return str(pred_text)
+
+ @classmethod
+ def is_same_judgement(cls, pred_text, gold_text):
+ if cls.is_gold_yes(gold_text) and cls.is_pred_yes(pred_text):
+ return True
+ elif cls.is_no_absolutely(gold_text) and cls.is_no_guessing(pred_text):
+ return True
+ elif cls.is_no_absolutely(pred_text) and cls.is_no_guessing(gold_text):
+ return True
+
+ return False
+
+ @classmethod
+ def is_same_ordinal_number(cls, pred_text, gold_text, raw_question):
+ if re.search('which (?:one|amendment)', raw_question, re.I):
+ pred_ordinal_number = cls.parse_ordinal_number(pred_text)
+ gold_ordinal_number = cls.parse_ordinal_number(gold_text)
+ if pred_ordinal_number is not None and gold_ordinal_number is not None:
+ return pred_ordinal_number == gold_ordinal_number
+ return False
+
+ @classmethod
+ def is_same_comparative_adjective(cls, pred_text, gold_text, raw_question):
+ if re.search('more or less|greater than or less than', raw_question, re.I):
+ pos_pred_adj = re.search(r'\b(?:more|greater)\b', pred_text, re.I)
+ neg_pred_adj = re.search(r'\b(?:less|lower)\b', pred_text, re.I)
+ pos_gold_adj = re.search(r'\b(?:more|greater)\b', gold_text, re.I)
+ neg_gold_adj = re.search(r'\b(?:less|lower)\b', gold_text, re.I)
+ if pos_pred_adj is not None and pos_gold_adj is not None:
+ return True
+ elif neg_pred_adj is not None and neg_gold_adj is not None:
+ return True
+
+ return False
+
+ @classmethod
+ def is_same_date(cls, pred_text, gold_text, raw_question):
+ date_question = re.search('"(?:date_value|date)"', raw_question, re.I)
+ if date_question is not None:
+
+ # check if string sub-match
+ pattern = r'date ?|mon ?|tue ?|wed ?|thu ?|fri ?|sat ?|sun ?'
+ cleaned_gold_text = re.sub(pattern, '', gold_text, flags=re.I).replace(' ', '').lower()
+ cleaned_pred_text = re.sub(pattern, '', pred_text, flags=re.I).replace(' ', '').lower()
+ if cleaned_gold_text in cleaned_pred_text:
+ return True
+
+ # check if parsed match
+ gold_tuple = cls.parse_date(gold_text)
+ pred_tuple = cls.parse_date(pred_text)
+ if gold_tuple is not None and pred_tuple is not None:
+ if gold_tuple[1:] == pred_tuple[1:] and abs(gold_tuple[0] - pred_tuple[0]) in [0, 2000]:
+ return True
+ elif gold_tuple == pred_tuple[::-1]:
+ return True
+
+ return False
+
+ @staticmethod
+ def is_same_trend(pred_text, gold_text, raw_question, task_name, sub_task_name):
+ if sub_task_name == 'CharXiv' and task_name == 'Logical Reasoning':
+ if re.search(r'\b(?:relationship|vary with|change as)\b', raw_question, re.I):
+ if re.search('^increase', gold_text, re.I):
+ straight_answer_pattern = r'(?:^increase)'
+ # as xxx increases, the xxx increases.
+ front_pattern = r'(?:as .+(?:increase|decrease).+increase[s.]*$)'
+ # the xxx increase, as xxx increases.
+ back_pattern = r'(?:increase.+as .+(?:increase|decrease))'
+ pattern = f'{straight_answer_pattern}|{front_pattern}|{back_pattern}'
+ if re.search(pattern, pred_text, re.I):
+ return True
+ elif re.search(r'^decrease', gold_text, re.I):
+ straight_answer_pattern = r'(?:^decrease)'
+ # as xxx increases, the xxx increases.
+ front_pattern = r'(?:as .+(?:increase|decrease).+decrease[s.]*$)'
+ # the xxx increase, as xxx increases.
+ back_pattern = r'(?:decrease.+as .+(?:increase|decrease))'
+ pattern = f'{straight_answer_pattern}|{front_pattern}|{back_pattern}'
+ if re.search(pattern, pred_text, re.I):
+ return True
+ elif re.search('^inverse', gold_text, re.I):
+ inverse_word_pattern = r'(?:\b(?:inversely|while|inverse)\b)'
+ inverse_sentence_pattern = r'(?:.+decrease.+as .+increase)|(?:.+increase.+as .+decrease)'
+ pattern = f'{inverse_word_pattern}|{inverse_sentence_pattern}'
+ if re.search(pattern, pred_text, re.I):
+ return True
+ elif re.search(r'change as .+higher', raw_question, re.I):
+ if re.search('^higher', gold_text, re.I):
+ front_pattern = r'(?:(?:higher|sharper|increase).+as .+(?:higher|increase))'
+ back_pattern = r'(?:as .+(?:higher|increase).+(?:higher|sharper|increase))'
+ pattern = f'{front_pattern}|{back_pattern}'
+ if re.search(pattern, pred_text, re.I):
+ return True
+ return False
+
+ @staticmethod
+ def string_in(pred_text, gold_text, raw_question, sub_task_name):
+ # in most cases, we check gold if is included in prediction, as prediction tends to be longer
+ if re.search(fr'(?:^| |\b){re.escape(gold_text)}\.?(?:\b| |$)', pred_text, re.I):
+ # different from kie's narrative string,
+ # we just check if gold is in prediction without length limit as prediction can be very long sometimes
+
+ # fix false inclusion
+ if sub_task_name == 'DUDE' and re.search(fr'\b{re.escape(gold_text)} or ', raw_question, re.I):
+ if re.search(r'\bboth\b', pred_text, re.I):
+ return False
+ return True
+
+ # in some cases, we check if prediction in included in gold, as predictions from lazy models tends to be shorter
+ selection_question = re.search(r'\b(?:which|where)\b', raw_question, re.I)
+ shorter_prediction = len(pred_text) < len(gold_text)
+ not_too_long_gold = gold_text.count(' ') <= 3
+ if selection_question and shorter_prediction and not_too_long_gold:
+ if re.search(fr'(?:^| |\b){re.escape(pred_text)}\.?(?:\b| |$)', gold_text, re.I):
+ return True
+
+ return False
+
+ @staticmethod
+ def remove_repetitions(s):
+ # meaningless point listing
+ points = [int(point) for point in re.findall(r'\b(\d+)\. (?=[a-z])', s, re.I)]
+ if points and len(points) > 10 and points == list(range(points[0], points[-1] + 1)):
+ logger.debug(f'[Repetition] remove invalid prediction completely: {repr(s[:100] + "...")}')
+ return ''
+
+ # general repetition removal
+ r = re.compile(r'(.+?)\1+')
+ detections = []
+ for match in r.finditer(s):
+ if match.end() - match.end(1) > 30:
+ if match.group(1) == '.':
+ # remove the '.' for correct number parsing later
+ if re.search(r'[a-z]$', s[:match.start()], re.I) and re.search(r'^ ?\d', s[match.end():], re.I):
+ detections.append((match.group(1), match.end(1) - 1, match.end()))
+ else:
+ detections.append((match.group(1), match.end(1), match.end()))
+ for r in detections:
+ logger.debug(f'[Repetition] remove {r[0]} from string')
+ s = s[:r[1]] + s[r[2]:]
+
+ return s
+
+ @staticmethod
+ def preprocess_for_amounts_in_special_format(text):
+ text_parts = text.split(',')
+ text_parts[0] = text_parts[0].replace('.', ',')
+ text = '.'.join(text_parts)
+ return text
+
+ @classmethod
+ def rule_parse_numeric_value(
+ cls, pred_text, gold_text, raw_question='', task_name='', sub_task_name='', is_evidence=False
+ ):
+ """
+ Extract and parse numbers from string text. Carefully handle the following cases:
+ + amounts where '.' and ',' are used reversely
+ + missing or redundant percentage errors
+ + extra 0 error
+ + calculation error
+ + sign error
+ + unit error
+ + etc
+ """
+ # cases checking
+ possible_negative = 'decrease' in pred_text
+ possible_thousands = ('$' in pred_text or re.search(r',\d00|[1-9]000$', pred_text) is not None) and re.search(
+ r'\bstars\b', raw_question, re.I
+ ) is None
+
+ interested_pred_text = cls.extract_number_part(pred_text, gold_text, raw_question, is_evidence)
+
+ # handles amounts where '.' and ',' are used reversely for CORD dataset
+ if sub_task_name == 'CORD':
+ if re.search(r'^\D*\d{1,3}(?:\.\d{3})*(?:,\d{2})?\D*$', interested_pred_text):
+ interested_pred_text = cls.preprocess_for_amounts_in_special_format(interested_pred_text)
+ if re.search(r'^\D*\d{1,3}(?:\.\d{3})*(?:,\d{2})?\D*$', gold_text):
+ gold_text = cls.preprocess_for_amounts_in_special_format(gold_text)
+
+ pred_num = cls.parse_number(interested_pred_text)
+ gold_num = cls.parse_number(gold_text)
+
+ # handles percentage errors
+ question_for_percentage = re.search(r'[a-z ](?:%|\(%\))[a-z ]|\b(?:percentage|percent)\b', raw_question, re.I)
+ percent_sign_diff = (
+ gold_text == interested_pred_text.replace('%', '')
+ or f'{gold_text}%' in interested_pred_text
+ or interested_pred_text == gold_text.replace('%', '')
+ or f'{interested_pred_text}%' in gold_text
+ )
+ check_percentage = question_for_percentage or percent_sign_diff
+ if pred_num.from_percentage and not gold_num.from_percentage and check_percentage:
+ pred_num.restore_to_value_before_percentage()
+ elif gold_num.from_percentage and not pred_num.from_percentage and check_percentage:
+ if gold_num.maybe_percentage_error(pred_num):
+ gold_num.restore_to_value_before_percentage()
+
+ pred_text = pred_num.parsed_value
+ gold_text = gold_num.parsed_value
+
+ if '.' not in gold_text and re.search(r'\.0+$', pred_text):
+ # extra 00 error
+ pred_text = pred_num.get_int_str()
+ elif pred_num.status and pred_num.decimal_num != gold_num.decimal_num:
+ # extra decimal error and calculation error
+ if task_name == 'Key Information Extraction':
+ # decimal error in extraction is not acceptable
+ round_num = max(pred_num.decimal_num, gold_num.decimal_num)
+ else:
+ # slight decimal error in calculation is acceptable
+ min_decimal_num = min(pred_num.decimal_num, gold_num.decimal_num)
+ not_all_percentage = pred_num.from_percentage != gold_num.from_percentage
+ slight_error = gold_num.maybe_rounding_error(pred_num)
+ if slight_error or not_all_percentage:
+ round_num = min_decimal_num
+ else:
+ round_num = max(pred_num.decimal_num, gold_num.decimal_num)
+
+ pred_text = pred_num.get_rounded_str(round_num)
+ gold_text = gold_num.get_rounded_str(round_num)
+
+ # ignore sign error in decrease setting
+ if gold_text.startswith('-') and gold_text[1:] == pred_text and possible_negative:
+ pred_text = f'-{pred_text}'
+ # ignore sign error in subtraction questions
+ elif (
+ not is_evidence
+ and 'difference' in raw_question
+ and 'absolute' not in raw_question
+ and gold_num.maybe_sign_error(pred_num)
+ ):
+ pred_text = gold_text
+
+ # ignore thousands error
+ elif possible_thousands and gold_num.maybe_thousands_error(pred_num):
+ pred_text = gold_text
+ return pred_text, gold_text
+
+ @classmethod
+ def rule_parse_extraction_value(
+ cls, pred_text, gold_text, raw_question='', task_name='', sub_task_name='', is_evidence=False
+ ):
+ time_question = re.search('"(?:time_value)"', raw_question, re.I)
+ phone_question = re.search('tel_value', raw_question, re.I)
+ if gold_text.lower() in pred_text.lower() and len(pred_text) <= 2 * len(gold_text):
+ # e.g., item name with irrelevant quantity
+ # add restrictions to avoid false positive
+ pred_text = gold_text
+ elif re.sub(r"[ ']", '', gold_text).lower() == re.sub(r"[ ']", '', pred_text).lower():
+ # extra ' and spaces
+ pred_text = gold_text
+ elif phone_question and re.sub(r'\D', '', pred_text) == re.sub(r'\D', '', gold_text):
+ # 614-766-4494 is the same as (614) 766-4494
+ pred_text = gold_text
+ elif time_question:
+ # remove noisy word and do not care the length restrictions
+ pattern = r'time[: ]*'
+ cleaned_gold_text = re.sub(
+ r':(?=pm)', ' ', re.sub(pattern, '', gold_text, flags=re.I), flags=re.I
+ ).replace(' ', '').lower()
+ cleaned_pred_text = re.sub(
+ r':(?=pm)', ' ', re.sub(pattern, '', pred_text, flags=re.I), flags=re.I
+ ).replace(' ', '').lower()
+ if cleaned_gold_text in cleaned_pred_text:
+ pred_text = gold_text
+ elif cls.is_same_date(pred_text, gold_text, raw_question):
+ pred_text = gold_text
+
+ return pred_text, gold_text
+
+ @classmethod
+ def rule_parse_narrative_value(
+ cls, pred_text, gold_text, raw_question='', task_name='', sub_task_name='', is_evidence=False
+ ):
+ pred_text = normalize_narrative_text(pred_text, raw_question, sub_task_name)
+ gold_text = normalize_narrative_text(gold_text, raw_question, sub_task_name)
+ if cls.is_same_ordinal_number(pred_text, gold_text, raw_question):
+ pred_text = gold_text
+ elif cls.is_same_comparative_adjective(pred_text, gold_text, raw_question):
+ pred_text = gold_text
+ elif cls.is_same_trend(pred_text, gold_text, raw_question, task_name, sub_task_name):
+ pred_text = gold_text
+ elif cls.string_in(pred_text, gold_text, raw_question, sub_task_name):
+ pred_text = gold_text
+ elif gold_text.replace(' ', '').lower() == pred_text.replace(' ', '').lower():
+ # space errors
+ pred_text = gold_text
+ elif gold_text.count(' ') >= 3 or (' ' in gold_text and len([i for i in gold_text if i.isalpha()]) >= 15):
+ # long answer with disturbing context information
+ # tolerant on spelling errors
+
+ # the original prediction
+ candidates = [pred_text]
+
+ # add another candidate((seperated by dot or 'including', 'is' keywords))
+ seps = ['. ', ', including', 'is']
+ for seperator in seps:
+ prediction_parts = pred_text.split(seperator)
+ if len(prediction_parts) > 1:
+ candidates.append(prediction_parts[0])
+
+ # check if any
+ for pred_candidate in candidates:
+ if anls_compute(gold_text, pred_candidate) < 0.5:
+ pred_text = gold_text
+ break
+
+ return pred_text, gold_text
+
+ @classmethod
+ def rule_parse(cls, pred_text, gold_text, raw_question='', task_name='', sub_task_name='', is_evidence=False):
+ """
+ Check if pred_text expresses the same meaning as gold_text. If so, update pred_text to gold_text.
+
+ 1. number comparison
+ 1.1 float/int only
+ 1.2 percentage
+ 1.3 number + units
+ 1.4 currency + number
+ 2. yes or no
+ 3. long answer with disturbing context information
+ """
+ if cls.is_gold_number(gold_text):
+ pred_text, gold_text = cls.rule_parse_numeric_value(
+ pred_text=pred_text,
+ gold_text=gold_text,
+ raw_question=raw_question,
+ task_name=task_name,
+ sub_task_name=sub_task_name,
+ is_evidence=is_evidence
+ )
+ elif cls.is_same_judgement(pred_text, gold_text):
+ pred_text = gold_text
+ elif is_narrative_kie(task_name, raw_question):
+ pred_text, gold_text = cls.rule_parse_extraction_value(
+ pred_text=pred_text,
+ gold_text=gold_text,
+ raw_question=raw_question,
+ task_name=task_name,
+ sub_task_name=sub_task_name,
+ is_evidence=is_evidence
+ )
+ elif 'Question Answering' in task_name or (is_reasoning_task(task_name)):
+ pred_text, gold_text = cls.rule_parse_narrative_value(
+ pred_text=pred_text,
+ gold_text=gold_text,
+ raw_question=raw_question,
+ task_name=task_name,
+ sub_task_name=sub_task_name,
+ is_evidence=is_evidence
+ )
+
+ return pred_text, gold_text
+
+ @classmethod
+ def parse(cls, pred_text, gold_text, raw_question='', task_name='', sub_task_name='', is_evidence=False):
+ pred_text = cls.to_string(pred_text)
+ gold_text = cls.to_string(gold_text)
+
+ pred_text = cls.remove_repetitions(pred_text)
+
+ skip_parse = re.search(r'Recognition|Localization|Forgery', task_name) is not None
+ keep_newline = 'Recognition' in task_name
+ skip_normalize = False
+ if not skip_parse and pred_text is not None and gold_text is not None:
+ if cls.is_gold_number(gold_text):
+ skip_normalize = True
+
+ if pred_text != gold_text:
+ pred_text, gold_text = cls.rule_parse(
+ pred_text=pred_text,
+ gold_text=gold_text,
+ raw_question=raw_question,
+ task_name=task_name,
+ sub_task_name=sub_task_name,
+ is_evidence=is_evidence
+ )
+ if pred_text is not None and not skip_normalize:
+ pred_text = normalize_text(pred_text, keep_newline=keep_newline)
+ if gold_text is not None and not skip_normalize:
+ gold_text = normalize_text(gold_text, keep_newline=keep_newline)
+ return pred_text, gold_text
+
+
+class BboxParser:
+ @classmethod
+ def parse(cls, bbox, model_name=''):
+ if bbox and isinstance(bbox, list):
+ if len(bbox) == 4 and (isinstance(bbox[0], int) or isinstance(bbox[0], float)):
+ if all(co < 2 for co in bbox):
+ x0 = math.floor(bbox[0] * 1000)
+ y0 = math.floor(bbox[1] * 1000)
+ x1 = math.ceil(bbox[2] * 1000)
+ y1 = math.ceil(bbox[3] * 1000)
+ return [x0, y0, x1, y1]
+ return bbox
+ elif isinstance(bbox[0], dict) and bbox[0].get('bbox'):
+ return cls.parse(bbox[0]['bbox'])
+ elif isinstance(bbox[0], list):
+ return cls.parse(bbox[0])
+ elif (
+ isinstance(bbox[0], dict)
+ and bbox[0].keys() == {'x0', 'y0'}
+ and isinstance(bbox[1], dict)
+ and bbox[1].keys() == {'x1', 'y1'}
+ ):
+ return list(bbox[0].values()) + list(bbox[1].values())
+ logger.debug(f'Fail to parse bbox: {bbox}. Return empty')
+ return []
diff --git a/vlmeval/dataset/utils/mmdocbench_eval.py b/vlmeval/dataset/utils/mmdocbench_eval.py
new file mode 100644
index 0000000000000000000000000000000000000000..2299a5345040dead7a5b33b4901facef372cb09d
--- /dev/null
+++ b/vlmeval/dataset/utils/mmdocbench_eval.py
@@ -0,0 +1,215 @@
+import argparse
+import itertools
+import json
+import os
+import re
+from functools import partial
+from pathlib import Path
+import numpy as np
+import torch
+from qwen_vl_utils import process_vision_info
+from torchvision.ops.boxes import box_area
+from tqdm import tqdm
+from transformers import AutoProcessor, Qwen2VLForConditionalGeneration
+import cv2
+import pandas as pd
+import random
+# from utils import seed_everything, get_model_id, update_res
+import datetime
+from num2words import num2words
+import ast
+import warnings
+import csv
+
+CAPABILITY_NAME = 'category'
+def update_data_format(df_data):
+ df_data = df_data.rename(columns={'capability': CAPABILITY_NAME})
+ if 'dataset_name' in df_data.columns:
+ df_data['sub_task'] = df_data['dataset_name']
+ df_data.drop(columns=['dataset_name'], inplace=True)
+ df_data.loc[df_data['sub_task'] == 'OCR-VQA', 'sub_task'] = 'BookOCR'
+ df_data.loc[df_data[CAPABILITY_NAME] != 'Visual Reasoning', CAPABILITY_NAME] = 'Visual Perception'
+ df_data['reasoning_type'] = df_data['reasoning_type'].fillna('')
+ df_data.loc[df_data['reasoning_type'] == 'algebraic', 'reasoning_type'] = 'arithmetic'
+ df_data.loc[df_data['task'] == 'Text Localization Bbox2Text', 'sub_task'] = 'Bbox2Text'
+ df_data.loc[df_data['task'] == 'Text Localization Text2Bbox', 'sub_task'] = 'Text2Bbox'
+ df_data.loc[df_data['task'] == 'Text Localization Bbox2Text', 'task'] = 'Text Localization'
+ df_data.loc[df_data['task'] == 'Text Localization Text2Bbox', 'task'] = 'Text Localization'
+
+ df_perception = df_data[df_data[CAPABILITY_NAME] == 'Visual Perception']
+ df_reasoning = df_data[df_data[CAPABILITY_NAME] == 'Visual Reasoning'].copy()
+ df_reasoning['task'] = df_reasoning['reasoning_type'].str.title()
+ df_reasoning['task'] = df_reasoning['task'].apply(
+ lambda x: x + ' Reasoning' if x in ['Arithmetic', 'Logical', 'Spatial'] else x
+ )
+ df_reasoning = df_reasoning.drop(columns=['reasoning_type']) # mute SettingWithCopyWarning warnings
+ return pd.concat([df_perception, df_reasoning], ignore_index=True)
+ return df_data
+
+answer_pattern = re.compile(r'(.*?) ')
+markdown_json_pattern = re.compile(r'```json(.*?)```', re.DOTALL)
+def process_answer(answer):
+ answer = answer.split('### Final Answer ###')[-1].strip() if '### Final Answer ###' in answer else answer
+ answer = answer.split('Answer:')[-1].strip() if 'Answer:' in answer else answer
+ matches = re.findall(answer_pattern, answer)
+ answer = matches[-1] if matches else answer
+ matches = re.findall(markdown_json_pattern, answer)
+ answer = matches[-1] if matches else answer
+ try:
+ answer_json = json.loads(answer)
+ answer = answer_json["answer"]
+ except:
+ pass
+ return str(answer)
+
+class NoMatchedEquationError(Exception):
+ pass
+
+
+def calculate(expression):
+ try:
+ exp = expression.split('=')[0].strip()
+ node = ast.parse(exp, mode='eval')
+ result = eval(compile(node, '', 'eval'))
+ return result
+ except:
+ return None
+
+def extract_and_judge(expression, target_result):
+ expression = expression.replace(" ", "").replace("$", "")
+ result = calculate(expression)
+ if result is None:
+ raise NoMatchedEquationError(f"none error")
+ else:
+ return target_result.strip() in str(result).strip()
+
+def check_relation(gt, ans, strict=False):
+ # # cot: 200 direct: 25
+ if strict:
+ delta_len = 25
+ else:
+ delta_len = 200
+ if abs(len(str(ans)) - len(str(gt))) > 200:
+ return False
+
+ gt = str(gt).strip()
+ ans = str(ans).strip()
+
+ if gt.lower() == ans.lower():
+ return True
+
+ ## rule 1: if string has million, then parse number
+ # if "million" in ans or "increase" in ans or "decrease" in ans:
+ # a = re.findall(r'\d+', gt)
+ # for i in a:
+ # if str(i) in ans:
+ # return True
+
+ ## rule 2: string exact match
+ try:
+ aa = int(gt.replace(",", "").replace("$", "").replace("*", "").replace("**", "").replace("@", "").replace("-","").replace(" ", "").replace("%", ""))
+ # print(aa)
+ words_list = ans.split(" ")
+ for i in words_list:
+ if int(aa) == int(i.replace(",", "").replace("$", "").replace("*", "").replace("**", "").replace("@", "").replace("-", "").replace(" ", "").replace("%", "").replace("million","").replace("increase","").replace("decrease","")):
+ if len(words_list)<5:
+ return True
+ except:
+ pass
+
+ try:
+ aa = float(gt.replace(",", "").replace("$", "").replace("*", "").replace("**", "").replace("@", "").replace("-","").replace(" ", "").replace("%", ""))
+ # print(aa)
+ words_list = ans.split(" ")
+ for i in words_list:
+ if round(aa,4) ==round(float(i.replace(",", "").replace("$", "").replace("*", "").replace("**", "").replace("@", "").replace("-", "").replace(" ", "").replace("%", "").replace("million","").replace("increase","").replace("decrease","")),4):
+ if len(words_list) < 3:
+ return True
+ except:
+ pass
+
+ ## rule 3: if string can be converted to number, then use number to test, avoid '1' and '12'
+ try:
+ a_f = float(ans.replace(",", "").replace("$", ""))
+ g_f = float(gt.replace(",", "").replace("$", ""))
+ if a_f == g_f:
+ return True
+ else:
+ return False
+ except:
+ pass
+ ## rule 4: if answer contains equation e.g. 141-111=30
+ try:
+ aa = extract_and_judge(ans, gt)
+ return aa
+ except:
+ pass
+
+ ## rule 5: string contains thousandths like 1,000 or percentage like 10%
+ try:
+ num_gt = float(gt.lstrip('$').replace(',', '').rstrip('%')) / 100 if "%" in gt else float(
+ gt.lstrip('$').replace(',', ''))
+ num_ans = float(ans.lstrip('$').replace(',', '').rstrip('%')) / 100 if "%" in ans else float(
+ ans.lstrip('$').replace(',', ''))
+ if num_gt == num_ans:
+ return True
+ else:
+ return False
+ except ValueError:
+ pass
+
+ ## rule 6: number to word e.g. eleven=>11
+ try:
+ num_gt = float(gt.lstrip('$').replace(',', '').rstrip('%')) / 100 if "%" in gt else float(
+ gt.lstrip('$').replace(',', ''))
+ if num2words(int(num_gt)).lower() == ans.lower():
+ return True
+ else:
+ return False
+ except ValueError:
+ pass
+
+ ## rule 7: string convert
+ aa = gt.lower() in ans.lower()
+ if aa:
+ try:
+ a = int(ans.lower().replace(gt.lower(), "").replace(" ", ""))
+ if a:
+ return False
+ else:
+ return True
+ except:
+ return True
+
+def eval_mmdocbench(ans, gt_obj, strict=False):
+ # 1.process ans
+ ans = process_answer(ans)
+ # 2.process ground truth
+ # if isinstance(gt_obj[0], str):
+ # gt_obj = json.loads(gt_obj[0])
+ # for gt_obj_ in gt_obj:
+ # gt_ls = []
+ # if isinstance(gt_obj_, list):
+ # for sub_gt_obj_ in gt_obj_:
+ # gt_ls.append(str(sub_gt_obj_['answer']))
+ # else:
+ # gt_ls.append(str(gt_obj_['answer']))
+ gt_ls = []
+ gt_obj_lst = json.loads(gt_obj)
+
+ if type(gt_obj_lst[0]) == list:
+ gt_obj_lst = gt_obj_lst[0]
+ for item in gt_obj_lst: # gt_obj_lst is list
+ gt_ls.append(item["answer"])
+
+ # 3.calculate em
+ cnt = 0
+ em = 0
+ for gt in gt_ls:
+ if gt != "":
+ cnt += 1
+ flag = check_relation(gt, ans, strict)
+ if flag:
+ em += 1
+ em /= cnt
+ return em
\ No newline at end of file
diff --git a/vlmeval/dataset/utils/mmdu.py b/vlmeval/dataset/utils/mmdu.py
new file mode 100644
index 0000000000000000000000000000000000000000..d432bdbb99f6dedec4691b4b1095410d41d82827
--- /dev/null
+++ b/vlmeval/dataset/utils/mmdu.py
@@ -0,0 +1,126 @@
+from ...smp import *
+
+meta_prompt = """
+You are an assistant skilled at evaluating the quality of creative text.
+Please act as an impartial judge and evaluate the quality of the response provided by an AI assistant to \
+the user question displayed below. You'll need to assess the response on the following dimensions: \
+Creativity, Richness, Visual Perception, Logical Coherence, Answer Accuracy and Image Relationship Understanding. \
+We will provide you with a creative question and the AI model's response and a reference answer for your evaluation. \
+As you begin your assessment, follow this process:
+1. Evaluate the AI model's answers on different dimensions, pointing out its strengths or weaknesses \
+in each dimension and assigning a score of 1 to 10 for each.
+2. Finally, based on the assessments across dimensions, \
+provide an overall score of 1 to 10 for the AI model's response.
+3. Your scoring should be as stringent as possible and follow the scoring rules below:
+In general, the higher the quality of the model's response and its strict adherence to user needs, \
+the higher the score. Responses that do not meet user needs will receive lower scores.
+Scoring rules:
+Creativity:
+Scores 1-2 when there is no innovation or uniqueness in the content.
+Scores 3-4 when providing partially original content but with low creative quality.
+Scores 5-6 when mostly creative but lacks significant novelty, with moderate quality.
+Scores 7-8 when having novelty and high-quality content.
+Scores 9-10 when highly novel and of exceptional quality compared to the reference answer.
+Richness:
+Scores 1-2 when lacking depth and breadth, with very limited information.
+Scores 3-4 when limited in depth and breadth, with fewer explanations and examples, showing low diversity.
+Scores 5-6 when limited in depth and breadth but provides basic necessary information.
+Scores 7-8 when providing depth and useful additional information.
+Scores 9-10 when providing exceptional depth, breadth, and high diversity compared to the reference answer.
+Visual Perception:
+Scores 1-2 when the description of the visual information in the image contains errors or \
+is significantly inconsistent with the content of the image.
+Scores 3-4 When the description of the visual information in the image reflects only a small amount \
+of the image's information and contains some errors.
+Scores 5-6 when the description of the visual information in the image includes the basic information \
+of the image but contains minimal information.
+Scores 7-8 when the description of the visual information in the image matches the image well and is rich in content, \
+providing a substantial amount of information about the image.
+Scores 9-10 when the description of the visual information in the image not only matches the image \
+but also is more detailed and informative compared to the reference answer, providing more information about the image.
+Logical Coherence:
+Scores 1-2 when entirely incoherent, lacking any logic, and not matching the question or known information.
+Scores 3-4 when somewhat coherent but with many logical errors or inconsistencies.
+Scores 5-6 when mostly coherent, with few errors, but may struggle to maintain complete coherence in complex situations.
+Scores 7-8 when excellent logical handling, very few errors.
+Scores 9-10 when flawless logic, impeccable in handling complexity, \
+and significantly higher logical coherence compared to the reference answer.
+Answer Accuracy:
+Scores 1-2 when the answer is significantly inconsistent with the question or contains obvious errors.
+Scores 3-4 when the answer is partially correct but contains some errors or is incomplete.
+Scores 5-6 when the answer is basically correct but lacks details or is not sufficiently detailed.
+Scores 7-8 when the answer is accurate and detailed, fully corresponding to the question.
+Scores 9-10 when the answer is not only accurate and detailed but also provides additional useful information, \
+exceeding expectations.
+Image Relationship Understanding:
+Scores 1-2 when there are significant errors or confusion in distinguishing and describing different images, \
+unable to correctly identify and relate the content of the images.
+Scores 3-4 when the description of different images reflects only minimal distinguishing information, \
+contains some errors and confusion, and fails to clearly differentiate and relate the images.
+Scores 5-6 when the description of different images includes basic distinguishing information, \
+is able to correctly identify and relate the images in a basic manner, \
+but the information provided is minimal and lacks detail.
+Scores 7-8 when the description of different images is accurate and detailed, \
+clearly distinguishing and relating the images, \
+with rich content that points out the main commonalities and differences between the images.
+Scores 9-10 when the description of different images is not only accurate and detailed but also \
+provides richer information and analysis, clearly distinguishing and relating the images, \
+more comprehensively pointing out the commonalities and differences \
+between the images compared to the reference answer.
+Overall Score:
+Scores 1-2 when irrelevant to the question, factually incorrect, or generates harmful content.
+Scores 3-4 when no serious errors, mostly harmless, but of low quality and does not meet requirements.
+Scores 5-6 when basically meeting requirements but performing poorly in some dimensions, with moderate quality.
+Scores 7-8 when performing well in all dimensions.
+Scores 9-10 when fully addressing user questions and all requirements, significantly surpassing the reference answer.
+Please remember, you must evaluate and explain before scoring. After your explanation for each dimension, \
+add the score for that dimension. Finally, at the end of your response, \
+in the format of the dictionary (including brackets), return all your scoring results, \
+ensuring your scores are integers:
+{'Dimension One': Score, 'Dimension Two': Score, ..., 'Overall Score': Score}, \
+for example: {'Creativity': 9, 'Richness': 6, ..., 'Overall Score': 7}.\n
+"""
+question_begin_prompt = '[Question]'
+reference_begin_prompt = '[The Start of Reference Answer]'
+reference_end_prompt = '[The End of Reference Answer]'
+answers_begin_prompt = '[The Start of Assistant’s Answer]'
+answers_end_prompt = '[The End of Assistant’s Answer]'
+
+
+def mmdu_score(model, line):
+ question = eval(line['question'])
+ gt = eval(line['answer'])
+ prediction = eval(line['prediction'])
+
+ DIMS = [
+ 'Creativity', 'Richness', 'Visual Perception', 'Logical Coherence',
+ 'Answer Accuracy', 'Image Relationship Understanding', 'Overall Score'
+ ]
+
+ all_result_dict = []
+ logs = []
+ for j in range(len(question)):
+ try:
+ prompt = meta_prompt + question_begin_prompt + '\n' + question[j] + '\n\n' + \
+ reference_begin_prompt + '\n' + gt[j] + '\n' + reference_end_prompt + '\n\n' + \
+ answers_begin_prompt + '\n' + prediction[j] + '\n' + answers_end_prompt
+ response = model.generate(prompt)
+ start_index = response.find('{')
+ end_index = response.rfind('}') + 1
+ dictionary_str = response[start_index: end_index]
+ result_dict = eval(dictionary_str)
+ all_result_dict.append(result_dict)
+ if all([x in result_dict for x in DIMS]):
+ logs.append('Succeed')
+ else:
+ logs.append(
+ f'Following Dims are not in results of turn {j}: '
+ f'{",".join([x for x in DIMS if x not in result_dict])}'
+ )
+ except Exception as e:
+ logging.warning(str(e))
+ all_result_dict.append({d: None for d in DIMS})
+ logs.append(str(e))
+
+ df = pd.DataFrame(all_result_dict)
+ return dict(res=df, log='\n'.join(logs))
diff --git a/vlmeval/dataset/utils/mmniah.py b/vlmeval/dataset/utils/mmniah.py
new file mode 100644
index 0000000000000000000000000000000000000000..34604ad8dd89a7ba6fd057961b312d8d82f5c774
--- /dev/null
+++ b/vlmeval/dataset/utils/mmniah.py
@@ -0,0 +1,298 @@
+import re
+import json
+
+
+def has_word(sentence, word):
+ pattern = r'\b' + re.escape(word) + r'\b'
+ match = re.search(pattern, sentence)
+ if match:
+ return True
+ else:
+ return False
+
+
+class VQAEval:
+ def __init__(self):
+ self.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",
+ }
+ self.manualMap = {
+ 'zero': 0, 'one': 1, 'two': 2, 'three': 3, 'four': 4,
+ 'five': 5, 'six': 6, 'seven': 7, 'eight': 8, 'nine': 9,
+ 'ten': 10, 'eleven': 11, 'twelve': 12, 'thirteen': 13,
+ 'fourteen': 14, 'fifteen': 15, 'sixteen': 16,
+ 'seventeen': 17, 'eighteen': 18, 'nineteen': 19,
+ 'twenty': 20, 'thirty': 30, 'forty': 40, 'fifty': 50,
+ 'sixty': 60, 'seventy': 70, 'eighty': 80, 'ninety': 90}
+ self.articles = ['a', 'an', 'the']
+
+ self.periodStrip = re.compile('(?!<=\\d)(\\.)(?!\\d)')
+ self.commaStrip = re.compile('(\\d)(\\,)(\\d)')
+ self.punct = [
+ ';',
+ r'/',
+ '[',
+ ']',
+ '"',
+ '{',
+ '}',
+ '(',
+ ')',
+ '=',
+ '+',
+ '\\',
+ '_',
+ '-',
+ '>',
+ '<',
+ '@',
+ '`',
+ ',',
+ '?',
+ '!',
+ ]
+
+ def evaluate(self, answer, gt_answers):
+ answer = answer.replace('\n', ' ')
+ answer = answer.replace('\t', ' ')
+ answer = answer.strip()
+ answer = self.processPunctuation(answer)
+ answer = self.processDigitArticle(answer)
+ if isinstance(gt_answers, list):
+ for i in range(len(gt_answers)):
+ gt_answers[i] = str(gt_answers[i])
+ gt_answers[i] = gt_answers[i].replace('\n', ' ')
+ gt_answers[i] = gt_answers[i].replace('\t', ' ')
+ gt_answers[i] = gt_answers[i].strip()
+ gt_answers[i] = self.processPunctuation(gt_answers[i])
+ gt_answers[i] = self.processDigitArticle(gt_answers[i])
+ if has_word(answer, gt_answers[i]):
+ return 1
+ return 0
+ else:
+ gt_answers = gt_answers.replace('\n', ' ')
+ gt_answers = gt_answers.replace('\t', ' ')
+ gt_answers = gt_answers.strip()
+ gt_answers = self.processPunctuation(gt_answers)
+ gt_answers = self.processDigitArticle(gt_answers)
+ if has_word(answer, gt_answers):
+ return 1
+ else:
+ return 0
+
+ def evaluate_MRR(self, answer, gt_answers):
+ answer = answer.replace('\n', ' ')
+ answer = answer.replace('\t', ' ')
+ answer = answer.strip()
+ answer = self.processPunctuation(answer)
+ answer = self.processDigitArticle(answer)
+ assert isinstance(gt_answers, list)
+ for i in range(len(gt_answers)):
+ gt_answers[i] = gt_answers[i].replace('\n', ' ')
+ gt_answers[i] = gt_answers[i].replace('\t', ' ')
+ gt_answers[i] = gt_answers[i].strip()
+ gt_answers[i] = self.processPunctuation(gt_answers[i])
+ gt_answers[i] = self.processDigitArticle(gt_answers[i])
+ if has_word(answer, gt_answers[i]):
+ return 1 / (i + 1)
+ return 0.0
+
+ def processPunctuation(self, inText):
+ outText = inText
+ for p in self.punct:
+ if (p + ' ' in inText or ' ' + p in inText) or (
+ re.search(self.commaStrip, inText) is not None
+ ):
+ outText = outText.replace(p, '')
+ else:
+ outText = outText.replace(p, ' ')
+ outText = self.periodStrip.sub('', outText, re.UNICODE)
+ return outText
+
+ def processDigitArticle(self, inText):
+ outText = []
+ tempText = inText.lower().split()
+ for word in tempText:
+ word = self.manualMap.setdefault(word, word)
+ if word not in self.articles:
+ outText.append(word)
+ else:
+ pass
+ for wordId, word in enumerate(outText):
+ if word in self.contractions:
+ outText[wordId] = self.contractions[word]
+
+ outText = [str(text) for text in outText]
+ outText = ' '.join(outText)
+ return outText
+
+
+def is_correct(answer, response):
+ # response_orig = response
+ response = response.strip('.')
+ if isinstance(answer, int):
+ if response.isdigit():
+ return int(int(response) == answer)
+
+ response = response.lower()
+ response = response.replace('the answer is', '')
+ response = response.replace('*', '') # parse **A**
+ if response.find('.') != -1:
+ response = response.split('.')[0]
+ response = response.replace(',', '')
+ response = response.strip()
+ response = response.strip()
+
+ if response == 'none':
+ return 0
+
+ if 'the camera is moving left' in response:
+ response = 'a'
+ elif 'the camera is moving right' in response:
+ response = 'b'
+
+ if len(response) != 1:
+ # print(f"Fail to parse {response_orig}")
+ return 0
+
+ return (ord(response) - ord('a')) == answer
+
+ if isinstance(answer, list):
+ try:
+ response = response.replace('json', '').replace('```', '').strip()
+ response = json.loads(response)
+ if isinstance(response, dict):
+ response = sum(list(response.values()), start=[])
+ except:
+ # print(f"Fail to parse {response_orig} Exception: {e}")
+ return 0
+
+ if not isinstance(response, (list, tuple)):
+ # print(f"Fail to parse {response_orig} Exception: not a list!")
+ return 0
+
+ match = 0
+ for res, ans in zip(response, answer):
+ match += res == ans
+ return match / len(answer)
+
+ return VQAEval().evaluate(response, answer)
diff --git a/vlmeval/dataset/utils/mmvet.py b/vlmeval/dataset/utils/mmvet.py
new file mode 100644
index 0000000000000000000000000000000000000000..e035eb0b6a29223304309e5624e8f75e328e2b5d
--- /dev/null
+++ b/vlmeval/dataset/utils/mmvet.py
@@ -0,0 +1,106 @@
+from ...smp import *
+
+
+def build_mmvet_gpt4_prompt(line):
+ question = line['question']
+ gt = str(line['answer'])
+ prediction = str(line['prediction'])
+ prompt = """
+Compare the ground truth and prediction from AI models, to give a correctness score for the prediction.
+ in the ground truth means it is totally right
+only when all elements in the ground truth are present in the prediction,
+and 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 -5 | x = 3 | 0.0
+What is x in the equation? | -1 -5 | x = -1 | 0.5
+What is x in the equation? | -1 -5 | x = -5 | 0.5
+What is x in the equation? | -1 -5 | x = -5 or 5 | 0.5
+What is x in the equation? | -1 -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
+"""
+ gpt4_prompt = prompt + '\n' + ' | '.join(
+ [question, gt.replace('', ' ').replace('', ' '), prediction, ''])
+ return gpt4_prompt
+
+
+def MMVet_auxeval(model, line):
+ def float_cvt(s):
+ try:
+ return float(s)
+ except ValueError:
+ return None
+
+ prompt = build_mmvet_gpt4_prompt(line)
+ log = ''
+ retry = 5
+ for i in range(retry):
+ output = model.generate(prompt, temperature=i * 0.5)
+ score = float_cvt(output)
+ if score is None:
+ log += f'Try {i}: output is {output}, failed to parse.\n'
+ elif score < 0 or score > 1:
+ log += f'Try {i}: output is {output}, invalid score: {score}.\n'
+ else:
+ log += 'Succeed'
+ return dict(log=log, score=score)
+ log += 'All 5 retries failed.\n'
+ return dict(log=log, score=0.0)
+
+
+def MMVet_acc(result_file):
+ data = load(result_file)
+ tot = defaultdict(lambda: 0)
+ score = defaultdict(lambda: 0)
+ lt = len(data)
+ cate2_list = []
+ for i in range(lt):
+ item = data.iloc[i]
+ cate = item['category']
+ cate2 = cate.replace(',', '_')
+ if cate2 not in cate2_list:
+ cate2_list.append(cate2)
+ grade = float(item['score'])
+ cate_list = ['rec', 'ocr', 'know', 'gen', 'spat', 'math']
+ for capa in cate_list:
+ if capa in cate:
+ tot[capa] += 1
+ score[capa] += grade
+ tot['Overall'] += 1
+ tot[cate2] += 1
+ score['Overall'] += grade
+ score[cate2] += grade
+
+ res = defaultdict(list)
+ res2 = defaultdict(list)
+ cate_list.append('Overall')
+ cate2_list.append('Overall')
+ for k in cate_list:
+ res['Category'].append(k)
+ res['tot'].append(tot[k])
+ res['acc'].append(score[k] / tot[k] * 100)
+ for v in cate2_list:
+ res2['Category'].append(v)
+ res2['tot'].append(tot[v])
+ res2['acc'].append(score[v] / tot[v] * 100)
+ res = pd.DataFrame(res)
+ res2 = pd.DataFrame(res2)
+ return res, res2
diff --git a/vlmeval/dataset/utils/moviechat1k.py b/vlmeval/dataset/utils/moviechat1k.py
new file mode 100644
index 0000000000000000000000000000000000000000..3c99621c2a745c5afef19935f62d3f260d3acc81
--- /dev/null
+++ b/vlmeval/dataset/utils/moviechat1k.py
@@ -0,0 +1,110 @@
+from ...smp import *
+import numpy as np
+import pandas as pd
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+CAL_SCORE_PROMPT = """Please evaluate the following video-based question-answer pair:
+
+Question: {question}
+Correct Answer: {answer}
+Predicted Answer: {pred_response}
+
+Provide your evaluation only as a yes/no and score where the score is an integer value between 0 and 5, with 5 indicating the highest meaningful match.
+Please generate the response in the form of a Python dictionary string with keys 'pred' and 'score', where value of 'pred' is a string of 'yes' or 'no' and value of 'score' is in INTEGER, not STRING.
+DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string.
+For example, your response should look like this: \{'pred': 'yes', 'score': 4.8\}.
+"""
+
+MOVIECHAT1K_DIMENSIONS = {
+ 'global': ['global'],
+ 'breakpoint': ['breakpoint'],
+ 'overall': []
+}
+
+L3_DIMS = []
+for k, v in MOVIECHAT1K_DIMENSIONS.items():
+ if k != 'overall':
+ L3_DIMS.extend(v)
+ MOVIECHAT1K_DIMENSIONS['overall'].extend(v)
+
+
+def get_dimension_rating(data_path):
+ data = load(data_path)
+ coarse_rating = {k: [] for k in MOVIECHAT1K_DIMENSIONS}
+ coarse_acc = {k: [] for k in MOVIECHAT1K_DIMENSIONS}
+
+ def parse_score_dict(score_dict):
+ """Helper function to parse score dictionary string"""
+ if isinstance(score_dict, dict):
+ return score_dict
+
+ if isinstance(score_dict, str):
+ try:
+ # First try standard json loading
+ return json.loads(score_dict)
+ except json.JSONDecodeError:
+ try:
+ # If that fails, try eval (safer than literal_eval for this case)
+ return eval(score_dict)
+ except:
+ print(f"Failed to parse score_dict: {score_dict}")
+ return None
+ return None
+
+ for i in range(len(data)):
+ mode = data.iloc[i]['mode'].lower() # Convert to lowercase
+ score_dict = parse_score_dict(data.iloc[i]['score'])
+ if score_dict and isinstance(score_dict, dict) and 'pred' in score_dict and 'score' in score_dict:
+ score = score_dict['score']
+ is_correct = 1 if score_dict['pred'].lower() == 'yes' else 0
+ else:
+ score = -1
+ is_correct = -1
+
+ # Map caption types to their lowercase versions
+ if mode in ['global', 'breakpoint']:
+ coarse_rating[mode].append(score)
+ coarse_rating['overall'].append(score)
+
+ if is_correct != -1:
+ coarse_acc[mode].append(is_correct)
+ coarse_acc['overall'].append(is_correct)
+
+
+ coarse_valid = {k: f'{np.mean([x for x in v if x >= 0]):.2f}' for k, v in coarse_rating.items()}
+ coarse_accuracy = {k: f'{np.mean(v):.2f}' if v else '0.00' for k, v in coarse_acc.items()}
+
+ return dict(
+ coarse_valid=coarse_valid,
+ coarse_accuracy=coarse_accuracy
+ )
+
+
+
+def prepare_score_prompt(item):
+ """
+ Prepare messages for score evaluation
+
+ Args:
+ item: DataFrame row containing question, answer, and prediction
+
+ Returns:
+ list: List of message dictionaries for the model
+ """
+ # Convert Series to dictionary if needed
+ if isinstance(item, pd.Series):
+ item = item.to_dict()
+
+
+ prompt = f"""Please evaluate the following video-based question-answer pair:\n\n
+ Question: {item['question']}\n
+ Correct Answer: {item['answer']}\n
+ Predicted Answer: {item['prediction']}\n\n
+ Provide your evaluation only as a yes/no and score where the score is an integer value between 0 and 5, with 5 indicating the highest meaningful match.
+ Please generate the response in the form of a Python dictionary string with keys 'pred' and 'score', where value of 'pred' is a string of 'yes' or 'no' and value of 'score' is in INTEGER, not STRING.
+ DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string.
+ For example, your response should look like this: {{'pred': 'yes', 'score': 4.8}}."""
+
+ return prompt
diff --git a/vlmeval/dataset/utils/multiple_choice.py b/vlmeval/dataset/utils/multiple_choice.py
new file mode 100644
index 0000000000000000000000000000000000000000..ab424cbfae60987049fd1c422c5faba9461716d8
--- /dev/null
+++ b/vlmeval/dataset/utils/multiple_choice.py
@@ -0,0 +1,567 @@
+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):
+ # assert group in [None, 'category', 'l2-category']
+ 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):
+ # assert group in [None, 'category', 'l2-category']
+ 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: \nWhat is the main object in image?\nOptions: A. teddy bear B. rabbit C. cat D. dog\n\n'
+ 'Answer: \na cute teddy bear\n\nYour output: A\n'
+ 'Example 2: \n'
+ 'Question: \nWhat is the main object in image?\nOptions: A. teddy bear B. rabbit C. cat D. dog\n\n'
+ 'Answer: \nSpider\n\nYour output: Z\n'
+ 'Example 3: \n'
+ 'Question: \n{}\nOptions: {}\n\nAnswer: \n{}\n\nYour output: '
+ )
+ question = question.replace(
+ ("Regarding the format, please answer following the template below, and be sure to include two <> symbols:\n"
+ ": <> : <>"),
+ '',
+ )
+ 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')
+ # It will return: (pred, raw, llm_time)
+ 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. ')
+
+
+# For Circular Evaluation
+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}. ')
+
+
+# For Circular Evaluation
+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)
+
+
+# data, meta are pd.DataFrame, result_file is a path
+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)):
+ # Dealing with the normal part
+ 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
+
+
+# data, meta are pd.DataFrame, result_file is a path
+def mcq_circular_eval(model, data, meta, nproc, result_file, dataset_name=None):
+ result = {}
+ if osp.exists(result_file):
+ result = load(result_file)
+ # Build Answer Map
+ 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']]
+
+ # Only keep those lines in the meta data
+ 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)):
+ # Dealing with the normal part
+ 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
diff --git a/vlmeval/dataset/utils/mvbench.py b/vlmeval/dataset/utils/mvbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..b2750ea796599cbc5e144a9cd6daf873574fb066
--- /dev/null
+++ b/vlmeval/dataset/utils/mvbench.py
@@ -0,0 +1,509 @@
+from ...smp import *
+from .multiple_choice import extract_answer_from_item
+from PIL import Image, ImageOps
+import torchvision
+import random
+import numbers
+import math
+import torch
+
+
+def get_dimension_rating(data_path):
+ data = load(data_path)
+ result_board = {}
+ for idx, item in data.iterrows():
+ if item['task_type'] not in result_board:
+ result_board[item['task_type']] = [0, 0]
+ result_board[item['task_type']][1] += 1
+ if item['score']:
+ result_board[item['task_type']][0] += 1
+
+ correct = 0
+ total = 0
+ for key, value in result_board.items():
+ correct += value[0]
+ total += value[1]
+ result_board[key].append(f'{value[0] / value[1] * 100 :.2f}%')
+
+ result_board['overall'] = [correct, total, f'{correct / total * 100 :.2f}%']
+
+ return result_board
+
+
+def check_ans(pred, gt):
+ flag = False
+
+ pred_list = pred.lower().strip().split(' ')
+ pred_option, _ = pred_list[0], ' '.join(pred_list[1:])
+ gt_list = gt.lower().strip().split(' ')
+ gt_option, gt_content = gt_list[0], ' '.join(gt_list[1:])
+ if gt_content[-1] == '.':
+ gt_content = gt_content[:-1]
+
+ if pred_option.replace('.', '') in gt_option:
+ flag = True
+ elif gt_option in pred_option:
+ flag = True
+
+ return flag
+
+
+def check_ans_with_model(pred, gt, model, item, dataset_name='MVBench'):
+ flag = False
+
+ pred_list = pred.lower().strip().split(' ')
+ pred_option, _ = pred_list[0], ' '.join(pred_list[1:])
+ gt_list = gt.lower().strip().split(' ')
+ gt_option, gt_content = gt_list[0], ' '.join(gt_list[1:])
+ if gt_content[-1] == '.':
+ gt_content = gt_content[:-1]
+
+ if pred_option.replace('.', '') in gt_option:
+ flag = True
+ elif gt_option in pred_option:
+ flag = True
+ elif extract_answer_from_item(model, item, dataset_name)['opt'] == item['answer']:
+ flag = True
+
+ return flag
+
+
+def check_ans_advanced(pred, gt):
+ number_table = {
+ 0: 'zero',
+ 1: 'one',
+ 2: 'two',
+ 3: 'three',
+ 4: 'four',
+ 5: 'five',
+ 6: 'six',
+ 7: 'seven',
+ 8: 'eight',
+ 9: 'nine',
+ }
+ flag = False
+
+ pred_list = pred.lower().strip().split(' ')
+ pred_option, _ = pred_list[0], ' '.join(pred_list[1:])
+ gt_list = gt.lower().strip().split(' ')
+ gt_option, gt_content = gt_list[0], ' '.join(gt_list[1:])
+ if gt_content[-1] == '.':
+ gt_content = gt_content[:-1]
+
+ try:
+ gt_content = number_table[int(gt_content.strip('. \n'))]
+ print(gt_content)
+ except:
+ pass
+
+ if pred_option.replace('.', '') in gt_option:
+ flag = True
+ elif gt_option in pred_option:
+ flag = True
+ elif gt_content.lower().strip('. \n') in pred.lower().strip('. \n'):
+ flag = True
+
+ return flag
+
+
+class GroupRandomCrop(object):
+ def __init__(self, size):
+ if isinstance(size, numbers.Number):
+ self.size = (int(size), int(size))
+ else:
+ self.size = size
+
+ def __call__(self, img_group):
+
+ w, h = img_group[0].size
+ th, tw = self.size
+
+ out_images = list()
+
+ x1 = random.randint(0, w - tw)
+ y1 = random.randint(0, h - th)
+
+ for img in img_group:
+ assert (img.size[0] == w and img.size[1] == h)
+ if w == tw and h == th:
+ out_images.append(img)
+ else:
+ out_images.append(img.crop((x1, y1, x1 + tw, y1 + th)))
+
+ return out_images
+
+
+class MultiGroupRandomCrop(object):
+ def __init__(self, size, groups=1):
+ if isinstance(size, numbers.Number):
+ self.size = (int(size), int(size))
+ else:
+ self.size = size
+ self.groups = groups
+
+ def __call__(self, img_group):
+
+ w, h = img_group[0].size
+ th, tw = self.size
+
+ out_images = list()
+
+ for i in range(self.groups):
+ x1 = random.randint(0, w - tw)
+ y1 = random.randint(0, h - th)
+
+ for img in img_group:
+ assert (img.size[0] == w and img.size[1] == h)
+ if w == tw and h == th:
+ out_images.append(img)
+ else:
+ out_images.append(img.crop((x1, y1, x1 + tw, y1 + th)))
+
+ return out_images
+
+
+class GroupCenterCrop(object):
+ def __init__(self, size):
+ self.worker = torchvision.transforms.CenterCrop(size)
+
+ def __call__(self, img_group):
+ return [self.worker(img) for img in img_group]
+
+
+class GroupRandomHorizontalFlip(object):
+ """Randomly horizontally flips the given PIL.Image with a probability of 0.5
+ """
+
+ def __init__(self, is_flow=False):
+ self.is_flow = is_flow
+
+ def __call__(self, img_group, is_flow=False):
+ v = random.random()
+ if v < 0.5:
+ ret = [img.transpose(Image.FLIP_LEFT_RIGHT) for img in img_group]
+ if self.is_flow:
+ for i in range(0, len(ret), 2):
+ # invert flow pixel values when flipping
+ ret[i] = ImageOps.invert(ret[i])
+ return ret
+ else:
+ return img_group
+
+
+class GroupNormalize(object):
+ def __init__(self, mean, std):
+ self.mean = mean
+ self.std = std
+
+ def __call__(self, tensor):
+ rep_mean = self.mean * (tensor.size()[0] // len(self.mean))
+ rep_std = self.std * (tensor.size()[0] // len(self.std))
+
+ # TODO: make efficient
+ for t, m, s in zip(tensor, rep_mean, rep_std):
+ t.sub_(m).div_(s)
+
+ return tensor
+
+
+class GroupScale(object):
+ """ Rescales the input PIL.Image to the given 'size'.
+ 'size' will be the size of the smaller edge.
+ For example, if height > width, then image will be
+ rescaled to (size * height / width, size)
+ size: size of the smaller edge
+ interpolation: Default: PIL.Image.BILINEAR
+ """
+
+ def __init__(self, size, interpolation=Image.BILINEAR):
+ self.worker = torchvision.transforms.Resize(size, interpolation)
+
+ def __call__(self, img_group):
+ return [self.worker(img) for img in img_group]
+
+
+class GroupOverSample(object):
+ def __init__(self, crop_size, scale_size=None, flip=True):
+ self.crop_size = crop_size if not isinstance(
+ crop_size, int) else (crop_size, crop_size)
+
+ if scale_size is not None:
+ self.scale_worker = GroupScale(scale_size)
+ else:
+ self.scale_worker = None
+ self.flip = flip
+
+ def __call__(self, img_group):
+
+ if self.scale_worker is not None:
+ img_group = self.scale_worker(img_group)
+
+ image_w, image_h = img_group[0].size
+ crop_w, crop_h = self.crop_size
+
+ offsets = GroupMultiScaleCrop.fill_fix_offset(
+ False, image_w, image_h, crop_w, crop_h)
+ oversample_group = list()
+ for o_w, o_h in offsets:
+ normal_group = list()
+ flip_group = list()
+ for i, img in enumerate(img_group):
+ crop = img.crop((o_w, o_h, o_w + crop_w, o_h + crop_h))
+ normal_group.append(crop)
+ flip_crop = crop.copy().transpose(Image.FLIP_LEFT_RIGHT)
+
+ if img.mode == 'L' and i % 2 == 0:
+ flip_group.append(ImageOps.invert(flip_crop))
+ else:
+ flip_group.append(flip_crop)
+
+ oversample_group.extend(normal_group)
+ if self.flip:
+ oversample_group.extend(flip_group)
+ return oversample_group
+
+
+class GroupFullResSample(object):
+ def __init__(self, crop_size, scale_size=None, flip=True):
+ self.crop_size = crop_size if not isinstance(
+ crop_size, int) else (crop_size, crop_size)
+
+ if scale_size is not None:
+ self.scale_worker = GroupScale(scale_size)
+ else:
+ self.scale_worker = None
+ self.flip = flip
+
+ def __call__(self, img_group):
+
+ if self.scale_worker is not None:
+ img_group = self.scale_worker(img_group)
+
+ image_w, image_h = img_group[0].size
+ crop_w, crop_h = self.crop_size
+
+ w_step = (image_w - crop_w) // 4
+ h_step = (image_h - crop_h) // 4
+
+ offsets = list()
+ offsets.append((0 * w_step, 2 * h_step)) # left
+ offsets.append((4 * w_step, 2 * h_step)) # right
+ offsets.append((2 * w_step, 2 * h_step)) # center
+
+ oversample_group = list()
+ for o_w, o_h in offsets:
+ normal_group = list()
+ flip_group = list()
+ for i, img in enumerate(img_group):
+ crop = img.crop((o_w, o_h, o_w + crop_w, o_h + crop_h))
+ normal_group.append(crop)
+ if self.flip:
+ flip_crop = crop.copy().transpose(Image.FLIP_LEFT_RIGHT)
+
+ if img.mode == 'L' and i % 2 == 0:
+ flip_group.append(ImageOps.invert(flip_crop))
+ else:
+ flip_group.append(flip_crop)
+
+ oversample_group.extend(normal_group)
+ oversample_group.extend(flip_group)
+ return oversample_group
+
+
+class GroupMultiScaleCrop(object):
+
+ def __init__(self, input_size, scales=None, max_distort=1,
+ fix_crop=True, more_fix_crop=True):
+ self.scales = scales if scales is not None else [1, .875, .75, .66]
+ self.max_distort = max_distort
+ self.fix_crop = fix_crop
+ self.more_fix_crop = more_fix_crop
+ self.input_size = input_size if not isinstance(input_size, int) else [
+ input_size, input_size]
+ self.interpolation = Image.BILINEAR
+
+ def __call__(self, img_group):
+
+ im_size = img_group[0].size
+
+ crop_w, crop_h, offset_w, offset_h = self._sample_crop_size(im_size)
+ crop_img_group = [
+ img.crop(
+ (offset_w,
+ offset_h,
+ offset_w + crop_w,
+ offset_h + crop_h)) for img in img_group]
+ ret_img_group = [img.resize((self.input_size[0], self.input_size[1]), self.interpolation)
+ for img in crop_img_group]
+ return ret_img_group
+
+ def _sample_crop_size(self, im_size):
+ image_w, image_h = im_size[0], im_size[1]
+
+ # find a crop size
+ base_size = min(image_w, image_h)
+ crop_sizes = [int(base_size * x) for x in self.scales]
+ crop_h = [
+ self.input_size[1] if abs(
+ x - self.input_size[1]) < 3 else x for x in crop_sizes]
+ crop_w = [
+ self.input_size[0] if abs(
+ x - self.input_size[0]) < 3 else x for x in crop_sizes]
+
+ pairs = []
+ for i, h in enumerate(crop_h):
+ for j, w in enumerate(crop_w):
+ if abs(i - j) <= self.max_distort:
+ pairs.append((w, h))
+
+ crop_pair = random.choice(pairs)
+ if not self.fix_crop:
+ w_offset = random.randint(0, image_w - crop_pair[0])
+ h_offset = random.randint(0, image_h - crop_pair[1])
+ else:
+ w_offset, h_offset = self._sample_fix_offset(
+ image_w, image_h, crop_pair[0], crop_pair[1])
+
+ return crop_pair[0], crop_pair[1], w_offset, h_offset
+
+ def _sample_fix_offset(self, image_w, image_h, crop_w, crop_h):
+ offsets = self.fill_fix_offset(
+ self.more_fix_crop, image_w, image_h, crop_w, crop_h)
+ return random.choice(offsets)
+
+ @staticmethod
+ def fill_fix_offset(more_fix_crop, image_w, image_h, crop_w, crop_h):
+ w_step = (image_w - crop_w) // 4
+ h_step = (image_h - crop_h) // 4
+
+ ret = list()
+ ret.append((0, 0)) # upper left
+ ret.append((4 * w_step, 0)) # upper right
+ ret.append((0, 4 * h_step)) # lower left
+ ret.append((4 * w_step, 4 * h_step)) # lower right
+ ret.append((2 * w_step, 2 * h_step)) # center
+
+ if more_fix_crop:
+ ret.append((0, 2 * h_step)) # center left
+ ret.append((4 * w_step, 2 * h_step)) # center right
+ ret.append((2 * w_step, 4 * h_step)) # lower center
+ ret.append((2 * w_step, 0 * h_step)) # upper center
+
+ ret.append((1 * w_step, 1 * h_step)) # upper left quarter
+ ret.append((3 * w_step, 1 * h_step)) # upper right quarter
+ ret.append((1 * w_step, 3 * h_step)) # lower left quarter
+ ret.append((3 * w_step, 3 * h_step)) # lower righ quarter
+
+ return ret
+
+
+class GroupRandomSizedCrop(object):
+ """Random crop the given PIL.Image to a random size of (0.08 to 1.0) of the original size
+ and and a random aspect ratio of 3/4 to 4/3 of the original aspect ratio
+ This is popularly used to train the Inception networks
+ size: size of the smaller edge
+ interpolation: Default: PIL.Image.BILINEAR
+ """
+
+ def __init__(self, size, interpolation=Image.BILINEAR):
+ self.size = size
+ self.interpolation = interpolation
+
+ def __call__(self, img_group):
+ for attempt in range(10):
+ area = img_group[0].size[0] * img_group[0].size[1]
+ target_area = random.uniform(0.08, 1.0) * area
+ aspect_ratio = random.uniform(3. / 4, 4. / 3)
+
+ w = int(round(math.sqrt(target_area * aspect_ratio)))
+ h = int(round(math.sqrt(target_area / aspect_ratio)))
+
+ if random.random() < 0.5:
+ w, h = h, w
+
+ if w <= img_group[0].size[0] and h <= img_group[0].size[1]:
+ x1 = random.randint(0, img_group[0].size[0] - w)
+ y1 = random.randint(0, img_group[0].size[1] - h)
+ found = True
+ break
+ else:
+ found = False
+ x1 = 0
+ y1 = 0
+
+ if found:
+ out_group = list()
+ for img in img_group:
+ img = img.crop((x1, y1, x1 + w, y1 + h))
+ assert (img.size == (w, h))
+ out_group.append(
+ img.resize(
+ (self.size, self.size), self.interpolation))
+ return out_group
+ else:
+ # Fallback
+ scale = GroupScale(self.size, interpolation=self.interpolation)
+ crop = GroupRandomCrop(self.size)
+ return crop(scale(img_group))
+
+
+class ConvertDataFormat(object):
+ def __init__(self, model_type):
+ self.model_type = model_type
+
+ def __call__(self, images):
+ if self.model_type == '2D':
+ return images
+ tc, h, w = images.size()
+ t = tc // 3
+ images = images.view(t, 3, h, w)
+ images = images.permute(1, 0, 2, 3)
+ return images
+
+
+class Stack(object):
+
+ def __init__(self, roll=False):
+ self.roll = roll
+
+ def __call__(self, img_group):
+ if img_group[0].mode == 'L':
+ return np.concatenate([np.expand_dims(x, 2)
+ for x in img_group], axis=2)
+ elif img_group[0].mode == 'RGB':
+ if self.roll:
+ return np.concatenate([np.array(x)[:, :, ::-1]
+ for x in img_group], axis=2)
+ else:
+ # print(np.concatenate(img_group, axis=2).shape)
+ # print(img_group[0].shape)
+ return np.concatenate(img_group, axis=2)
+
+
+class ToTorchFormatTensor(object):
+ """ Converts a PIL.Image (RGB) or numpy.ndarray (H x W x C) in the range [0, 255]
+ to a torch.FloatTensor of shape (C x H x W) in the range [0.0, 1.0] """
+
+ def __init__(self, div=True):
+ self.div = div
+
+ def __call__(self, pic):
+ if isinstance(pic, np.ndarray):
+ # handle numpy array
+ img = torch.from_numpy(pic).permute(2, 0, 1).contiguous()
+ else:
+ # handle PIL Image
+ img = torch.ByteTensor(
+ torch.ByteStorage.from_buffer(
+ pic.tobytes()))
+ img = img.view(pic.size[1], pic.size[0], len(pic.mode))
+ # put it from HWC to CHW format
+ # yikes, this transpose takes 80% of the loading time/CPU
+ img = img.transpose(0, 1).transpose(0, 2).contiguous()
+ return img.float().div(255) if self.div else img.float()
+
+
+class IdentityTransform(object):
+
+ def __call__(self, data):
+ return data
diff --git a/vlmeval/dataset/utils/naturalbench.py b/vlmeval/dataset/utils/naturalbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed9a9576d2a61c61424de3f6cbbbd1456d627291
--- /dev/null
+++ b/vlmeval/dataset/utils/naturalbench.py
@@ -0,0 +1,145 @@
+import re
+
+
+def extract_answer(output_string, task_type="yes_no"):
+ """
+ Extracts the answer from the output string based on the task type.
+
+ Parameters:
+ output_string (str): The output string.
+ task_type (str): The type of task. Must be either "yes_no" or "multiple_choice".
+
+ Returns:
+ int:
+ 1 if "yes" or "A"
+ 0 if "no" or "B"
+ -1 if no relevant answer is found.
+ Raises a ValueError if an unsupported task_type is provided.
+ """
+
+ def find_word_position(string, word):
+ pattern = r'\b' + re.escape(word) + r'\b'
+ match = re.search(pattern, string, re.IGNORECASE)
+ if match:
+ return match.start()
+ return -1
+
+ if task_type not in ["yes_no", "multiple_choice"]:
+ raise ValueError(f"Task type {task_type} not supported. Must be 'yes_no' or 'multiple_choice'.")
+
+ if task_type == "yes_no":
+ position_yes_and_a = find_word_position(output_string, "yes")
+ position_no_and_b = find_word_position(output_string, "no")
+ elif task_type == "multiple_choice":
+ position_yes_and_a = find_word_position(output_string, "A")
+ position_no_and_b = find_word_position(output_string, "B")
+
+ if position_yes_and_a == -1 and position_no_and_b == -1:
+ print(f"No answer found in the output string: {output_string}.")
+ return -1
+ elif position_yes_and_a != -1 and position_no_and_b != -1:
+ return 1 if position_yes_and_a < position_no_and_b else 0
+ else:
+ return 0 if position_yes_and_a == -1 else 1
+
+
+def get_scores(scores):
+ """
+ Calculate various scores based on the given results.
+
+ Args:
+ scores (dict or list): A dictionary or list containing results where each result can be:
+ - dict: {id: {"q0_i0": 1 or 0, "q0_i1": 1 or 0, "q1_i0": 1 or 0, "q1_i1": 1 or 0}, ...}
+ - list: [[q0_i0 (1 or 0), q0_i1 (1 or 0), q1_i0 (1 or 0), q1_i1 (1 or 0)], ...]
+
+ The keys "q0_i0", "q0_i1", "q1_i0", "q1_i1" represent combinations of questions and images:
+ - "q0_i0" means question_0 on image_0
+ - "q0_i1" means question_0 on image_1
+ - "q1_i0" means question_1 on image_0
+ - "q1_i1" means question_1 on image_1
+
+ Returns:
+ dict: A dictionary containing the calculated scores:
+ - 'Q_Acc': Average question score
+ - 'I_Acc': Average image score
+ - 'Acc': Average binary VQA score
+ - 'G_Acc': Average group score
+ """
+ Q_Acc = 0.0
+ I_Acc = 0.0
+ Acc = 0.0
+ G_Acc = 0.0
+
+ num_samples = len(scores)
+
+ def calculate_image_score(result):
+ image_correct = 0
+ if isinstance(result, dict):
+ if result["q0_i0"] == 1.0 and result["q1_i0"] == 0.0:
+ image_correct += 1
+ if result["q1_i1"] == 1.0 and result["q0_i1"] == 0.0:
+ image_correct += 1
+ elif isinstance(result, list):
+ if result[0] == 1.0 and result[2] == 0.0:
+ image_correct += 1
+ if result[3] == 1.0 and result[1] == 0.0:
+ image_correct += 1
+ return image_correct
+
+ def calculate_question_score(result):
+ text_correct = 0
+ if isinstance(result, dict):
+ if result["q0_i0"] == 1.0 and result["q0_i1"] == 0.0:
+ text_correct += 1
+ if result["q1_i1"] == 1.0 and result["q1_i0"] == 0.0:
+ text_correct += 1
+ else:
+ if result[0] == 1.0 and result[1] == 0.0:
+ text_correct += 1
+ if result[3] == 1.0 and result[2] == 0.0:
+ text_correct += 1
+ return text_correct
+
+ def calculate_binary_score(result):
+ binary_score_correct = 0
+ if isinstance(result, dict):
+ binary_score_correct += 1 if result["q0_i0"] == 1.0 else 0
+ binary_score_correct += 1 if result["q0_i1"] == 0.0 else 0
+ binary_score_correct += 1 if result["q1_i0"] == 0.0 else 0
+ binary_score_correct += 1 if result["q1_i1"] == 1.0 else 0
+ else:
+ binary_score_correct += 1 if result[0] == 1.0 else 0
+ binary_score_correct += 1 if result[1] == 0.0 else 0
+ binary_score_correct += 1 if result[2] == 0.0 else 0
+ binary_score_correct += 1 if result[3] == 1.0 else 0
+
+ return binary_score_correct
+
+ def calculate_group(result):
+ group_correct = 0
+ if calculate_question_score(result) == 2 and calculate_image_score(result) == 2:
+ group_correct += 1
+
+ return group_correct
+
+ if isinstance(scores, dict):
+ for _, result in scores.items():
+ Q_Acc += calculate_question_score(result)
+ I_Acc += calculate_image_score(result)
+ Acc += calculate_binary_score(result)
+ G_Acc += calculate_group(result)
+ else:
+ for result in scores:
+ Q_Acc += calculate_question_score(result)
+ I_Acc += calculate_image_score(result)
+ Acc += calculate_binary_score(result)
+ G_Acc += calculate_group(result)
+
+ results = {
+ 'Q_Acc': Q_Acc / float(num_samples * 2),
+ 'I_Acc': I_Acc / float(num_samples * 2),
+ 'Acc': Acc / float(num_samples * 4),
+ 'G_Acc': G_Acc / num_samples
+ }
+
+ return results
diff --git a/vlmeval/dataset/utils/ocrbench.py b/vlmeval/dataset/utils/ocrbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..f88bb246c3a2737dda9d60c335b8b069df8d8b56
--- /dev/null
+++ b/vlmeval/dataset/utils/ocrbench.py
@@ -0,0 +1,65 @@
+from ...smp import *
+
+
+def OCRBench_eval(eval_file):
+ OCRBench_score = {
+ 'Regular Text Recognition': 0,
+ 'Irregular Text Recognition': 0,
+ 'Artistic Text Recognition': 0,
+ 'Handwriting Recognition': 0,
+ 'Digit String Recognition': 0,
+ 'Non-Semantic Text Recognition': 0,
+ 'Scene Text-centric VQA': 0,
+ 'Doc-oriented VQA': 0,
+ 'Key Information Extraction': 0,
+ 'Handwritten Mathematical Expression Recognition': 0
+ }
+
+ logger = get_logger('Evaluation')
+
+ data = load(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 = eval(line['answer'])
+ category = line['category']
+ if category == 'Handwritten Mathematical Expression Recognition':
+ for j in range(len(answers)):
+ answer = answers[j].strip().replace('\n', ' ').replace(' ', '')
+ predict = predict.strip().replace('\n', ' ').replace(' ', '')
+ if answer in predict:
+ OCRBench_score[category] += 1
+ break
+ else:
+ for j in range(len(answers)):
+ answer = answers[j].lower().strip().replace('\n', ' ')
+ predict = predict.lower().strip().replace('\n', ' ')
+ if answer in predict:
+ OCRBench_score[category] += 1
+ break
+
+ final_score_dict = {}
+ final_score_dict['Text Recognition'] = (
+ OCRBench_score['Regular Text Recognition'] + OCRBench_score['Irregular Text Recognition']
+ + OCRBench_score['Artistic Text Recognition'] + OCRBench_score['Handwriting Recognition']
+ + OCRBench_score['Digit String Recognition'] + OCRBench_score['Non-Semantic Text Recognition']
+ )
+ final_score_dict['Scene Text-centric VQA'] = OCRBench_score['Scene Text-centric VQA']
+ final_score_dict['Doc-oriented VQA'] = OCRBench_score['Doc-oriented VQA']
+ final_score_dict['Key Information Extraction'] = OCRBench_score['Key Information Extraction']
+ final_score_dict['Handwritten Mathematical Expression Recognition'] = \
+ OCRBench_score['Handwritten Mathematical Expression Recognition']
+ final_score_dict['Final Score'] = (
+ final_score_dict['Text Recognition'] + final_score_dict['Scene Text-centric VQA']
+ + final_score_dict['Doc-oriented VQA'] + final_score_dict['Key Information Extraction']
+ + final_score_dict['Handwritten Mathematical Expression Recognition']
+ )
+ final_score_dict['Final Score Norm'] = float(final_score_dict['Final Score']) / 10
+ score_pth = eval_file.replace('.xlsx', '_score.json')
+ dump(final_score_dict, score_pth)
+ logger.info(f'OCRBench_eval successfully finished evaluating {eval_file}, results saved in {score_pth}')
+ logger.info('Score: ')
+ for key, value in final_score_dict.items():
+ logger.info('{}:{}'.format(key, value))
diff --git a/vlmeval/dataset/utils/olympiadbench.py b/vlmeval/dataset/utils/olympiadbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..eaa781b330ffb0770ad7e97fba0ec1faa131311e
--- /dev/null
+++ b/vlmeval/dataset/utils/olympiadbench.py
@@ -0,0 +1,542 @@
+import re
+import json
+from math import isclose
+from decimal import Decimal, getcontext
+from fractions import Fraction
+import sys
+import math
+import timeout_decorator
+
+try:
+ import sympy as sp
+ from sympy import simplify, Eq, sympify, evalf, Pow
+ from sympy.parsing.latex import parse_latex
+ import antlr4
+except ImportError:
+ logging.warning('sympy or antlr4 is not installed, please install it for OlympiadBench evaluation.')
+
+
+chinese_answer_type_dict = {
+ 'Numerical': '数值',
+ 'Expression': '表达式',
+ 'Equation': '方程',
+ 'Interval': '区间'
+}
+english_answer_type_dict = {
+ 'Numerical': 'a numerical value',
+ 'Expression': 'an expression',
+ 'Equation': 'an equation',
+ 'Interval': 'an interval'
+}
+
+
+def get_single_answer_type_text(answer_type, is_chinese):
+ if '-' in answer_type: # No need now
+ answer_type = answer_type[:answer_type.find('-')]
+ for t in ['Numerical', 'Expression', 'Equation', 'Interval']:
+ if t in answer_type:
+ if is_chinese:
+ return chinese_answer_type_dict[t]
+ else:
+ return english_answer_type_dict[t]
+ exit(f'Error parsing answer type {answer_type}!')
+
+
+def get_answer_type_text(answer_type, is_chinese, multiple_answer):
+ # 'Tuple' has various meanings in different context, such as position or values of a series of variable,
+ # so it may lead to confusion to directly use 'tuple' in the prompt.
+ if ('Need_human_evaluate' in answer_type) or ('Tuple' in answer_type):
+ full_answer_text = ''
+ else:
+ if not multiple_answer:
+ answer_text = get_single_answer_type_text(answer_type, is_chinese)
+ if is_chinese:
+ full_answer_text = f'，答案类型为{answer_text}'
+ else:
+ full_answer_text = f"The answer of The problem should be {answer_text}. "
+ else:
+ if ',' not in answer_type: # Same answer type for all answers
+ answer_text = get_single_answer_type_text(answer_type, is_chinese)
+ if is_chinese:
+ full_answer_text = f'，题目有多个答案，答案类型均为{answer_text}'
+ else:
+ full_answer_text = f'The problem has multiple answers, each of them should be {answer_text}. '
+ else:
+ answer_types = answer_type.split(',')
+ answer_types = [get_single_answer_type_text(t, is_chinese) for t in answer_types]
+ if len(set(answer_types)) == 1:
+ answer_text = answer_types[0]
+ if is_chinese:
+ full_answer_text = f'，题目有多个答案，答案类型均为{answer_text}'
+ else:
+ full_answer_text = f'The problem has multiple answers, each of them should be {answer_text}. '
+ else:
+ if is_chinese:
+ answer_text = '、'.join(answer_types)
+ full_answer_text = f'，题目有多个答案，答案类型分别为{answer_text}'
+ else:
+ answer_text = ', '.join(answer_types)
+ full_answer_text = (
+ f'The problem has multiple answers, with the answers in order being {answer_text}. '
+ )
+ return full_answer_text
+
+
+def make_input(prompt, question_content):
+ # diversified based on the vllm, which is not implemented temporarily
+ input = prompt + '\n' + question_content
+ return input
+
+
+sys.set_int_max_str_digits(1000000)
+# 设置decimal的精度
+getcontext().prec = 50
+
+
+class MathJudger:
+ def __init__(self):
+ self.special_signal_map = {
+ "\\left": "",
+ "\\right": "",
+ "∶": ":",
+ "，": ",",
+ "$": "",
+ "\\approx": "=",
+ "\\simeq": "=",
+ "\\sim": "=",
+ "^\\prime": "'",
+ "^{\\prime}": "'",
+ "^\\circ": "",
+ "%": "",
+ }
+ self.pi = parse_latex("\\pi")
+ self.precision = 1e-8
+
+ def split_by_comma(self, expr: str):
+ in_bracket_num = 0
+ splitted_expr = []
+ start_idx = 0
+ for i, char in enumerate(expr):
+ if char == "(" or char == "[":
+ in_bracket_num += 1
+ elif char == ")" or char == "]":
+ in_bracket_num -= 1
+ elif char == "," and in_bracket_num == 0:
+ splitted_expr.append(expr[start_idx:i].strip())
+ start_idx = i + 1
+
+ if start_idx < len(expr):
+ splitted_expr.append(expr[start_idx:].strip())
+
+ return splitted_expr
+
+ def trans_plus_minus_sign(self, expr_list: list):
+ new_expr_list = []
+ for expr in expr_list:
+ if "\\pm" in expr:
+ new_expr_list.append(expr.replace("\\pm", "+"))
+ new_expr_list.append(expr.replace("\\pm", "-"))
+ else:
+ new_expr_list.append(expr)
+
+ return new_expr_list
+
+ def judge(self, expression1, expression2, precision=1e-8):
+ # (默认 expression1 为 Ground_Truth)
+ precision = precision if isinstance(precision, list) else [precision]
+
+ try:
+ expression1, expression2 = self.preprocess(expression1, expression2)
+ except:
+ return False
+ if expression1 == expression2:
+ # print("原生相等")
+ return True
+
+ # 去除字符串中的中文字符，因为上面已经判断过了类似回答为"能"或"不能"的含有中文字符的回答情况
+ expression1 = re.sub(r'[\u4e00-\u9fff]+', '', expression1)
+ expression2 = re.sub(r'[\u4e00-\u9fff]+', '', expression2)
+
+ expression1 = self.split_by_comma(expression1)
+ expression2 = self.split_by_comma(expression2)
+
+ temp_list1 = self.trans_plus_minus_sign(expression1)
+ temp_list2 = self.trans_plus_minus_sign(expression2)
+
+ # 设计误差值列表
+ if len(precision) <= 1:
+ precision = precision * len(temp_list1)
+
+ if len(temp_list1) != len(temp_list2):
+ return False
+
+ # 判断两个列表中的元素是否可以两两配对，并且两两相等，由此支持多个回答的比较
+ idx = -1
+ while len(temp_list1) != 0:
+ idx = (idx + 1) % len(temp_list1)
+
+ item1 = temp_list1[idx]
+ self.precision = precision[idx]
+ # print(self.precision)
+
+ for item2 in temp_list2:
+ try:
+ if self.is_equal(item1, item2):
+ temp_list1.remove(item1)
+ temp_list2.remove(item2)
+ precision.remove(self.precision)
+ break
+ except Exception as err:
+ logging.warning(f'{type(err)}: {err}')
+ continue
+ else:
+ # If we didn't break from the inner loop, it means no match was found
+ return False
+
+ # If all elements are matched and removed, the lists can be paired
+ return True
+
+ def is_interval(self, epr):
+ return epr.startswith(("(", "[")) and epr.endswith((")", "]"))
+
+ # 在进行数值计算前，需要将sympy中的pi符号替换为pi的近似数值
+ # def sympy_sub_pi(self, expression_sympy):
+ # return expression_sympy.subs(self.pi, math.pi)
+
+ # 默认第一个表达式是 ground_truth
+ @timeout_decorator.timeout(30)
+ def is_equal(self, expression1, expression2):
+ if expression1 == expression2 and expression1 != "" and expression2 != "":
+ # print("原生等价")
+ return True
+
+ # 先判断是否是两个区间，是的话进行判断相等，不相等则返回 False
+ if self.is_interval(expression1) and self.is_interval(expression2):
+ try:
+ if self.interval_equal(expression1, expression2):
+ # print("区间等价")
+ return True
+ except:
+ return False
+
+ # 再判断是否在数值上相等
+ try:
+ if self.numerical_equal(expression1, expression2):
+ # print("数值等价")
+ return True
+ except:
+ pass
+
+ # 再判断是否是表达式相等
+ try:
+ if self.expression_equal(expression1, expression2) and not ("=" in expression1 and "=" in expression2):
+ # print("表达式等价")
+ return True
+ except:
+ pass
+
+ # 再判断是否是等式相等
+ try:
+ if self.equation_equal(expression1, expression2):
+ # print("等式等价")
+ return True
+ except:
+ pass
+
+ return False
+
+ # 判断两个数值在误差允许范围内是否相等
+ def numerical_equal(self, expression1: str, expression2: str, include_percentage: bool = True):
+ """
+ (默认 expression1 为 Ground_Truth)
+ 函数: 判读两个数值是否在误差允许范围内相等
+ 步骤1: 将可能出现的百分号的情况包含进来
+ 步骤2: 使用 math.isclose 函数判断是否相等
+ """
+ reference = float(expression1)
+ prediction = float(expression2)
+
+ if include_percentage:
+ gt_result = [reference / 100, reference, reference * 100]
+ else:
+ gt_result = [reference]
+
+ for item in gt_result:
+ # if isclose(item, prediction, abs_tol=self.precision, rel_tol=0):
+ if abs(item - prediction) <= self.precision * 1.01:
+ return True
+ return False
+
+ def expression_equal(self, exp1, exp2):
+ """
+ (默认 expression1 为 Ground_Truth)
+ 函数: 判断两个表达式是否在数学意义上等价
+ 步骤1: 提取表达式, 防止有的模型会给出"x=1"而不是"1"
+ 步骤2: 使用 sympy 库进行等价判断
+ """
+
+ # 只提取等号右边的表达式，一般左边是所求的量
+ def extract_expression(expression):
+ if "=" in expression:
+ expression = expression.split("=")[1]
+ return expression.strip()
+
+ exp1 = extract_expression(exp1)
+ exp2 = extract_expression(exp2)
+
+ exp_too_long = len(exp1) > 300 or len(exp2) > 300
+
+ # 将表达式转换为 sympy 中能够进行处理的格式
+ expr1_sym = sympify(parse_latex(exp1))
+ expr2_sym = sympify(parse_latex(exp2))
+
+ if expr1_sym == expr2_sym:
+ return True
+ else:
+ expr1_sym = self.sympy_sub_pi(expr1_sym)
+ expr2_sym = self.sympy_sub_pi(expr2_sym)
+ # 如果输入的表达式可以计算出具体数值的话，则将其进行数值计算的比较
+
+ if (expr1_sym.has(sp.Symbol) and not expr2_sym.has(sp.Symbol)) or (
+ not expr1_sym.has(sp.Symbol) and expr2_sym.has(sp.Symbol)):
+ return False
+ elif not expr1_sym.has(sp.Symbol) and not expr2_sym.has(sp.Symbol):
+ try:
+ if not (self.can_compute_power(expr1_sym) and self.can_compute_power(expr2_sym)):
+ print(
+ "These two number can not be calculated by current computer for: "
+ f"\"{str(expr1_sym)}\" and \"{str(expr2_sym)}\""
+ )
+ return False
+ if exp_too_long:
+ print(f'Expression {exp1} or {exp2} is too long to compute. ')
+ return False
+
+ if abs(expr1_sym.evalf() - expr2_sym.evalf()) <= self.precision * 1.01:
+ return True
+ else:
+ return False
+ except:
+ return False
+ elif exp_too_long:
+ print(f'Expression {exp1} or {exp2} is too long to compute. ')
+ return False
+ else:
+ try:
+ simplified_expr = simplify(expr1_sym - expr2_sym)
+
+ num_value = simplified_expr.evalf()
+
+ return abs(num_value) < 1e-3
+ except:
+ return False
+
+ def equation_equal(self, expression1, expression2):
+ """
+ (默认 expression1 为 Ground_Truth)
+ 函数: 判断两个方程是否在数学意义上等价
+ 步骤1: 将一个方程/等式化简为标准方程, 即等式的右边严格等于0, 接下来只需要判断两个等式的左边是否"等价"
+ 步骤2: 使用 sympy 库计算两个等式左边的商, 如果这个商或者这个商的倒数为整数, 那么数学意义上我们可以推导出这两个方程等价👌
+ """
+
+ # 将等式的右边都移到左边，并返回一个 sympy 格式的表达式
+ def simplify_equation(latex_eq):
+ # 分割等式的左边和右边
+ lhs, rhs = latex_eq.split('=')
+
+ # 使用 parse_latex 解析 LaTeX 表达式
+ lhs_expr = parse_latex(lhs)
+ rhs_expr = parse_latex(rhs)
+
+ # 创建等式对象
+ equation = Eq(lhs_expr, rhs_expr)
+
+ # 化简等式：将等式右边移到左边
+ simplified_eq = simplify(equation.lhs - equation.rhs)
+
+ return simplified_eq
+
+ expr1_sym = simplify_equation(expression1)
+ expr2_sym = simplify_equation(expression2)
+
+ division_result_1 = simplify(expr1_sym / expr2_sym)
+ division_result_2 = simplify(expr2_sym / expr1_sym)
+
+ # 如果两个方程转换后的式子相除为整数 且非零，则根据推导可知这两个方程等价
+ if (division_result_1.is_Integer and division_result_1 != 0) or (
+ division_result_2.is_Integer and division_result_2 != 0):
+ return True
+ else:
+ return False
+
+ def interval_equal(self, expression1, expression2):
+ # 函数: 判断两个区间是否在数学意义上等价
+ # 步骤1: 简化区间的表达式, 去除无关的符号比如"\left", "\right", 同时将可能出现的"x \in"删去
+ # 步骤2: 对比两个区间的左右符号、中间出现的数学表达式等是否一致
+
+ def compare_two_interval(inter1, inter2):
+
+ # 首先比较两边的括号是否一致，一致的话再进行下一步比较
+ if inter1[0] != inter2[0] or inter1[-1] != inter2[-1]:
+ return False
+
+ inter1 = inter1.strip('[]()')
+ inter2 = inter2.strip('[]()')
+
+ # 分割区间的左右部分
+ items_1 = inter1.split(',')
+ items_2 = inter2.split(',')
+
+ for item_1, item_2 in zip(items_1, items_2):
+ if not self.expression_equal(item_1, item_2):
+ return False
+ return True
+
+ interval1 = expression1
+ interval2 = expression2
+
+ if interval1 == interval2:
+ return True
+ else:
+ inter_list1 = interval1.split("\\cup")
+ inter_list2 = interval2.split("\\cup")
+
+ if len(inter_list1) != len(inter_list2):
+ return False
+ else:
+ for inter1, inter2 in zip(inter_list1, inter_list2):
+ if not compare_two_interval(inter1, inter2):
+ return False
+ return True
+
+ def preprocess(self, expression1, expression2):
+
+ # 尝试捕获box中的内容，如果有多个则以逗号相连返回，如果一个都没有，则报错
+ def extract_boxed_content(latex_str):
+ # 查找所有的 \boxed{...} 结构
+ boxed_matches = re.finditer(r'\\boxed{', latex_str)
+ results = ""
+
+ for match in boxed_matches:
+ start_index = match.end()
+ end_index = start_index
+ stack = 1
+
+ # 从 \boxed{ 之后开始搜索，直到找到对应的闭合括号
+ while stack > 0 and end_index < len(latex_str):
+ if latex_str[end_index] == '{':
+ stack += 1
+ elif latex_str[end_index] == '}':
+ stack -= 1
+ end_index += 1
+
+ if stack == 0:
+ # 提取 \boxed{} 内部的内容
+ content = latex_str[start_index:end_index - 1]
+ results += content + ","
+ else:
+ # 如果括号没有正确闭合，则返回错误信息
+ raise ValueError("Mismatched braces in LaTeX string.")
+
+ # 如果没有匹配到'\boxed{}'字符，则默认提取有内容的文字最后一行中的所有公式部分
+ if results == "":
+ last_line_ans = latex_str.strip().split("\n")[-1]
+ dollar_pattern = r"\$(.*?)\$"
+ answers = re.findall(dollar_pattern, last_line_ans)
+
+ if answers:
+ for ans in answers:
+ results += ans + ","
+ else:
+ results = latex_str
+
+ return results
+
+ def sepcial_symbol_replace(expression):
+ if "\\in " in expression:
+ expression = expression.split("\\in ")[1]
+
+ # 进行特殊字符的替换，这些字符都不影响latex的解析，属于美观/修饰性字符
+ for signal in self.special_signal_map:
+ expression = expression.replace(signal, self.special_signal_map[signal])
+
+ expression = expression.strip("\n$,.:;^_=+`!@#$%^&*~，。")
+
+ pattern = r'\\(?:mathrm|mathbf)\{~?([^}]*)\}'
+ expression = re.sub(pattern, r'\1', expression)
+
+ return expression
+
+ exp1, exp2 = extract_boxed_content(expression1), extract_boxed_content(expression2)
+ exp1, exp2 = sepcial_symbol_replace(exp1), sepcial_symbol_replace(exp2)
+
+ return exp1, exp2
+
+ def can_compute_power(self, expr):
+ """
+ Check if the power expression can be computed.
+
+ Parameters:
+ expr (sympy expression): The expression to check.
+
+ Returns:
+ bool: True if the expression can be computed, False otherwise.
+ """
+ # Check if the expression is a power expression
+ if isinstance(expr, Pow):
+ # Extract the base and the exponent
+ base, exp = expr.as_base_exp()
+
+ # Check if the base and the exponent are numbers
+ if base.is_number and exp.is_number:
+ # Set a threshold for the maximum size of the exponent
+ MAX_EXP = 1000 # This threshold can be adjusted based on the computing environment
+
+ # Check if the exponent is greater than the threshold
+ if abs(exp.evalf()) > MAX_EXP:
+ return False
+ else:
+ return True
+ else:
+ # If the base or the exponent is not a number, we cannot compute the power
+ return False
+ else:
+ # If the expression is not a power expression, return True as it is not the case we are checking for
+ return True
+
+
+def extract_answer(is_chinese, model_output, is_deepseek=False):
+ # deepseekmath has special answering format
+ if str(model_output) == 'nan':
+ model_output = 'nan'
+
+ if is_deepseek:
+ if is_chinese:
+ matches = re.findall('## 解题答案(.*)', model_output)
+ else:
+ matches = re.findall('The answer is: (.*)', model_output)
+
+ # 检测是否至少找到一个匹配，如果没有就直接整个送进去找\boxed{}
+ if matches:
+ # 如果找到多个匹配，取最后一个
+ model_answer = matches[-1].strip()
+ return model_answer
+ else:
+ return model_output
+
+ if is_chinese:
+ matches = re.findall('所以最终答案是(.*)', model_output)
+ else:
+ matches = re.findall('So the final answer is (.*)', model_output)
+
+ # 检测是否至少找到一个匹配，如果没有就直接整个送进去找\boxed{}
+ if matches:
+ # 如果找到多个匹配，取最后一个
+ model_answer = matches[-1].strip()
+ return model_answer
+ else:
+ return model_output
+
+
+def calculate_merged_accuracy(reference_dir, text_only):
+ pass
diff --git a/vlmeval/dataset/utils/qbench_video.py b/vlmeval/dataset/utils/qbench_video.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c6a8cc691da64d44de493018491d99c6e2ed147
--- /dev/null
+++ b/vlmeval/dataset/utils/qbench_video.py
@@ -0,0 +1,47 @@
+from ...smp import *
+from .multiple_choice import extract_answer_from_item
+from PIL import Image, ImageOps
+import numpy as np
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+VQA_JUDGE_SYS_PROMPT = """
+You are a helpful assistant that grades answers related to visual video quality.
+There are a lot of special terms or keywords related to video processing and photography.
+You will pay attention to the context of `quality evaluation' when grading.
+"""
+
+VQA_JUDGE_USER_PROMPT = """
+Given the question {}, evaluate whether the response {} completely matches the correct answer {}.
+First, check the response and please rate score 0 if the response is not a valid answer.
+Please rate score 2 if the response completely or almost completely matches the correct answer on completeness, accuracy, and relevance.
+Please rate score 1 if the response partly matches the correct answer on completeness, accuracy, and relevance.
+Please rate score 0 if the response doesn't match the correct answer on completeness, accuracy, and relevance at all.
+Please only provide the result in the following format: Score:'
+"""
+
+
+def check_ans_mcq(pred, ans, correct_choice, correct_answer):
+ flag = False
+
+ if correct_choice == pred or correct_choice+"." in pred or correct_answer == pred:
+ flag = True
+ elif correct_choice in pred.split("\n"):
+ flag = True
+
+ return flag
+
+def check_ans_vqa(model, line):
+ score = model.generate(VQA_JUDGE_USER_PROMPT.format(line['question'], line['prediction'], line['answer'])).strip()
+ return score
+
+def get_dimension_rating(score_file):
+ score = load(score_file)
+ result_dict = {}
+ for idx, item in score.iterrows():
+ question_type = eval(item['dimensions'])[0].split(',')[0]
+ if question_type not in result_dict:
+ result_dict[question_type] = [0, 0]
+ result_dict[question_type][0] += int(item['score'])
+ result_dict[question_type][1] += 1
+ return result_dict
\ No newline at end of file
diff --git a/vlmeval/dataset/utils/qspatial.py b/vlmeval/dataset/utils/qspatial.py
new file mode 100644
index 0000000000000000000000000000000000000000..97d4125797da5c7af7a7e29806c5ff5d4e074967
--- /dev/null
+++ b/vlmeval/dataset/utils/qspatial.py
@@ -0,0 +1,123 @@
+from ...smp import *
+from ...utils import can_infer
+
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+def get_gpt4_ICE_for_qspatial():
+ example_1 = """
+Hint: Please answer the question requiring in a tuple format. The tuple should contain a numeric value and a unit,
+e.g., (1, m), (2.2, cm), (3.12, meter), at the end.\n
+Model response: **Object Identification**
+
+* The object in question is a chair.
+* The chair is not visible in the image.
+
+**Conclusion**
+
+The height of the chair cannot be determined from the provided image.\n
+Extracted answer: (0, cm)
+"""
+
+ example_2 = """
+Hint: Please answer the question requiring in a tuple format. The tuple should contain a numeric value and a unit,
+e.g., (1, inch), (1.2, cm), (3.0, feet), at the end.\n
+Model response: **Step 1: Identify the stapler and the recycle bin in the image.**
+
+The stapler is located on the wooden table, and the recycle bin is located on the floor.
+
+**Step 2: Determine the distance between the stapler and the recycle bin.**
+
+The stapler is 0.5 meters from the edge of the table, and the recycle bin is 1.5 meters from the edge of the table.
+Therefore, the minimum distance between the stapler and the recycle bin is 1.5 - 0.5 = 1 meter.
+
+**Answer:** 1 m\n
+Extracted answer: (1, m)
+"""
+ example_3 = """
+Hint: Please answer the question requiring in a tuple format. The tuple should contain a numeric value and a unit,
+e.g., (1, foot), (2, cm), (4.3, meter), at the end.\n
+Model response: The mirror in the image is approximately 5 feet 4 inches tall.\n
+Extracted answer: (64, inch)
+"""
+ example_4 = """
+Hint: Please answer the question requiring in a tuple format. The tuple should contain a numeric value and a unit,
+e.g., (0.1, cm), (2.9, cm), (0.3, meter), at the end.\n
+Model response: The minimum distance between the wooden chair and the chair near the camera in the image is 1.7 feet.\n
+Extracted answer: (1.7, feet)
+"""
+ example_5 = """
+Hint: Please answer the question requiring in a tuple format. The tuple should contain a numeric value and a unit,
+e.g., (5.1, cm), (0.9, cm), (55, mm), at the end.\n
+Model response: The height of the painting's bottom edge from the floor is approximately 4.5 feet.\n
+Extracted answer: (4.5, feet)
+"""
+ return [example_1, example_2, example_3, example_4, example_5]
+
+
+def list_to_dict(lst):
+ return {chr(65 + i): val for i, val in enumerate(lst)}
+
+
+def post_check(line, prefetch=False):
+ res = None
+ ans = line['answer']
+ response = line['prediction'] if prefetch else line['res']
+ try:
+ if line['question_type'] == 'multi_choice':
+ ans = line['answer_option']
+ choices = list_to_dict(eval(line['choices']))
+ res = can_infer(response, choices)
+ if prefetch:
+ return res
+ else:
+ if line['answer_type'] == 'integer':
+ res = int(response)
+ ans = int(line['answer'])
+ elif line['answer_type'] == 'float':
+ res = float(response)
+ ans = float(line['answer'])
+ else:
+ res = str(res)
+ ans = str(ans)
+ except ValueError:
+ pass
+
+ if res == ans:
+ return res if prefetch else True
+ else:
+ return False
+
+
+def build_qspatial_gpt4_prompt(line):
+ task_description = """
+Please read the following example.
+Then extract the answer from the model response and type it at the end of the prompt.\n
+"""
+ prediction = str(line['prediction'])
+ prompt = task_description
+ examples = get_gpt4_ICE_for_qspatial()
+ for example in examples:
+ prompt += example + '\n'
+ prompt += 'Model respone: ' + prediction
+ prompt += '\nExtracted answer:'
+ return prompt
+
+
+def QSpatial_auxeval(model, line):
+ prompt = build_qspatial_gpt4_prompt(line)
+
+ log = ''
+ retry = 5
+ for i in range(retry):
+ prediction = line['prediction']
+ res = model.generate(prompt, temperature=i * 0.5)
+
+ if FAIL_MSG in res:
+ log += f'Try {i}: output is {prediction}, failed to parse.\n'
+ else:
+ log += 'Succeed'
+ return dict(log=log, res=res)
+ log += 'All 5 retries failed.\n'
+ return dict(log=log, res='')
diff --git a/vlmeval/dataset/utils/reasoning.py b/vlmeval/dataset/utils/reasoning.py
new file mode 100644
index 0000000000000000000000000000000000000000..75ec788ec41dcd53853d1569841eaabf7478a916
--- /dev/null
+++ b/vlmeval/dataset/utils/reasoning.py
@@ -0,0 +1,9 @@
+def extract_answer(pred: str) -> str:
+ start_tag = ""
+ end_tag = " "
+ last_start_index = pred.rfind(start_tag)
+ last_end_index = pred.rfind(end_tag)
+ if last_start_index == -1 or last_end_index == -1 or last_start_index > last_end_index:
+ return pred
+ else:
+ return pred[last_start_index + len(start_tag):last_end_index].strip()
\ No newline at end of file
diff --git a/vlmeval/dataset/utils/shortqa.py b/vlmeval/dataset/utils/shortqa.py
new file mode 100644
index 0000000000000000000000000000000000000000..55c63d69d380b9c53c918243cb63ecdbf3b8e93e
--- /dev/null
+++ b/vlmeval/dataset/utils/shortqa.py
@@ -0,0 +1,274 @@
+from vlmeval.smp import *
+
+
+EVAL_TMPL = """
+You are an AI assistant tasked with evaluating whether a model's response correctly answers a given visual-language question.
+
+You will be provided with:
+1. The question (text only)
+2. The model's response
+3. The ground truth answer
+
+Your task is to determine whether the model's response conveys the same meaning as the ground truth. The response is considered **correct** if:
+- It has the same meaning as the ground truth, even if phrased differently.
+- It provides additional relevant details without altering the original meaning.
+
+The response is considered **wrong** if:
+- It contradicts the ground-truth
+- It misses essential information or include additional incorrect information.
+
+Your evaluation should include the following fields:
+- **Correctness**: Either `"yes"` (if correct) or `"no"` (if incorrect).
+- **Reason**: A brief explanation of your judgment.
+
+{requirement}
+
+Here are some examples:
+{examples}
+
+Now please complete the following task:
+
+[Begin Question]{question}[End Question]
+[Begin Ground-Truth]{ground_truth}[End Ground-Truth]
+[Begin Response]{response}[End Response]
+"""
+
+EVAL_TMPL_CN = """
+你是一名 AI 助理，负责评估模型的回答是否正确回答了给定的视觉语言问题。
+
+你将被提供以下信息：
+1. 问题（仅包含文本）
+2. 模型的回答
+3. 标准答案（Ground Truth）
+
+你的任务是判断模型的回答是否与标准答案表达相同的含义。若满足以下条件，则认为回答是**正确的**：
+- 回答的含义与标准答案相同，即使措辞不同。
+- 回答提供了额外的相关细节，但没有改变原本的含义。
+
+若满足以下条件，则认为回答是**错误的**：
+- 回答与标准答案相矛盾。
+- 回答遗漏了关键信息，或包含额外的错误信息。
+
+你的评估应包含以下字段：
+- **正确性（Correctness）**：值应为 `"yes"`（正确）或 `"no"`（错误）。
+- **原因（Reason）**：对你的判断进行简要解释。
+
+{requirement}
+
+以下是一些示例：
+{examples}
+
+现在，请完成以下任务：
+[Begin Question]{question}[End Question]
+[Begin Ground-Truth]{ground_truth}[End Ground-Truth]
+[Begin Response]{response}[End Response]
+"""
+
+en_single_ICEs = [
+ {
+ 'question': 'Please tell me the name of the man in this image, in the format of "[First Name] [Given Name]".',
+ 'answer': 'Franklin D. Roosevelt',
+ 'prediction': 'Franklin Roosevelt',
+ 'correctness': "yes",
+ 'reason': 'The model response basically align with the ground-truth answer, just omitted the middle name. Thus the response is correct.'
+ },
+ {
+ 'question': 'Please tell me the name of the man in this image, in the format of "[First Name] [Given Name]".',
+ 'answer': 'Usain Bolt',
+ 'prediction': 'Bolt',
+ 'correctness': 'no',
+ 'reason': 'The question asks the model to output the '
+ },
+ {
+ 'question': 'Where did the text in this image originate from',
+ 'answer': 'Ancient Egypt',
+ 'prediction': 'egypt',
+ 'correctness': 'yes',
+ 'reason': 'The model response basically align with the ground-truth answer (egypt vs. Ancient Egypt). Thus the response is correct. '
+ },
+ {
+ 'question': 'Name this building',
+ 'answer': "St. Peter's Basilica Church",
+ 'prediction': 'st peters basilica',
+ 'correctness': 'yes',
+ 'reason': "The model response basically align with the ground-truth answer. Thus the response is correct."
+ },
+ {
+ 'question': 'Extract the text on the umbrella in the image',
+ 'answer': 'keter',
+ 'prediction': 'ketter',
+ 'correctness': 'no',
+ 'reason': 'The question requires the model to exactly extract the text on the umbrella. The model response does not contain the exact text on the umbrella (keter). Thus the response is incorrect. '
+ }
+]
+
+en_multiple_ICEs = [
+ {
+ 'question': 'Please tell me the name of the man in this image, in the format of "[First Name] [Given Name]".',
+ 'answer': 'Franklin D. Roosevelt',
+ 'prediction': 'Franklin Roosevelt',
+ 'correctness': "yes",
+ 'reason': 'The model response basically align with the ground-truth answer, just omitted the middle name. Thus the response is correct.'
+ },
+ {
+ 'question': 'Please tell me the name of the man in this image, in the format of "[First Name] [Given Name]".',
+ 'answer': 'Usain Bolt',
+ 'prediction': 'Bolt',
+ 'correctness': 'no',
+ 'reason': 'The question asks the model to output the '
+ },
+ {
+ 'question': 'Name all countries besides this lake',
+ 'answer': "['Jordan', 'Israel', 'Palestine']",
+ 'prediction': "Israel, Jordan",
+ 'correctness': 'no',
+ 'reason': 'The model response does not contain all the countries besides this lake (missing Palestine). Thus the response is incorrect.'
+ },
+ {
+ 'question': 'Name this building, as well as the country that the building located in.',
+ 'answer': "['La Tour Eiffel (or Eiffel Tower)', 'France']",
+ 'prediction': "Eiffel Tower, France",
+ 'correctness': 'yes',
+ 'reason': 'The model response basically align with the ground-truth answer. Thus the response is correct.'
+ },
+ {
+ 'question': 'Name this attraction, as well as the country that this attraction located in. ',
+ 'answer': "['Notre Dame de Paris', 'France']",
+ 'prediction': "Notre-Dame Cathedral, France",
+ 'correctness': 'yes',
+ 'reason': 'The model response basically align with the ground-truth answer. Thus the response is correct.'
+ },
+ {
+ 'question': "Who are the top three players in terms of goals scored for these teams' Top Team Scorers?",
+ 'answer': "['Mohamed Salah','Erling Haaland','Alexander Isak']",
+ 'prediction': "The top three players in terms of goals scored for these teams' Top Team Scorers are: 1. Mohamed Salah - 19 goals (Liverpool) 2. Erling Haaland - 18 goals (Manchester City) 3. Alexander Isak - 17 goals (Newcastle Utd)",
+ 'correctness': 'yes',
+ 'reason': 'The model response align with the ground-truth answer, and include some additional information including the team and number of goals of the player. Thus the response is correct.'
+ }
+]
+
+cn_single_ICEs = [
+ {
+ 'question': '请直接告诉我图中右侧人物的名字',
+ 'answer': '姚明',
+ 'prediction': 'Yao Ming',
+ 'correctness': 'yes',
+ 'reason': '回答中用英语提及了人物的名称 Yao Ming，因此回答正确。'
+ },
+ {
+ 'question': '图中右起第几位女士的身高最高？',
+ 'answer': '右起第一位',
+ 'prediction': '1',
+ 'correctness': 'yes',
+ 'reason': '回答中提及了第一位 (依据提问，默认为右起)，因此回答正确。'
+ },
+ {
+ 'question': '图中文物的具体名称是什么？',
+ 'answer': '司母戊鼎',
+ 'prediction': '鼎',
+ 'correctness': 'no',
+ 'reason': '问题询问文物的具体名称，回答仅提及了鼎，但未提及司母戊鼎，因此回答错误。'
+ },
+ {
+ 'question': '图中的景点位于哪个省份？',
+ 'answer': '四川',
+ 'prediction': '图中的景点是九寨沟，位于中国四川省阿坝藏族羌族自治州。',
+ 'correctness': 'yes',
+ 'reason': '回答提及景点位于四川省，与标准答案一致，且更加详尽，因此回答正确'
+ }
+]
+
+cn_multiple_ICEs = [
+ {
+ 'question': '图中文物的具体名称是什么？',
+ 'answer': '司母戊鼎',
+ 'prediction': '鼎',
+ 'correctness': 'no',
+ 'reason': '问题询问文物的具体名称，回答仅提及了鼎，但未提及司母戊鼎，因此回答错误。'
+ },
+ {
+ 'question': 'JiaQi在2025年与哪些战队交过手？',
+ 'answer': "['Ninjas in Pyjamas','Invictus Gaming']",
+ 'prediction': "根据提供的图片信息，JiaQi在2025年与以下战队交过手：\n- TES Challenger\n- Ninjas in Pyjamas\n- Invictus Gaming",
+ 'correctness': 'no',
+ 'reason': "依据问题与标准答案，JiaQi 在 2025 年应仅与 Ninjas in Pyjamas 与 Invictus Gaming 两支战队交过手。模型回复中，TES Challenger 未在标准答案中提及，因此回答错误。"
+ },
+ {
+ 'question': '根据图中内容，请列出全部在 2022年7月份到10月份间的开源模型？',
+ 'answer': "['CodeGeeX','GLM','Flan-T5','NLLB']",
+ 'prediction': "根据图中内容，2022年7月份到10月份间的开源模型有：Tk-Instruct, Luminous, GLM, NLLB",
+ 'correctness': 'no',
+ 'reason': "根据问题与标准答案，2022年7月份到10月份间的开源模型有 CodeGeeX, GLM, Flan-T5, NLLB。模型回复中，Tk-Instruct 与 Luminous 未在标准答案中提及，且遗漏了 cODEGeeX 与 Flan-T5，因此回答错误。"
+ },
+ {
+ 'question': '图中的景点是什么，位于哪个城市',
+ 'answer': "['少林寺', '河南登封市']",
+ 'prediction': "The scenic spot in the picture is Shaolin Temple, located in Dengfeng City, Henan Province.",
+ 'correctness': 'yes',
+ 'reason': "答案中提及了少林寺及河南省登封市，因此回答正确"
+ },
+ {
+ 'question': '图中中央的物品是什么，它最流行于中国的南方还是北方？',
+ 'answer': "['铜火锅', '北方']",
+ 'prediction': '图中中央的物品是火锅，它最流行于中国的北方。',
+ 'correctness': "yes",
+ "reason": "回答中提及了火锅及北方，因此回答正确。"
+ },
+ {
+ 'question': '请直接告诉我图中右侧人物的名字',
+ 'answer': "['姚明', '易建联']",
+ 'prediction': 'Yao Ming & Jianlian Yi',
+ 'correctness': 'yes',
+ 'reason': '回答中用英语提及了姚明与易建联的名字，与标准答案一致，因此回答正确。'
+ },
+]
+
+
+def ICE_builder(ICEs):
+ res = ''
+ for i, eg in enumerate(ICEs):
+ res += f"Example {i+1}:\n"
+ res += "[Begin Question]" + eg['question'] + "[End Question]\n"
+ res += "[Begin Ground-Truth]" + eg['answer'] + "[End Ground-Truth]\n"
+ res += "[Begin Response]" + eg['prediction'] + "[End Response]\n"
+ res += "[Begin Correctness]" + eg['correctness'] + "[End Correctness]\n"
+ res += "[Begin Reason]" + eg['reason'] + "[End Reason]\n"
+ res += '\n'
+ return res
+
+
+def ShortQA_prompt(line):
+ question = line['question']
+ is_cn = cn_string(question)
+ answer = line['answer']
+ if answer[0] == '[' and answer[-1] == ']':
+ answer = eval(answer)
+ else:
+ answer = [answer]
+
+ requirements = {
+ 'en_multi': "The provided ground-truth is a list. The answer is correct if the model response contains and only contains all contents in the list (no other answer included)",
+ 'cn_multi': "题目提供的标准答案是一个列表。如果模型回答包含且仅包含列表中的所有内容，则回答正确",
+ }
+
+ examples = ''
+ if is_cn:
+ examples = ICE_builder(cn_single_ICEs if len(answer) == 1 else cn_multiple_ICEs)
+ else:
+ examples = ICE_builder(en_single_ICEs if len(answer) == 1 else en_multiple_ICEs)
+
+ if len(answer) > 1:
+ requirement = requirements['en_multi'] if not is_cn else requirements['cn_multi']
+ else:
+ requirement = ''
+ answer = answer[0]
+
+ tmpl = EVAL_TMPL_CN if is_cn else EVAL_TMPL
+ prompt = tmpl.format(
+ question=question,
+ examples=examples,
+ requirement=requirement,
+ ground_truth=answer,
+ response=line['prediction']
+ )
+ return prompt
diff --git a/vlmeval/dataset/utils/tablevqabench.py b/vlmeval/dataset/utils/tablevqabench.py
new file mode 100644
index 0000000000000000000000000000000000000000..0782f55a9852ee92805bea4e6b37ac56927f29d9
--- /dev/null
+++ b/vlmeval/dataset/utils/tablevqabench.py
@@ -0,0 +1,500 @@
+"""
+Copied from https://github.com/allenai/allennlp-semparse
+Modified from https://github.com/naver-ai/tablevqabench
+"""
+
+import re
+import unicodedata
+import time
+
+from abc import ABCMeta, abstractmethod
+from math import isinf, isnan
+
+
+# Vision Prompts
+VWTQ_PROMPT = (
+ 'You are asked to answer questions asked on an image.\n'
+ 'You should answer the question with a single word.\n'
+ 'Example: \n'
+ 'Question: what was the only year mr. wu competed in the olympic games?\n'
+ 'Answer: 2004\n'
+ 'Question: which township in pope county, arkansas has the least amount of water area?\n'
+ 'Answer: Freeman\n'
+ 'If you have multiple answers, please separate them with || marks. Example: Apple||Banana||Tomato\n\n'
+ 'Question: {question}\n'
+ 'Answer:'
+)
+
+VTABFACT_PROMPT = (
+ 'You are asked to answer whether the statement is True or False based on given image\n'
+ 'You should only answer True or False.\n'
+ 'Example: \n'
+ 'Statement: the milwaukee buck win 6 game in the 2010 - 11 season\n'
+ 'Answer: True\n'
+ 'Statement: only the top team score above the average of 8.8\n'
+ 'Answer: False\n\n'
+ 'Statement: {question}\n'
+ 'Answer:'
+)
+
+FINTABNETQA_PROMPT = (
+ 'You are asked to answer questions asked on a image.\n'
+ 'You should answer the question within a single word or few words.\n'
+ 'If units can be known, the answer should include units such as $, %, million and etc.\n'
+ 'Example: \n'
+ 'Question: What were the total financing originations for the fiscal year ended October 31, 2004?\n'
+ 'Answer: $3,852 million\n'
+ 'Question: What is the time period represented in the table?\n'
+ 'Answer: October 31\n'
+ 'Question: What was the percentage of net sales for selling, general and administrative expenses in 2006?\n'
+ 'Answer: 34.2%\n'
+ 'Question: {question}\n'
+ 'Answer:'
+)
+
+
+def evaluate_tabfact(data, score_keys):
+ num_examples = 0
+ num_correct = 0
+ manual_check = 0
+ start_time = time.time()
+ for instance in data:
+ if instance['prediction'] is None:
+ instance['prediction'] = 'none'
+ pred = instance['prediction'].lower()
+ gt = instance['answer']
+ num_examples += 1
+ if 'true' in pred and 'false' in pred:
+ manual_check += 1
+ score = None
+ elif 'true' in pred and gt == '1':
+ num_correct += 1
+ score = 1
+ elif 'false' in pred and gt == '0':
+ num_correct += 1
+ score = 1
+ else:
+ score = 0
+ instance['scores'] = {score_keys[0]: score}
+ if manual_check > 0:
+ print(f'the number of not properly parsed samples: {manual_check}')
+ end_time = time.time()
+ elapsed_time = end_time - start_time
+ Accuracy = round((num_correct + 1e-9) / (num_examples + 1e-9), 8) * 100
+ meta = {
+ 'evaluators': 'correctness',
+ 'score_info': [score_keys[0]],
+ 'evaluated_time': elapsed_time,
+ 'total_num_sample': len(data),
+ 'average_scores': [Accuracy],
+ }
+ return meta
+
+
+def evaluate_wtq(data, score_keys):
+ num_examples = 0
+ num_correct = 0
+ start_time = time.time()
+
+ for instance in data:
+ pred = instance['prediction'].replace('||', '|')
+ gt = instance['answer']
+ original_strings = tsv_unescape_list(gt)
+ target_values = to_value_list(original_strings)
+
+ predicted_strings = tsv_unescape_list(pred)
+ predicted_values = to_value_list(predicted_strings)
+ correct = check_denotation(target_values, predicted_values)
+ num_examples += 1
+ score = 0
+ if correct:
+ num_correct += 1
+ score = 1
+ instance['scores'] = {score_keys[0]: score}
+
+ end_time = time.time()
+ elapsed_time = end_time - start_time
+
+ Accuracy = round((num_correct + 1e-9) / (num_examples + 1e-9), 8) * 100
+ meta = {
+ 'evaluators': 'correctness',
+ 'score_info': [score_keys[0]],
+ 'evaluated_time': elapsed_time,
+ 'total_num_sample': len(data),
+ 'average_scores': [Accuracy],
+ }
+ return meta
+
+
+def evaluate_fintabnet(data, score_keys):
+ num_examples = 0
+ num_correct, _num_correct = 0, 0
+ start_time = time.time()
+ for instance in data:
+ pred, preds = fintabnet_normalize(instance['prediction'])
+ gt, gts = fintabnet_normalize(instance['answer'])
+ correct = 1 if gt == pred else 0
+ _correct = any(_pred == _gt for _pred in preds for _gt in gts)
+ num_examples += 1
+ score, _score = 0, 0
+ if correct:
+ num_correct += 1
+ score = 1
+ if _correct:
+ _num_correct += 1
+ _score = 1
+ instance['scores'] = {score_keys[0]: _score, 'exact_score': score}
+
+ end_time = time.time()
+ elapsed_time = end_time - start_time
+ Accuracy = round((num_correct + 1e-9) / (num_examples + 1e-9), 8) * 100
+ _Accuracy = round((_num_correct + 1e-9) / (num_examples + 1e-9), 8) * 100
+ meta = {
+ 'evaluators': 'correctness',
+ 'score_info': ['relieved_accuracy', score_keys[0]],
+ 'evaluated_time': elapsed_time,
+ 'total_num_sample': len(data),
+ 'average_scores': [_Accuracy, Accuracy],
+ }
+ return meta
+
+
+def fintabnet_normalize(s):
+ s = normalize(s)
+ remove_words = [
+ 'dollar', 'gallons', 'square feet', 'shares', 'mbtu',
+ 'mbpd', 'mbbls', 'mmbtu', 'unit', 'gwh', 'year', 'mmcf', 'mile', 'mboe'
+ ]
+
+ # Data specific filtering using regular expressions
+ # Remove special characters like $, (, and )
+ s = re.sub(r'[\$\(\),]', '', s)
+
+ # Replace "dollar" with empty string if it's not part of another word
+ pattern = r'\b(' + '|'.join(remove_words) + r')s?\b'
+ s = re.sub(pattern, '', s, flags=re.IGNORECASE)
+
+ # Unit conversion dictionary with regex patterns for flexibility
+ unit_conversion = {
+ r' \bthousand\b': 'e3',
+ r' \bmillion\b': 'e6',
+ r' \bbillion\b': 'e9',
+ r'\bthousand\b': 'e3',
+ r'\bmillion\b': 'e6',
+ r'\bbillion\b': 'e9',
+ r' ?%': 'e-2',
+ }
+
+ # Convert percentages to their decimal representation.
+ # Applying this after unit_conversion prevents "percent" from being processed
+ # in cases like "million %", which would be incorrect.
+ # s = re.sub(r' ?%', 'e-2', s)
+ # s_percent = re.sub(r' ?%', '', s_percent)
+
+ s_unit_free = s
+
+ # Iterate over unit_conversion and apply transformations
+ for pattern, value in unit_conversion.items():
+ s = re.sub(pattern, value, s)
+ s_unit_free = re.sub(pattern, '', s_unit_free)
+
+ # Attempt to convert to float
+ try:
+ return float(s), [float(s), float(s_unit_free)]
+ except ValueError:
+ # Return the original string and the error for debugging purposes
+ return s, [s, s_unit_free]
+
+
+def normalize(x):
+ if not isinstance(x, str):
+ x = x.decode('utf8', errors='ignore')
+ # Remove diacritics
+ x = ''.join(
+ c for c in unicodedata.normalize('NFKD', x) if unicodedata.category(c) != 'Mn'
+ )
+ # Normalize quotes and dashes
+ x = re.sub(r'[‘’´`]', "'", x)
+ x = re.sub(r'[“”]', '"', x)
+ x = re.sub(r'[‐‑‒–—−]', '-', x)
+ while True:
+ old_x = x
+ # Remove citations
+ x = re.sub(r'((? backslash + n
+ vertical bar (0x7C) -> backslash + p
+ backslash (0x5C) -> backslash + backslash
+
+ Args:
+ x (str or unicode)
+ Returns:
+ a unicode
+ """
+ return x.replace(r'\n', '\n').replace(r'\p', '|').replace('\\\\', '\\')
+
+
+def tsv_unescape_list(x):
+ """Unescape a list in the TSV file.
+ List items are joined with vertical bars (0x5C)
+
+ Args:
+ x (str or unicode)
+ Returns:
+ a list of unicodes
+ """
+ return [tsv_unescape(y) for y in x.split('|')]
diff --git a/vlmeval/dataset/utils/tamperbench.py b/vlmeval/dataset/utils/tamperbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..1194642a6407281c558891fe369782038d192e2d
--- /dev/null
+++ b/vlmeval/dataset/utils/tamperbench.py
@@ -0,0 +1,737 @@
+from ...smp import *
+from .multiple_choice import extract_answer_from_item
+from PIL import Image, ImageOps
+import torchvision
+import random
+import numbers
+import math
+import torch
+import json
+import pandas as pd
+
+
+import numpy as np
+import re
+
+
+def get_dimension_rating(data_path, category_type='task_type'):
+ data = load(data_path)
+ result_board = {}
+ for idx, item in data.iterrows():
+ if item[category_type] not in result_board:
+ result_board[item[category_type]] = [0, 0]
+ result_board[item[category_type]][1] += 1
+ if item['score']:
+ result_board[item[category_type]][0] += 1
+
+ correct = 0
+ total = 0
+ for key, value in result_board.items():
+ correct += value[0]
+ total += value[1]
+ result_board[key].append(f'{value[0] / value[1] * 100:.2f}%')
+
+ result_board['overall'] = [correct, total, f'{correct / total * 100:.2f}%']
+
+ return result_board
+
+
+def process_results(score_file,model_name):
+ from sklearn.metrics import (
+ accuracy_score,
+ precision_score,
+ recall_score,
+ f1_score,
+ classification_report,
+ confusion_matrix,
+ roc_auc_score
+ )
+ data = pd.read_excel(score_file)
+
+ # Create the prediction column based on the Score and Answer columns
+ data['prediction'] = data.apply(
+ lambda row: row['answer'] if row['score'] == 1 else ('Yes' if row['answer'] == 'No' else 'No'), axis=1
+ )
+
+ # Recompute metrics for tamper types including 'original' in the calculations but exclude 'original' from the output
+ grouped_metrics_with_original_excluding_original = {}
+
+ original_group = data[data['tamper_type'] == 'original']
+
+ for tamper_type, group in data[data['tamper_type'] != 'original'].groupby('tamper_type'):
+ # Combine the current group with the 'original' group
+ combined_group = pd.concat([group, original_group])
+
+ # Extract ground truth and predictions for the combined group
+ y_true_group = combined_group['answer'].map({'Yes': 1, 'No': 0})
+ y_pred_group = combined_group['prediction'].map({'Yes': 1, 'No': 0})
+
+ # Calculate metrics for the combined group
+ accuracy = accuracy_score(y_true_group, y_pred_group)
+ precision = precision_score(y_true_group, y_pred_group, zero_division=0)
+ recall = recall_score(y_true_group, y_pred_group, zero_division=0)
+ f1 = f1_score(y_true_group, y_pred_group, zero_division=0)
+ conf_matrix = confusion_matrix(y_true_group, y_pred_group)
+
+ # Store metrics for the tamper_type
+ grouped_metrics_with_original_excluding_original[tamper_type] = {
+ "Accuracy": accuracy,
+ "Precision": precision,
+ "Recall": recall,
+ "F1 Score": f1,
+ "Confusion Matrix": conf_matrix.tolist() # Convert to list for JSON compatibility
+ }
+
+ # Add the Macro Average row to the Dictionary
+ # grouped_metrics_with_original_excluding_original["overall"] = macro_averages
+
+ # Display the metrics in a dataframe for clarity
+ df_grouped_metrics_with_original_excluding_original = pd.DataFrame.from_dict(
+ grouped_metrics_with_original_excluding_original, orient='index'
+ )
+
+ # Compute Macro Averages for Accuracy, Precision, Recall, and F1 Score
+ macro_averages = {
+ "Accuracy": df_grouped_metrics_with_original_excluding_original["Accuracy"].mean(),
+ "Precision": df_grouped_metrics_with_original_excluding_original["Precision"].mean(),
+ "Recall": df_grouped_metrics_with_original_excluding_original["Recall"].mean(),
+ "F1 Score": df_grouped_metrics_with_original_excluding_original["F1 Score"].mean(),
+ "Confusion Matrix": "N/A" # Macro average doesn't have a meaningful confusion matrix
+ }
+
+ # # Add the Macro Average row to the DataFrame
+ df_grouped_metrics_with_original_excluding_original.loc["overall"] = macro_averages
+
+ # df_grouped_metrics_with_original_excluding_original
+ metrics_dict = json.loads(df_grouped_metrics_with_original_excluding_original.T.to_json())
+ # Process Model Level Metrics
+ formatted_data = []
+ for task, task_metrics in metrics_dict.items():
+ task_metrics['Model'] = model_name
+ task_metrics['Task'] = task
+ formatted_data.append(task_metrics)
+
+ df_metrics = pd.DataFrame(formatted_data)
+
+ # Reorder columns to make 'Model' and 'Task' appear first
+ columns_order = ['Model', 'Task'] + [col for col in df_metrics.columns if col not in ['Model', 'Task']]
+ df_metrics = df_metrics[columns_order]
+
+ return df_metrics
+
+
+def aggregate_metrics_with_macro_average(score_file):
+ from sklearn.metrics import (
+ accuracy_score,
+ precision_score,
+ recall_score,
+ f1_score,
+ classification_report,
+ confusion_matrix,
+ roc_auc_score
+ )
+ # Load data
+ data = pd.read_excel(score_file)
+
+ # Create the prediction column based on the Score and Answer columns
+ data['prediction'] = data.apply(
+ lambda row: row['answer'] if row['score'] == 1 else ('Yes' if row['answer'] == 'No' else 'No'), axis=1
+ )
+
+ # Initialize a dictionary to store metrics
+ task_type_metrics = {}
+
+ # Process each task_type separately
+ for task_type, task_group in data.groupby('task_type'):
+ # Separate the 'original' group for the current task_type
+ original_group = task_group[task_group['tamper_type'] == 'original']
+
+ # Skip if there is no 'original' data for this task_type
+ if original_group.empty:
+ continue
+
+ # Process each tamper type for the current task_type (excluding 'original')
+ tamper_metrics = {}
+ for tamper_type, tamper_group in task_group[task_group['tamper_type'] != 'original'].groupby('tamper_type'):
+
+ # Combine the tamper group with the original group of the current task_type
+ combined_group = pd.concat([tamper_group, original_group])
+
+ # Map answers and predictions to binary values
+ y_true = combined_group['answer'].map({'Yes': 1, 'No': 0})
+ y_pred = combined_group['prediction'].map({'Yes': 1, 'No': 0})
+
+ # Compute metrics
+ accuracy = accuracy_score(y_true, y_pred)
+ precision = precision_score(y_true, y_pred, zero_division=0)
+ recall = recall_score(y_true, y_pred, zero_division=0)
+ f1 = f1_score(y_true, y_pred, zero_division=0)
+ conf_matrix = confusion_matrix(y_true, y_pred)
+
+ # Store metrics for the tamper_type
+ tamper_metrics[tamper_type] = {
+ "Accuracy": accuracy,
+ "Precision": precision,
+ "Recall": recall,
+ "F1 Score": f1,
+ "Confusion Matrix": conf_matrix.tolist() # Convert to list for JSON compatibility
+ }
+
+ # Compute Macro Averages for the current task_type
+ metrics_df = pd.DataFrame(tamper_metrics).T
+ macro_average = {
+ "Accuracy": metrics_df["Accuracy"].mean(),
+ "Precision": metrics_df["Precision"].mean(),
+ "Recall": metrics_df["Recall"].mean(),
+ "F1 Score": metrics_df["F1 Score"].mean(),
+ "Confusion Matrix": "N/A" # Macro average doesn't have a meaningful confusion matrix
+ }
+
+ # Add the macro average as "overall" for the task_type
+ tamper_metrics["overall"] = macro_average
+
+ # Add tamper metrics for the current task_type to the main dictionary
+ task_type_metrics[task_type] = tamper_metrics
+
+ # Transform the nested dictionary into a DataFrame
+ dataframes = []
+ for task_type, metrics in task_type_metrics.items():
+ task_df = pd.DataFrame.from_dict(metrics, orient='index')
+ task_df['task_type'] = task_type # Add the task_type as a column
+ dataframes.append(task_df)
+
+ # Combine all task-specific DataFrames into a single DataFrame
+ result_df = pd.concat(dataframes).reset_index().rename(columns={'index': 'tamper_type'})
+ # Reorder the columns to place task_type first, then tamper_type
+ result_df = result_df[['task_type', 'tamper_type', 'Accuracy', 'Precision', 'Recall',
+ 'F1 Score', 'Confusion Matrix']]
+
+ # Select only numeric columns for aggregation
+ numeric_columns = ['Accuracy', 'Precision', 'Recall', 'F1 Score']
+
+ # Group by task_type and tamper_type, and calculate the mean for numeric columns
+ average_metrics = result_df.groupby(['task_type', 'tamper_type'])[numeric_columns].mean().reset_index()
+
+ return average_metrics
+
+
+def check_ans(pred, gt):
+ """
+ Checks if the predicted answer matches the ground truth.
+
+ Args:
+ pred (str): The predicted answer.
+ gt (str): The ground truth answer.
+
+ Returns:
+ bool: True if the predicted answer matches the ground truth, False otherwise.
+ """
+ # Convert both predictions and ground truths to lowercase and split them into options and contents
+ flag = False
+
+ # Split prediction into option and content
+ pred_list = pred.lower().strip().split(' ')
+ pred_option, _ = pred_list[0], ' '.join(pred_list[1:])
+
+ # Split ground truth into option and content
+ gt_list = gt.lower().strip().split(' ')
+ gt_option, gt_content = gt_list[0], ' '.join(gt_list[1:])
+
+ # Remove trailing period from ground truth content if present
+ if gt_content[-1] == '.':
+ gt_content = gt_content[:-1]
+
+ # Check for matching conditions
+ # Condition 1: If the predicted option is a substring of the ground truth option
+ if pred_option.replace('.', '') in gt_option:
+ flag = True
+ # Condition 2: If the ground truth option is a substring of the predicted option
+ elif gt_option in pred_option:
+ flag = True
+ # Condition 3: If the ground truth is a substring of the predicted answer
+ elif gt in pred:
+ flag = True
+
+ return flag
+
+
+def check_ans_with_model(pred, gt, model, item, dataset_name='MVBench'):
+ """
+ Checks if the predicted answer matches the ground truth using a given model.
+
+ Args:
+ pred (str): The predicted answer.
+ gt (str): The ground truth answer.
+ model: A machine learning model used for additional verification.
+ item (dict): An item containing information about the question or task.
+ dataset_name (str, optional): Name of the dataset being used. Defaults to 'MVBench'.
+
+ Returns:
+ bool: True if the predicted answer matches the ground truth, False otherwise.
+ """
+ # Initialize flag to track match status
+ flag = False
+
+ # Preprocess prediction and ground truth by converting to lowercase and splitting into options and contents
+ pred_list = pred.lower().strip().split(' ')
+ pred_option, _ = pred_list[0], ' '.join(pred_list[1:])
+ gt_list = gt.lower().strip().split(' ')
+ gt_option, gt_content = gt_list[0], ' '.join(gt_list[1:])
+
+ # Remove trailing period from ground truth content if presen
+ if gt_content[-1] == '.':
+ gt_content = gt_content[:-1]
+
+ # Check for matching conditions
+ # Condition 1: If the predicted option is a substring of the ground truth option
+ if pred_option.replace('.', '') in gt_option:
+ flag = True
+ # Condition 2: If the ground truth option is a substring of the predicted option
+ elif gt_option in pred_option:
+ flag = True
+ # Condition 3: Use the provided model to verify the answer
+ elif extract_answer_from_item(model, item, dataset_name)['opt'] == item['answer']:
+ flag = True
+
+ return flag
+
+
+def check_ans_advanced(pred, gt):
+ number_table = {
+ 0: 'zero',
+ 1: 'one',
+ 2: 'two',
+ 3: 'three',
+ 4: 'four',
+ 5: 'five',
+ 6: 'six',
+ 7: 'seven',
+ 8: 'eight',
+ 9: 'nine',
+ }
+ flag = False
+
+ pred_list = pred.lower().split(' ')
+ pred_option, _ = pred_list[0], ' '.join(pred_list[1:])
+ gt_list = gt.lower().split(' ')
+ gt_option, gt_content = gt_list[0], ' '.join(gt_list[1:])
+ if gt_content[-1] == '.':
+ gt_content = gt_content[:-1]
+
+ try:
+ gt_content = number_table[int(gt_content.strip('. \n'))]
+ print(gt_content)
+ except:
+ pass
+
+ if pred_option.replace('.', '') in gt_option:
+ flag = True
+ elif gt_option in pred_option:
+ flag = True
+ elif gt_content.lower().strip('. \n') in pred.lower().strip('. \n'):
+ flag = True
+
+ return flag
+
+
+class GroupRandomCrop(object):
+ def __init__(self, size):
+ if isinstance(size, numbers.Number):
+ self.size = (int(size), int(size))
+ else:
+ self.size = size
+
+ def __call__(self, img_group):
+
+ w, h = img_group[0].size
+ th, tw = self.size
+
+ out_images = list()
+
+ x1 = random.randint(0, w - tw)
+ y1 = random.randint(0, h - th)
+
+ for img in img_group:
+ assert (img.size[0] == w and img.size[1] == h)
+ if w == tw and h == th:
+ out_images.append(img)
+ else:
+ out_images.append(img.crop((x1, y1, x1 + tw, y1 + th)))
+
+ return out_images
+
+
+class MultiGroupRandomCrop(object):
+ def __init__(self, size, groups=1):
+ if isinstance(size, numbers.Number):
+ self.size = (int(size), int(size))
+ else:
+ self.size = size
+ self.groups = groups
+
+ def __call__(self, img_group):
+
+ w, h = img_group[0].size
+ th, tw = self.size
+
+ out_images = list()
+
+ for i in range(self.groups):
+ x1 = random.randint(0, w - tw)
+ y1 = random.randint(0, h - th)
+
+ for img in img_group:
+ assert (img.size[0] == w and img.size[1] == h)
+ if w == tw and h == th:
+ out_images.append(img)
+ else:
+ out_images.append(img.crop((x1, y1, x1 + tw, y1 + th)))
+
+ return out_images
+
+
+class GroupCenterCrop(object):
+ def __init__(self, size):
+ self.worker = torchvision.transforms.CenterCrop(size)
+
+ def __call__(self, img_group):
+ return [self.worker(img) for img in img_group]
+
+
+class GroupRandomHorizontalFlip(object):
+ """Randomly horizontally flips the given PIL.Image with a probability of 0.5
+ """
+
+ def __init__(self, is_flow=False):
+ self.is_flow = is_flow
+
+ def __call__(self, img_group, is_flow=False):
+ v = random.random()
+ if v < 0.5:
+ ret = [img.transpose(Image.FLIP_LEFT_RIGHT) for img in img_group]
+ if self.is_flow:
+ for i in range(0, len(ret), 2):
+ # invert flow pixel values when flipping
+ ret[i] = ImageOps.invert(ret[i])
+ return ret
+ else:
+ return img_group
+
+
+class GroupNormalize(object):
+ def __init__(self, mean, std):
+ self.mean = mean
+ self.std = std
+
+ def __call__(self, tensor):
+ rep_mean = self.mean * (tensor.size()[0] // len(self.mean))
+ rep_std = self.std * (tensor.size()[0] // len(self.std))
+
+ # TODO: make efficient
+ for t, m, s in zip(tensor, rep_mean, rep_std):
+ t.sub_(m).div_(s)
+
+ return tensor
+
+
+class GroupScale(object):
+ """ Rescales the input PIL.Image to the given 'size'.
+ 'size' will be the size of the smaller edge.
+ For example, if height > width, then image will be
+ rescaled to (size * height / width, size)
+ size: size of the smaller edge
+ interpolation: Default: PIL.Image.BILINEAR
+ """
+
+ def __init__(self, size, interpolation=Image.BILINEAR):
+ self.worker = torchvision.transforms.Resize(size, interpolation)
+
+ def __call__(self, img_group):
+ return [self.worker(img) for img in img_group]
+
+
+class GroupOverSample(object):
+ def __init__(self, crop_size, scale_size=None, flip=True):
+ self.crop_size = crop_size if not isinstance(
+ crop_size, int) else (crop_size, crop_size)
+
+ if scale_size is not None:
+ self.scale_worker = GroupScale(scale_size)
+ else:
+ self.scale_worker = None
+ self.flip = flip
+
+ def __call__(self, img_group):
+
+ if self.scale_worker is not None:
+ img_group = self.scale_worker(img_group)
+
+ image_w, image_h = img_group[0].size
+ crop_w, crop_h = self.crop_size
+
+ offsets = GroupMultiScaleCrop.fill_fix_offset(
+ False, image_w, image_h, crop_w, crop_h)
+ oversample_group = list()
+ for o_w, o_h in offsets:
+ normal_group = list()
+ flip_group = list()
+ for i, img in enumerate(img_group):
+ crop = img.crop((o_w, o_h, o_w + crop_w, o_h + crop_h))
+ normal_group.append(crop)
+ flip_crop = crop.copy().transpose(Image.FLIP_LEFT_RIGHT)
+
+ if img.mode == 'L' and i % 2 == 0:
+ flip_group.append(ImageOps.invert(flip_crop))
+ else:
+ flip_group.append(flip_crop)
+
+ oversample_group.extend(normal_group)
+ if self.flip:
+ oversample_group.extend(flip_group)
+ return oversample_group
+
+
+class GroupFullResSample(object):
+ def __init__(self, crop_size, scale_size=None, flip=True):
+ self.crop_size = crop_size if not isinstance(
+ crop_size, int) else (crop_size, crop_size)
+
+ if scale_size is not None:
+ self.scale_worker = GroupScale(scale_size)
+ else:
+ self.scale_worker = None
+ self.flip = flip
+
+ def __call__(self, img_group):
+
+ if self.scale_worker is not None:
+ img_group = self.scale_worker(img_group)
+
+ image_w, image_h = img_group[0].size
+ crop_w, crop_h = self.crop_size
+
+ w_step = (image_w - crop_w) // 4
+ h_step = (image_h - crop_h) // 4
+
+ offsets = list()
+ offsets.append((0 * w_step, 2 * h_step)) # left
+ offsets.append((4 * w_step, 2 * h_step)) # right
+ offsets.append((2 * w_step, 2 * h_step)) # center
+
+ oversample_group = list()
+ for o_w, o_h in offsets:
+ normal_group = list()
+ flip_group = list()
+ for i, img in enumerate(img_group):
+ crop = img.crop((o_w, o_h, o_w + crop_w, o_h + crop_h))
+ normal_group.append(crop)
+ if self.flip:
+ flip_crop = crop.copy().transpose(Image.FLIP_LEFT_RIGHT)
+
+ if img.mode == 'L' and i % 2 == 0:
+ flip_group.append(ImageOps.invert(flip_crop))
+ else:
+ flip_group.append(flip_crop)
+
+ oversample_group.extend(normal_group)
+ oversample_group.extend(flip_group)
+ return oversample_group
+
+
+class GroupMultiScaleCrop(object):
+
+ def __init__(self, input_size, scales=None, max_distort=1,
+ fix_crop=True, more_fix_crop=True):
+ self.scales = scales if scales is not None else [1, .875, .75, .66]
+ self.max_distort = max_distort
+ self.fix_crop = fix_crop
+ self.more_fix_crop = more_fix_crop
+ self.input_size = input_size if not isinstance(input_size, int) else [
+ input_size, input_size]
+ self.interpolation = Image.BILINEAR
+
+ def __call__(self, img_group):
+
+ im_size = img_group[0].size
+
+ crop_w, crop_h, offset_w, offset_h = self._sample_crop_size(im_size)
+ crop_img_group = [
+ img.crop(
+ (offset_w,
+ offset_h,
+ offset_w + crop_w,
+ offset_h + crop_h)) for img in img_group]
+ ret_img_group = [img.resize((self.input_size[0], self.input_size[1]), self.interpolation)
+ for img in crop_img_group]
+ return ret_img_group
+
+ def _sample_crop_size(self, im_size):
+ image_w, image_h = im_size[0], im_size[1]
+
+ # find a crop size
+ base_size = min(image_w, image_h)
+ crop_sizes = [int(base_size * x) for x in self.scales]
+ crop_h = [
+ self.input_size[1] if abs(
+ x - self.input_size[1]) < 3 else x for x in crop_sizes]
+ crop_w = [
+ self.input_size[0] if abs(
+ x - self.input_size[0]) < 3 else x for x in crop_sizes]
+
+ pairs = []
+ for i, h in enumerate(crop_h):
+ for j, w in enumerate(crop_w):
+ if abs(i - j) <= self.max_distort:
+ pairs.append((w, h))
+
+ crop_pair = random.choice(pairs)
+ if not self.fix_crop:
+ w_offset = random.randint(0, image_w - crop_pair[0])
+ h_offset = random.randint(0, image_h - crop_pair[1])
+ else:
+ w_offset, h_offset = self._sample_fix_offset(
+ image_w, image_h, crop_pair[0], crop_pair[1])
+
+ return crop_pair[0], crop_pair[1], w_offset, h_offset
+
+ def _sample_fix_offset(self, image_w, image_h, crop_w, crop_h):
+ offsets = self.fill_fix_offset(
+ self.more_fix_crop, image_w, image_h, crop_w, crop_h)
+ return random.choice(offsets)
+
+ @staticmethod
+ def fill_fix_offset(more_fix_crop, image_w, image_h, crop_w, crop_h):
+ w_step = (image_w - crop_w) // 4
+ h_step = (image_h - crop_h) // 4
+
+ ret = list()
+ ret.append((0, 0)) # upper left
+ ret.append((4 * w_step, 0)) # upper right
+ ret.append((0, 4 * h_step)) # lower left
+ ret.append((4 * w_step, 4 * h_step)) # lower right
+ ret.append((2 * w_step, 2 * h_step)) # center
+
+ if more_fix_crop:
+ ret.append((0, 2 * h_step)) # center left
+ ret.append((4 * w_step, 2 * h_step)) # center right
+ ret.append((2 * w_step, 4 * h_step)) # lower center
+ ret.append((2 * w_step, 0 * h_step)) # upper center
+
+ ret.append((1 * w_step, 1 * h_step)) # upper left quarter
+ ret.append((3 * w_step, 1 * h_step)) # upper right quarter
+ ret.append((1 * w_step, 3 * h_step)) # lower left quarter
+ ret.append((3 * w_step, 3 * h_step)) # lower righ quarter
+
+ return ret
+
+
+class GroupRandomSizedCrop(object):
+ """Random crop the given PIL.Image to a random size of (0.08 to 1.0) of the original size
+ and and a random aspect ratio of 3/4 to 4/3 of the original aspect ratio
+ This is popularly used to train the Inception networks
+ size: size of the smaller edge
+ interpolation: Default: PIL.Image.BILINEAR
+ """
+
+ def __init__(self, size, interpolation=Image.BILINEAR):
+ self.size = size
+ self.interpolation = interpolation
+
+ def __call__(self, img_group):
+ for attempt in range(10):
+ area = img_group[0].size[0] * img_group[0].size[1]
+ target_area = random.uniform(0.08, 1.0) * area
+ aspect_ratio = random.uniform(3. / 4, 4. / 3)
+
+ w = int(round(math.sqrt(target_area * aspect_ratio)))
+ h = int(round(math.sqrt(target_area / aspect_ratio)))
+
+ if random.random() < 0.5:
+ w, h = h, w
+
+ if w <= img_group[0].size[0] and h <= img_group[0].size[1]:
+ x1 = random.randint(0, img_group[0].size[0] - w)
+ y1 = random.randint(0, img_group[0].size[1] - h)
+ found = True
+ break
+ else:
+ found = False
+ x1 = 0
+ y1 = 0
+
+ if found:
+ out_group = list()
+ for img in img_group:
+ img = img.crop((x1, y1, x1 + w, y1 + h))
+ assert (img.size == (w, h))
+ out_group.append(
+ img.resize(
+ (self.size, self.size), self.interpolation))
+ return out_group
+ else:
+ # Fallback
+ scale = GroupScale(self.size, interpolation=self.interpolation)
+ crop = GroupRandomCrop(self.size)
+ return crop(scale(img_group))
+
+
+class ConvertDataFormat(object):
+ def __init__(self, model_type):
+ self.model_type = model_type
+
+ def __call__(self, images):
+ if self.model_type == '2D':
+ return images
+ tc, h, w = images.size()
+ t = tc // 3
+ images = images.view(t, 3, h, w)
+ images = images.permute(1, 0, 2, 3)
+ return images
+
+
+class Stack(object):
+
+ def __init__(self, roll=False):
+ self.roll = roll
+
+ def __call__(self, img_group):
+ if img_group[0].mode == 'L':
+ return np.concatenate([np.expand_dims(x, 2)
+ for x in img_group], axis=2)
+ elif img_group[0].mode == 'RGB':
+ if self.roll:
+ return np.concatenate([np.array(x)[:, :, ::-1]
+ for x in img_group], axis=2)
+ else:
+ # print(np.concatenate(img_group, axis=2).shape)
+ # print(img_group[0].shape)
+ return np.concatenate(img_group, axis=2)
+
+
+class ToTorchFormatTensor(object):
+ """ Converts a PIL.Image (RGB) or numpy.ndarray (H x W x C) in the range [0, 255]
+ to a torch.FloatTensor of shape (C x H x W) in the range [0.0, 1.0] """
+
+ def __init__(self, div=True):
+ self.div = div
+
+ def __call__(self, pic):
+ if isinstance(pic, np.ndarray):
+ # handle numpy array
+ img = torch.from_numpy(pic).permute(2, 0, 1).contiguous()
+ else:
+ # handle PIL Image
+ img = torch.ByteTensor(
+ torch.ByteStorage.from_buffer(
+ pic.tobytes()))
+ img = img.view(pic.size[1], pic.size[0], len(pic.mode))
+ # put it from HWC to CHW format
+ # yikes, this transpose takes 80% of the loading time/CPU
+ img = img.transpose(0, 1).transpose(0, 2).contiguous()
+ return img.float().div(255) if self.div else img.float()
+
+
+class IdentityTransform(object):
+
+ def __call__(self, data):
+ return data
diff --git a/vlmeval/dataset/utils/tempcompass.py b/vlmeval/dataset/utils/tempcompass.py
new file mode 100644
index 0000000000000000000000000000000000000000..c284e4bf82cbf6097ec43705d086127b9d05eb53
--- /dev/null
+++ b/vlmeval/dataset/utils/tempcompass.py
@@ -0,0 +1,254 @@
+from ...smp import *
+from .multiple_choice import extract_answer_from_item
+from PIL import Image, ImageOps
+import numpy as np
+
+sys_prompt = "You are an AI assistant for question answering."
+
+system_prompt_multi_choice = (
+ "You will receive a multi-choice question, the ground-truth answer and the prediction from a question answering (QA) model. " # noqa
+ "Your task is to determine whether QA model prediction is correct, based on the question and ground-truth answer. "
+ "If the prediction is correct, respond \"Correct\". If the prediction is incorrect, respond \"Incorrect\"."
+)
+
+system_prompt_caption_matching = (
+ "You will receive a caption matching question, the ground-truth answer and the prediction from a question answering (QA) model. " # noqa
+ "Your task is to determine whether QA model prediction is correct, based on the question and ground-truth answer. "
+ "If the prediction is correct, respond \"Correct\". If the prediction is incorrect, respond \"Incorrect\"."
+)
+
+system_prompt_captioning = """
+You will receive a video description and a multi-choice question. Your task is to choose the correct answer and briefly explain the reason why you choose the answer. \
+If none of the choice candidates are correct or the video description lacks enough information to answer the question, just answer "None of the choices are correct". \
+Please organize your response in this format:
+```
+Reasoning: [Your reason to obtain the answer]
+Answer: [Your answer]
+```
+
+Here are some examples of video description, multi-choice question and the expected answer:
+```
+Video Description: A person is palying football.
+Multi-Choice Question:
+What is the person doing in the video?
+A. cooking
+B. palying football
+C. playing basketball
+D. reading book
+Reasoning: The video description mentions that the person is playing football.
+Answer: B. palying football
+
+Video Description: A bird is flying clockwise.
+Multi-Choice Question:
+In which direction is the bird flying?
+A. backwark
+B. counter-clockwise
+C. clockwise
+D. downward
+Reasoning: The video description mentions that the bird is flying clockwise
+Answer: C. clockwise
+
+Video Description: An air balloon is inflating.
+Multi-Choice Question:
+What is happening to the air balloon?
+A. exploding
+B. getting smaller
+C. flying
+Reasoning: The video description mentions that the air balloon is inflating, while none of the coices can be explained as inflating.
+Answer: None of the choices are correct
+```
+""" # noqa
+
+system_prompt_YorN = """
+You will receive a Yes/No question, the ground-truth answer and the prediction from a question answering (QA) model. \
+Your task is to determine whether QA model prediction is correct, based on the question and ground-truth answer. \
+If the prediction is correct, respond "Correct". If the prediction is incorrect, respond "Incorrect".
+""" # noqa
+
+
+def eval_rule_caption_matching(line):
+ # Determine whether the video llm output is correct, based on word matching rules
+ video_llm_output = line['prediction']
+ answer = line['answer']
+ option_strs = eval(line['candidates']) # complete option strings
+ option_sents = [opt.split(': ')[1] for opt in option_strs] # option sentence
+ # option index, e.g., Sentence A, Caption A, Option 1
+ option_inds = [opt.split(': ')[0] for opt in option_strs] + [opt.split(': ')[0].replace('Sentence ', '').replace('Option ', '').replace('Caption ', '') for opt in option_strs] # noqa
+ video_llm_pred = None
+ for option_str in option_strs:
+ if option_str == video_llm_output:
+ video_llm_pred = option_str
+ for option_sent in option_sents:
+ if option_sent == video_llm_output or (') ' in video_llm_output and option_sent == video_llm_output.split(') ')[1]): # noqa
+ video_llm_pred = option_sent
+ for option_ind in option_inds:
+ if option_ind == video_llm_output or option_ind == video_llm_output.replace('.', ''): # noqa
+ video_llm_pred = option_ind
+
+ if video_llm_pred is None:
+ return "fail"
+ else:
+ return 1 if video_llm_pred == answer or video_llm_pred == answer.split(":")[0] or video_llm_pred == answer.split(": ")[1] or video_llm_pred == answer.split(": ")[0].split()[1] else 0 # noqa
+
+
+def eval_rule_multi_choice(line):
+ if line['prediction'] == line['answer']:
+ return 1
+ elif line['prediction'] in ['A', 'B', 'C', 'D']:
+ return 1 if line['prediction'] == line['answer'][0] else 0
+ elif any(line['prediction'].startswith(prefix) for prefix in ['A.', 'B.', 'C.', 'D.']):
+ return 1 if line['prediction'].split('.')[0] == line['answer'][0] else 0
+ elif any(line['prediction'].startswith(prefix) for prefix in ['A)', 'B)', 'C)', 'D)']):
+ return 1 if line['prediction'].split(')')[0] == line['answer'][0] else 0
+ else:
+ return "fail"
+
+
+def eval_rule_YorN(video_llm_output):
+ # Extract the yes/no predction from the original video llm output
+ video_llm_output = video_llm_output.lower()
+ if video_llm_output.startswith("yes"):
+ return "yes"
+ elif video_llm_output.startswith("no"):
+ return "no"
+ else:
+ return False
+
+
+def llm_output_to_rating(llm_output):
+ if not ('Correct' in llm_output or 'Incorrect' in llm_output):
+ print(f"Warning: LLM output is not in the correct format: {llm_output}")
+ rating = 0
+ return rating
+ if llm_output.startswith('Correct'):
+ rating = 1
+ elif llm_output.startswith('Incorrect'):
+ rating = 0
+ elif ('Correct' in llm_output) and ('Incorrect' not in llm_output):
+ rating = 1
+ elif 'Incorrect' in llm_output:
+ rating = 0
+ return rating
+
+
+def parse_llm_output(llm_output, gt_answer):
+ if llm_output == "invalid_request_error" or not llm_output:
+ eval_result = {"rating": -1, "chatgpt-answer": None, "chatgpt-reasoning": None}
+ return eval_result
+
+ eval_result = {}
+ lines = llm_output.split("\n")
+
+ for line in lines:
+ line = line.strip()
+ if "Reasoning" in line:
+ eval_result['chatgpt-reasoning'] = line.replace("Reasoning:", "").strip()
+ if "Answer" in line:
+ eval_result['chatgpt-answer'] = line.replace("Answer:", "").strip()
+
+ if "chatgpt-answer" not in eval_result:
+ eval_result['chatgpt-answer'] = llm_output
+ if "chatgpt-reasoning" not in eval_result:
+ eval_result['chatgpt-reasoning'] = None
+
+ # Check if the chatgpt answer is the ground-truth answer
+ # calculate the number of 'A.', 'B.', 'C.', 'D.' in chatgpt-answer
+ answer_counts = sum(eval_result['chatgpt-answer'].count(prefix) for prefix in ['A.', 'B.', 'C.', 'D.']) # noqa
+ if eval_result['chatgpt-answer'].split(". ")[0] == gt_answer.split(". ")[0] and answer_counts == 1:
+ eval_result['rating'] = 1
+ else:
+ eval_result['rating'] = 0
+ return eval_result
+
+
+def evaluate_tempcompass_mcq(model, line):
+ eval_rules_dict = {
+ 'caption_matching': eval_rule_caption_matching,
+ 'multi-choice': eval_rule_multi_choice
+ }
+ gpt_eval_prompt = {
+ 'multi-choice': '{}\nMulti-Choice Question:\n{}\nGround-Truth Answer: {}\nModel Prediction: {}',
+ 'caption_matching': '{}\nCaption Matching Question:\n{}\nGround-Truth Answer: {}\nModel Prediction: {}'
+ }
+ base_prompt = {
+ 'multi-choice': system_prompt_multi_choice,
+ 'caption_matching': system_prompt_caption_matching
+ }
+ eval_result = {
+ "question": line['question'],
+ "answer": line['answer'],
+ "prediction": line['prediction'],
+ "task_type": line['task_type'],
+ "candidates": line['candidates'],
+ "match_success": True
+ }
+ result = eval_rules_dict[line['task_type']](line)
+ if result == "fail":
+ eval_result['match_success'] = False
+ if model is None:
+ eval_result['rating'] = 0
+ else:
+ prompt_template = gpt_eval_prompt[line['task_type']]
+ prompt = prompt_template.format(base_prompt[line['task_type']], line['question'], line['answer'], line['prediction']) # noqa
+ llm_output = model.generate(prompt)
+ result = llm_output_to_rating(llm_output)
+ eval_result['chatgpt-response'] = llm_output
+ eval_result['rating'] = result
+ else:
+ eval_result['rating'] = result
+
+ return eval_result
+
+
+def evaluate_tempcompass_captioning(model, line):
+ prompt = (
+ f"{system_prompt_captioning}\n"
+ f"Video Description:{line['prediction']}\n"
+ f"Multi-Choice Question:\n{line['mc_question']}\n"
+ )
+ if model is not None:
+ llm_output = model.generate(prompt)
+ eval_result = parse_llm_output(llm_output, gt_answer=line['mc_answer'])
+ return eval_result
+ else:
+ raise ValueError("Model is None, TempCompass Captioning task not supported exact matching") # noqa
+
+
+def evaluate_tempcompass_YorN(model, line):
+ prompt = (
+ f"{system_prompt_YorN}\n"
+ f"Yes/No Question:\n{line['question']}\n"
+ f"Ground-Truth Answer: {line['answer']}\n"
+ f"Model Prediction: {line['prediction']}"
+ )
+ result = eval_rule_YorN(line['prediction'])
+ eval_result = {
+ "question": line['question'],
+ "answer": line['answer'],
+ "prediction": line['prediction'],
+ "match_success": True
+ }
+ if result:
+ eval_result['rating'] = 1 if result == line['answer'] else 0
+ elif model is None:
+ eval_result['match_success'] = False
+ eval_result['rating'] = 0
+ else:
+ eval_result['match_success'] = False
+ llm_output = model.generate(prompt)
+ result = llm_output_to_rating(llm_output)
+ eval_result['chatgpt-response'] = llm_output
+ eval_result['rating'] = result
+ return eval_result
+
+
+def get_dimension_rating(score_file):
+ data = load(score_file)
+ result_dict = {}
+ for idx, item in data.iterrows():
+ dict_key = item['dim'] + '. ' + item['task_type']
+ if dict_key not in result_dict:
+ result_dict[dict_key] = [0,0]
+ result_dict[dict_key][0] += int(item['score'])
+ result_dict[dict_key][1] += 1
+ return result_dict
diff --git a/vlmeval/dataset/utils/vdc.py b/vlmeval/dataset/utils/vdc.py
new file mode 100644
index 0000000000000000000000000000000000000000..235314da967e952fba01f644c8b7be3512b299a4
--- /dev/null
+++ b/vlmeval/dataset/utils/vdc.py
@@ -0,0 +1,158 @@
+from ...smp import *
+import numpy as np
+import pandas as pd
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+SYSTEM_CAL_SCORE_PROMPT = """You are an intelligent chatbot designed for evaluating the correctness of generative outputs for question-answer pairs.
+Your task is to compare the predicted answer with the correct answer and determine if they match meaningfully. Here's how you can accomplish the task:
+------
+##INSTRUCTIONS:
+- Focus on the meaningful match between the predicted answer and the correct answer.
+- Consider synonyms or paraphrases as valid matches.
+- Evaluate the correctness of the prediction compared to the answer.
+"""
+
+USER_CAL_SCORE_PROMPT = """Please evaluate the following video-based question-answer pair:
+
+Question: {question}
+Correct Answer: {answer}
+Predicted Answer: {pred_response}
+
+Provide your evaluation only as a yes/no and score where the score is an integer value between 0 and 5, with 5 indicating the highest meaningful match.
+Please generate the response in the form of a Python dictionary string with keys 'pred' and 'score', where value of 'pred' is a string of 'yes' or 'no' and value of 'score' is in INTEGER, not STRING.
+DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string.
+For example, your response should look like this: \{'pred': 'yes', 'score': 4.8\}.
+"""
+
+SYSTEM_GENER_PRED_PROMPT = """You are an intelligent chatbot designed for providing accurate answers to questions related to the content based on a detailed description of a video or image.
+Here's how you can accomplish the task:
+------
+##INSTRUCTIONS:
+- Read the detailed description carefully.
+- Answer the question only based on the detailed description.
+- The answer should be a short sentence or phrase.
+"""
+
+USER_GENER_PRED_PROMPT = """Please provide accurate answers to questions related to the content based on a detailed description of a video or image:
+
+detailed description: {pred_cap}
+question: {q}
+
+DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide short but accurate answer."""
+
+
+VDC_DIMENSIONS = {
+ 'short': ['short'],
+ 'detailed': ['detailed'],
+ 'background': ['background'],
+ 'main_object': ['main_object'],
+ 'camera': ['camera'],
+ 'overall': []
+}
+
+L3_DIMS = []
+for k, v in VDC_DIMENSIONS.items():
+ if k != 'overall':
+ L3_DIMS.extend(v)
+ VDC_DIMENSIONS['overall'].extend(v)
+
+
+def get_dimension_rating(data_path):
+ data = load(data_path)
+ coarse_rating = {k: [] for k in VDC_DIMENSIONS}
+ coarse_acc = {k: [] for k in VDC_DIMENSIONS}
+
+ def parse_score_dict(score_dict):
+ """Helper function to parse score dictionary string"""
+ if isinstance(score_dict, dict):
+ return score_dict
+
+ if isinstance(score_dict, str):
+ try:
+ # First try standard json loading
+ return json.loads(score_dict)
+ except json.JSONDecodeError:
+ try:
+ # If that fails, try eval (safer than literal_eval for this case)
+ return eval(score_dict)
+ except:
+ print(f"Failed to parse score_dict: {score_dict}")
+ return None
+ return None
+
+ for i in range(len(data)):
+ caption_type = data.iloc[i]['caption_type'].lower() # Convert to lowercase
+ score_dict = parse_score_dict(data.iloc[i]['score'])
+
+ if score_dict and isinstance(score_dict, dict) and 'pred' in score_dict and 'score' in score_dict:
+ score = score_dict['score']
+ is_correct = 1 if score_dict['pred'].lower() == 'yes' else 0
+ else:
+ score = -1
+ is_correct = -1
+
+ # Map caption types to their lowercase versions
+ if caption_type in ['short', 'detailed', 'background', 'main_object', 'camera']:
+ coarse_rating[caption_type].append(score)
+ coarse_rating['overall'].append(score)
+
+ if is_correct != -1:
+ coarse_acc[caption_type].append(is_correct)
+ coarse_acc['overall'].append(is_correct)
+
+
+ coarse_valid = {k: f'{np.mean([x for x in v if x >= 0]):.2f}' for k, v in coarse_rating.items()}
+ coarse_accuracy = {k: f'{np.mean(v):.2f}' if v else '0.00' for k, v in coarse_acc.items()}
+
+ return dict(
+ coarse_valid=coarse_valid,
+ coarse_accuracy=coarse_accuracy
+ )
+
+def prepare_response_prompt(item):
+ """
+ Prepare messages for response generation
+
+ Args:
+ item: DataFrame row containing pred_cap and question
+
+ Returns:
+ list: List of message dictionaries for the model
+ """
+ return USER_GENER_PRED_PROMPT.format(
+ pred_cap=item['prediction'],
+ q=item['question'])
+
+
+def prepare_score_prompt(item):
+ """
+ Prepare messages for score evaluation
+
+ Args:
+ item: DataFrame row containing question, answer, and prediction
+
+ Returns:
+ list: List of message dictionaries for the model
+ """
+ # Convert Series to dictionary if needed
+ if isinstance(item, pd.Series):
+ item = item.to_dict()
+
+
+ # prompt = USER_CAL_SCORE_PROMPT.format(
+ # question=item['question'],
+ # answer=item['answer'],
+ # pred_response=item['pred_response']
+ # )
+
+ prompt = f"""Please evaluate the following video-based question-answer pair:\n\n
+ Question: {item['question']}\n
+ Correct Answer: {item['answer']}\n
+ Predicted Answer: {item['pred_response']}\n\n
+ Provide your evaluation only as a yes/no and score where the score is an integer value between 0 and 5, with 5 indicating the highest meaningful match.
+ Please generate the response in the form of a Python dictionary string with keys 'pred' and 'score', where value of 'pred' is a string of 'yes' or 'no' and value of 'score' is in INTEGER, not STRING.
+ DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string.
+ For example, your response should look like this: {{'pred': 'yes', 'score': 4.8}}."""
+
+ return prompt
diff --git a/vlmeval/dataset/utils/videomme.py b/vlmeval/dataset/utils/videomme.py
new file mode 100644
index 0000000000000000000000000000000000000000..dea57ead7ed6cbb700b95eda15c6eec2fb45b77f
--- /dev/null
+++ b/vlmeval/dataset/utils/videomme.py
@@ -0,0 +1,150 @@
+from ...smp import *
+from .multiple_choice import extract_answer_from_item
+import numpy as np
+import re
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+DURATIONS = [
+ 'short',
+ 'medium',
+ 'long',
+]
+
+DOMAINS = [
+ 'Knowledge',
+ 'Film & Television',
+ 'Sports Competition',
+ 'Artistic Performance',
+ 'Life Record',
+ 'Multilingual'
+]
+
+SUB_CATEGORIES = [
+ 'Humanity & History',
+ 'Literature & Art',
+ 'Biology & Medicine',
+ 'Finance & Commerce',
+ 'Astronomy',
+ 'Geography',
+ 'Law',
+ 'Life Tip',
+ 'Technology',
+ 'Animation',
+ 'Movie & TV Show',
+ 'Documentary',
+ 'News Report',
+ 'Esports',
+ 'Basketball',
+ 'Football',
+ 'Athletics',
+ 'Other Sports',
+ 'Stage Play',
+ 'Magic Show',
+ 'Variety Show',
+ 'Acrobatics',
+ 'Handicraft',
+ 'Food',
+ 'Fashion',
+ 'Daily Life',
+ 'Travel',
+ 'Pet & Animal',
+ 'Exercise',
+ 'Multilingual'
+]
+
+TASK_CATEGORIES = [
+ 'Temporal Perception',
+ 'Spatial Perception',
+ 'Attribute Perception',
+ 'Action Recognition',
+ 'Object Recognition',
+ 'OCR Problems',
+ 'Counting Problem',
+ 'Temporal Reasoning',
+ 'Spatial Reasoning',
+ 'Action Reasoning',
+ 'Object Reasoning',
+ 'Information Synopsis',
+]
+
+
+def get_dimension_rating(data_path):
+ data = load(data_path)
+
+ duration_rating = {k: {} for k in DURATIONS}
+ for duration in DURATIONS + ['overall']:
+ duration_rating[duration] = {
+ 'overall': '',
+ 'domain': {k: [] for k in DOMAINS},
+ 'sub_category': {k: [] for k in SUB_CATEGORIES},
+ 'task_type': {k: [] for k in TASK_CATEGORIES}
+ }
+
+ for i in range(len(data)):
+
+ domain = data.iloc[i]['domain']
+ sub_ctg = data.iloc[i]['sub_category']
+ task_ctg = data.iloc[i]['task_type']
+
+ duration = data.iloc[i]['duration']
+ duration_rating[duration]['domain'][domain].append(data.iloc[i]['score'])
+ duration_rating[duration]['sub_category'][sub_ctg].append(data.iloc[i]['score'])
+ duration_rating[duration]['task_type'][task_ctg].append(data.iloc[i]['score'])
+
+ duration_rating['overall']['domain'][domain].append(data.iloc[i]['score'])
+ duration_rating['overall']['sub_category'][sub_ctg].append(data.iloc[i]['score'])
+ duration_rating['overall']['task_type'][task_ctg].append(data.iloc[i]['score'])
+
+ for duration in DURATIONS + ['overall']:
+
+ overall_res_dur = f'{np.mean([x for x in sum(duration_rating[duration]["domain"].values(), []) if x >= 0]):.3f}'
+ duration_rating[duration]['overall'] = overall_res_dur
+
+ for domain in DOMAINS:
+ domain_res_dur = f'{np.mean([x for x in duration_rating[duration]["domain"][domain] if x >= 0]):.3f}'
+ duration_rating[duration]['domain'][domain] = domain_res_dur
+
+ for sub_ctg in SUB_CATEGORIES:
+ sub_res_dur = f'{np.mean([x for x in duration_rating[duration]["sub_category"][sub_ctg] if x >= 0]):.3f}'
+ duration_rating[duration]['sub_category'][sub_ctg] = sub_res_dur
+
+ for task_ctg in TASK_CATEGORIES:
+ task_res_dur = f'{np.mean([x for x in duration_rating[duration]["task_type"][task_ctg] if x >= 0]):.3f}'
+ duration_rating[duration]['task_type'][task_ctg] = task_res_dur
+
+ return duration_rating
+
+
+def extract_option(model, input_item, dataset_name):
+ options = input_item['question'].split('\n')[1:]
+ for id, option in enumerate(options):
+ option_id = chr(ord('A') + id) + '.'
+ if option.find(option_id) >= 0:
+ input_item[chr(ord('A') + id)] = option[option.find(option_id) + len(option_id):].strip('. \n')
+ return extract_answer_from_item(model, input_item, dataset_name)['opt']
+
+
+def extract_characters_regex(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:',
+ 'Answer:',
+ 'Option:',
+ ]
+ for answer_prefix in answer_prefixes:
+ s = s.replace(answer_prefix, '')
+
+ if len(s.split()) > 10 and not re.search('[ABCD]', s):
+ return ''
+ matches = re.search(r'[ABCD]', s)
+ if matches is None:
+ return ''
+ return matches[0]
diff --git a/vlmeval/dataset/utils/vlm2bench.py b/vlmeval/dataset/utils/vlm2bench.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ec20a4dc7262e6392d2c90743b7d17904157302
--- /dev/null
+++ b/vlmeval/dataset/utils/vlm2bench.py
@@ -0,0 +1,227 @@
+"""
+vlm2bench utils for eval
+
+Input sample format: contains the following fields:
+ - index (original q_id)
+ - question
+ - answer (correct answer, i.e., gt_answer)
+ - category
+ - prediction (model output, i.e., model answer)
+
+The categories of each sub-task include:
+ gc-mat, gc-trk, oc-cpr, pc-cpr --> tf pair task (the last character of the same index distinguishes positive or negative with _p or _n)
+ oc-cnt, pc-cnt --> cnt type
+ oc-grp, pc-grp --> grp (MCQ) type
+"""
+
+import os
+import re
+import json
+from collections import defaultdict
+from PIL import Image
+
+##########################################
+# 1. General Functions
+##########################################
+def common_doc_to_text(sample, **kwargs):
+ """
+ General: directly return the "question" field from the sample.
+ """
+ return sample.get("question", "")
+
+def common_doc_to_target(sample, **kwargs):
+ """
+ General: return the "answer" field from the sample as the correct answer.
+ """
+ return sample.get("answer", "")
+
+def common_process_results(results):
+ """
+ Since the input file fields are already index, question, answer, category, prediction,
+ directly return the original results without field mapping conversion.
+ """
+ return results
+
+##########################################
+# 2. TF Pair Task Evaluation (suitable for gc-mat, gc-trk, oc-cpr, pc-cpr)
+##########################################
+def parse_tf_answer(model_answer):
+ """
+ Extract 'T' or 'F' from the tf type model_answer.
+ Supports formats like 'T', 'F', 'True', 'False'; returns an error flag if multiple matches are found.
+ """
+ pattern = re.compile(r'\b(t|f|true|false)\b', re.IGNORECASE)
+ matches = pattern.findall(model_answer)
+ extracted = [match.upper()[0] for match in matches]
+ if len(extracted) == 1:
+ return extracted[0], None
+ elif len(extracted) > 1:
+ return None, 'multiple_answers_found'
+ else:
+ return None, 'no_answer_found'
+
+def tf_pair_aggregate_accuracy(results):
+ """
+ Aggregate evaluation results for the tf pair task.
+ Group by index, where the index format is like "pc-cpr_1_p" and "pc-cpr_1_n",
+ taking the prefix (removing the last _p or _n) as the identifier for the same group.
+ If all records in the group have predictions that match the answer ("T" or "F"), the group is considered correct,
+ returning the ratio of correct groups to total groups.
+ """
+ groups = defaultdict(list)
+ for item in results:
+ idx = item.get("index", "")
+ if "_" not in idx:
+ continue
+ base_id = "_".join(idx.split("_")[:-1])
+ groups[base_id].append(item)
+ total_groups = len(groups)
+ correct_groups = 0
+ for base_id, items in groups.items():
+ # At least two records are required in the group
+ if len(items) < 2:
+ continue
+ group_correct = True
+ for item in items:
+ gt = item.get("answer", "").strip().upper()
+ pred = item.get("prediction", "").strip().upper()
+ parsed, err = parse_tf_answer(pred)
+ if parsed != gt:
+ group_correct = False
+ break
+ if group_correct:
+ correct_groups += 1
+ return (correct_groups / total_groups) * 100 if total_groups > 0 else 0
+
+##########################################
+# 3. CNT Task Evaluation (suitable for oc-cnt, pc-cnt)
+##########################################
+NUM_WORDS = {
+ "zero": 0, "one": 1, "two": 2, "three": 3, "four": 4, "five": 5,
+ "six": 6, "seven": 7, "eight": 8, "nine": 9, "ten": 10,
+ "eleven": 11, "twelve": 12, "thirteen": 13, "fourteen": 14,
+ "fifteen": 15, "sixteen": 16, "seventeen": 17, "eighteen": 18,
+ "nineteen": 19, "twenty": 20, "thirty": 30, "forty": 40, "fifty": 50,
+ "sixty": 60, "seventy": 70, "eighty": 80, "ninety": 90, "hundred": 100, "thousand": 1000,
+}
+PENALTY_FACTOR = 10
+L_MAX = 4
+
+def words_to_num(s):
+ s = s.lower().replace('-', ' ').replace('and', ' ')
+ tokens = s.split()
+ total = 0
+ current = 0
+ for token in tokens:
+ if token in NUM_WORDS:
+ scale = NUM_WORDS[token]
+ if scale in (100, 1000):
+ if current == 0:
+ current = 1
+ current *= scale
+ total += current
+ current = 0
+ else:
+ current += scale
+ else:
+ return None
+ total += current
+ return total if total != 0 else None
+
+def extract_numbers(text):
+ text = text.lower()
+ digit_numbers = re.findall(r'\d+', text)
+ digit_numbers = [int(num) for num in digit_numbers]
+ word_numbers = []
+ pattern = re.compile(
+ r'\b(zero|one|two|three|four|five|six|seven|eight|nine|ten|'
+ r'eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|'
+ r'eighteen|nineteen|twenty|thirty|forty|fifty|sixty|seventy|'
+ r'eighty|ninety|hundred|thousand)\b', re.IGNORECASE)
+ matches = pattern.findall(text)
+ if matches:
+ word_phrase = ' '.join(matches)
+ num = words_to_num(word_phrase)
+ if num is not None:
+ word_numbers.append(num)
+ return digit_numbers + word_numbers
+
+def parse_model_answer(model_answer):
+ numbers = extract_numbers(model_answer)
+ if len(numbers) == 1:
+ return numbers[0]
+ else:
+ return None
+
+def cnt_aggregate_metric(results):
+ """
+ Aggregate evaluation results for the CNT task.
+ For each sample, parse the numbers in the prediction and compare them with the answer (which should be an integer),
+ calculate the score based on the error, and return the average score of all samples.
+ """
+ total_count = 0
+ total_norm_score = 0.0
+ for item in results:
+ try:
+ gt = int(item.get("answer", None))
+ except:
+ gt = None
+ if gt is None:
+ continue
+ total_count += 1
+ model_ans_str = str(item.get("prediction", "")).strip()
+ # Try to use the image_seq_len provided in the record; if not, default to 2
+ image_seq_len = item.get("image_seq_len", 2)
+ try:
+ image_seq_len = int(image_seq_len)
+ except:
+ image_seq_len = 2
+
+ parsed = parse_model_answer(model_ans_str)
+ if parsed is None:
+ norm_score = 0.0
+ else:
+ raw_diff = abs(parsed - gt)
+ if raw_diff == 0:
+ norm_score = 100.0
+ else:
+ max_error = max(gt - 1, image_seq_len - gt)
+ if max_error <= 0:
+ max_error = 1
+ relative_error = raw_diff / max_error
+ weight = L_MAX / image_seq_len
+ penalty = weight * (relative_error ** (1.0 / PENALTY_FACTOR))
+ norm_score = 100 * (1 - penalty) if penalty < 1 else 0.0
+ total_norm_score += norm_score
+ return total_norm_score / total_count if total_count > 0 else 0
+
+
+##########################################
+# 4. GRP Task Evaluation (suitable for oc-grp, pc-grp)
+##########################################
+def grp_clean_answer(answer):
+ if ")" in answer:
+ return answer.split(")")[0].strip()
+ return answer.strip()
+
+def grp_count_options(answer):
+ return len(re.findall(r'\([A-Z]\)', answer))
+
+def grp_aggregate_accuracy(results):
+ """
+ Aggregate evaluation results for the GRP task (MCQ).
+ For each sample, if multiple options appear in the prediction, it is considered incorrect; otherwise, compare the cleaned answer letters.
+ Return the accuracy.
+ """
+ total = 0
+ correct = 0
+ for item in results:
+ total += 1
+ model_ans = item.get("prediction", "")
+ gt_ans = item.get("answer", "")
+ if grp_count_options(model_ans) > 1:
+ continue
+ if grp_clean_answer(model_ans) == grp_clean_answer(gt_ans):
+ correct += 1
+ return (correct / total * 100) if total > 0 else 0
+
diff --git a/vlmeval/dataset/utils/vmcbench.py b/vlmeval/dataset/utils/vmcbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..048d24737c2f0656c9516ea89295bc7878b50467
--- /dev/null
+++ b/vlmeval/dataset/utils/vmcbench.py
@@ -0,0 +1,96 @@
+import pandas as pd
+import numpy as np
+import random
+
+
+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.
+ """
+ response = str(response)
+ 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 or 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
+
+def get_mc_score(row, use_parse = True):
+ if use_parse:
+ if pd.isna(row["A"]):
+ return False
+ response = row["prediction"]
+ all_choices = []
+ for i in range(9):
+ if chr(65+i) in row and pd.isna(row[chr(65+i)])== False:
+ all_choices.append(chr(65+i))
+ index2ans = {index: row[index] for index in all_choices}
+ pred_index = parse_multi_choice_response(response, all_choices, index2ans)
+ else:
+ pred_index = row["output"]
+ return int(pred_index == row["answer"])
+
+def report_vmc_acc(data):
+ general_datasets = ["SEEDBench", "MMStar", "A-OKVQA", "VizWiz", "MMVet",
+ "VQAv2", "OKVQA"]
+ reason_datasets = ["MMMU", "MathVista", "ScienceQA", "RealWorldQA", "GQA", "MathVision"]
+ ocr_datasets = ["TextVQA", "OCRVQA"]
+ doc_datasets = ["AI2D", "ChartQA","DocVQA", "InfoVQA", "TableVQABench"]
+ results = {}
+ for category in data['category'].unique():
+ results[category] = data[data['category'] == category]['hit'].mean()
+ results = pd.DataFrame(results, index=[0])
+ results["Overall"] = data['hit'].mean()
+ results['General'] = results[general_datasets].mean(axis=1)
+ results['Reasoning'] = results[reason_datasets].mean(axis=1)
+ results['OCR'] = results[ocr_datasets].mean(axis=1)
+ results['Doc & Chart'] = results[doc_datasets].mean(axis=1)
+ for key in results:
+ results[key] = round(results[key]*100, 2)
+ results = results[['Overall', 'General', 'Reasoning', 'OCR', 'Doc & Chart']
+ + general_datasets + reason_datasets + ocr_datasets + doc_datasets]
+ return results
+
\ No newline at end of file
diff --git a/vlmeval/dataset/utils/vqa_eval.py b/vlmeval/dataset/utils/vqa_eval.py
new file mode 100644
index 0000000000000000000000000000000000000000..8fcacf1ac62b0f5b12c9ad07ef1e1863dd0f7f61
--- /dev/null
+++ b/vlmeval/dataset/utils/vqa_eval.py
@@ -0,0 +1,285 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# Partly adopted from https://github.com/GT-Vision-Lab/VQA
+# Copyright (c) 2014, Aishwarya Agrawal
+
+from ...smp import *
+from typing import Optional
+
+
+def _process_digit_article(inText):
+ outText = []
+ tempText = inText.lower().split()
+ articles = ['a', 'an', 'the']
+ manualMap = {
+ 'none': '0',
+ 'zero': '0',
+ 'one': '1',
+ 'two': '2',
+ 'three': '3',
+ 'four': '4',
+ 'five': '5',
+ 'six': '6',
+ 'seven': '7',
+ 'eight': '8',
+ 'nine': '9',
+ 'ten': '10',
+ }
+ 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",
+ }
+ for word in tempText:
+ word = manualMap.setdefault(word, word)
+ if word not in articles:
+ outText.append(word)
+ for wordId, word in enumerate(outText):
+ if word in contractions:
+ outText[wordId] = contractions[word]
+ outText = ' '.join(outText)
+ return outText
+
+
+def hit_calculate(result, dataset_name, anls_threshold=0.5):
+ if listinstr(['TextVQA'], dataset_name):
+ return [np.mean(x['match']) for x in result]
+ elif listinstr(['DocVQA', 'InfoVQA'], dataset_name):
+ return [0.0 if 1 - np.min(x['match']) < anls_threshold else 1 - np.min(x['match']) for x in result]
+ elif listinstr(['ChartQA', 'OCRVQA'], dataset_name):
+ return [np.max(x['match']) for x in result]
+ else: # default using vqa_score to calculate score
+ return [np.mean(x['match']) for x in result]
+
+
+# https://github.com/google-research/pix2struct/blob/main/pix2struct/metrics.py#L81
+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 = str(prediction)
+ target = str(target)
+ 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 levenshtein_distance(s1, s2):
+ if len(s1) > len(s2):
+ s1, s2 = s2, s1
+
+ distances = range(len(s1) + 1)
+ for i2, c2 in enumerate(s2):
+ distances_ = [i2 + 1]
+ for i1, c1 in enumerate(s1):
+ if c1 == c2:
+ distances_.append(distances[i1])
+ else:
+ distances_.append(1 + min((distances[i1], distances[i1 + 1], distances_[-1])))
+ distances = distances_
+ return distances[-1]
+
+
+def anls_compute(groundtruth, prediction):
+ gt_answer = ' '.join(groundtruth.strip().lower().split())
+ det_answer = ' '.join(prediction.strip().lower().split())
+ dist = levenshtein_distance(gt_answer, det_answer)
+ length = max(len(groundtruth.upper()), len(prediction.upper()))
+ values = 0.0 if length == 0 else float(dist) / float(length)
+ return values
+
+
+def process_answer(answer):
+ answer = answer.replace('\n', ' ')
+ answer = answer.replace('\t', ' ')
+ answer = answer.strip()
+ answer = process_punctuation(answer)
+ answer = _process_digit_article(answer)
+ return answer
+
+
+def process_line(line, method='vqa_score'):
+ ret = {}
+ if istype(line['answer'], list):
+ answers = eval(line['answer'])
+ else:
+ answers = [line['answer']]
+ if method == 'vqa_score':
+ ret['gt'] = [process_answer(x) for x in answers]
+ ret['pred'] = process_answer(line['prediction'])
+ ret['match'] = []
+ for current_idx, gtAnsDatum in enumerate(ret['gt']):
+ otherGTAns = [
+ item for ret_gt_idx, item in enumerate(ret['gt'])
+ if ret_gt_idx != current_idx
+ ]
+ matchingAns = [
+ item for item in otherGTAns if item == ret['pred']
+ ]
+ acc = min(1, float(len(matchingAns)) / 3)
+ ret['match'].append(acc)
+ elif method == 'anls':
+ ret['gt'] = answers
+ ret['pred'] = line['prediction']
+ ret['match'] = [anls_compute(x, ret['pred']) for x in ret['gt']]
+ elif method == 'relaxed_accuracy':
+ ret['gt'] = answers
+ ret['pred'] = line['prediction'].strip()
+ ret['match'] = [relaxed_correctness(ret['pred'], x) for x in ret['gt']]
+ elif method == 'accuracy':
+ ret['gt'] = answers
+ ret['pred'] = line['prediction'].strip()
+ ret['match'] = [(1.0 if (x.strip().lower() == ret['pred'].strip().lower()) else 0.0) for x in ret['gt']]
+ else: # default using vqa_score to calculate score
+ ret['gt'] = [process_answer(x) for x in answers]
+ ret['pred'] = process_answer(line['prediction'])
+ ret['match'] = [x == ret['pred'] for x in ret['gt']]
+
+ return ret
diff --git a/vlmeval/dataset/utils/wemath.py b/vlmeval/dataset/utils/wemath.py
new file mode 100644
index 0000000000000000000000000000000000000000..d6a4b2b84e66bfea3dbc846336bae1a0a541a9fd
--- /dev/null
+++ b/vlmeval/dataset/utils/wemath.py
@@ -0,0 +1,896 @@
+# pylint: skip-file
+
+import pandas as pd
+import json
+import numpy as np
+import os
+import argparse
+
+# four_dimensional_metrics.py
+
+
+# Function to evaluate steps
+def evaluate_evaluate_steps(json, steps): # noqa
+ jokers = [json[[f'joker_{i}', f'knowledge concept_{i}']] for i in range(1, steps + 1)]
+ for i in range(steps):
+ jokers[i].rename(
+ columns={f'joker_{i + 1}': 'joker', f'knowledge concept_{i + 1}': 'knowledge_concept'},
+ inplace=True,
+ )
+ concatenated_steps = pd.concat(jokers, axis=0)
+ return concatenated_steps
+
+
+# Function to load and process JSON data
+def load_and_process_data(filepath):
+ df = pd.read_excel(filepath)
+ if 'hit' not in df.columns:
+ df['processed_answer'] = (
+ df['prediction']
+ .str.split('Answer')
+ .str[-1]
+ .str.strip()
+ .str.replace(r'[>><<:.]', '', regex=True)
+ .str.strip()
+ )
+ df['processed_answer'] = df['processed_answer'].apply(lambda x: x[0] if x and x[0] in 'ABCDEFGH' else None)
+ df['joker'] = df['processed_answer'] == df['answer']
+ else:
+ df['joker'] = df['hit'].astype(bool)
+ return df
+
+
+# Function to process steps data and merge results
+def evaluate_process_steps_data(df, steps):
+ steps_data = {f'{steps}steps_{i}': df[df['key'] == f'{steps}steps_{i}'] for i in range(1, steps + 1)}
+ steps_data[f'{steps}steps_multi'] = df[df['key'] == f'{steps}steps_multi']
+ for key, data in steps_data.items():
+ data.columns = [col + f'_{key.split("_")[-1]}' for col in data.columns]
+ merged_data = steps_data[f'{steps}steps_1']
+ for i in range(2, steps + 1):
+ merged_data = pd.merge(
+ merged_data, steps_data[f'{steps}steps_{i}'], left_on=f'ID_1', right_on=f'ID_{i}', how='left' # noqa
+ )
+ merged_data = pd.merge(
+ merged_data, steps_data[f'{steps}steps_multi'], left_on=f'ID_1', right_on='ID_multi', how='left' # noqa
+ )
+ return merged_data
+
+
+# Function to calculate evaluation metrics
+def evaluate_calculate_metrics(merged_2steps, merged_3steps):
+ metrics = {}
+ metrics['steps2_filtered_rows_1_loose'] = merged_2steps[
+ ((merged_2steps['joker_1'] == False) & (merged_2steps['joker_2'] == False)) # noqa
+ & (merged_2steps['joker_multi'] == True) # noqa
+ ]
+ metrics['steps2_filtered_rows_1_strict'] = merged_2steps[
+ ((merged_2steps['joker_1'] == False) | (merged_2steps['joker_2'] == False)) # noqa
+ & (merged_2steps['joker_multi'] == True) # noqa
+ ]
+ metrics['steps2_filtered_rows_2'] = merged_2steps[
+ ((merged_2steps['joker_1'] == True) & (merged_2steps['joker_2'] == True)) # noqa
+ & (merged_2steps['joker_multi'] == False) # noqa
+ ]
+ metrics['steps2_filtered_rows_3'] = merged_2steps[
+ ((merged_2steps['joker_1'] == False) | (merged_2steps['joker_2'] == False)) # noqa
+ & (merged_2steps['joker_multi'] == False) # noqa
+ ]
+ metrics['steps2_filtered_rows_4_loose'] = merged_2steps[
+ ((merged_2steps['joker_1'] == True) | (merged_2steps['joker_2'] == True))
+ & (merged_2steps['joker_multi'] == True)
+ ]
+ metrics['steps2_filtered_rows_4_strict'] = merged_2steps[
+ ((merged_2steps['joker_1'] == True) & (merged_2steps['joker_2'] == True))
+ & (merged_2steps['joker_multi'] == True)
+ ]
+ metrics['steps3_filtered_rows_1_loose'] = merged_3steps[
+ (
+ (merged_3steps['joker_1'] == False)
+ & (merged_3steps['joker_2'] == False)
+ & (merged_3steps['joker_3'] == False)
+ )
+ & (merged_3steps['joker_multi'] == True)
+ ]
+ metrics['steps3_filtered_rows_1_strict'] = merged_3steps[
+ (
+ (merged_3steps['joker_1'] == False)
+ | (merged_3steps['joker_2'] == False)
+ | (merged_3steps['joker_3'] == False)
+ )
+ & (merged_3steps['joker_multi'] == True)
+ ]
+ metrics['steps3_filtered_rows_2'] = merged_3steps[
+ ((merged_3steps['joker_1'] == True) & (merged_3steps['joker_2'] == True) & (merged_3steps['joker_3'] == True))
+ & (merged_3steps['joker_multi'] == False)
+ ]
+ metrics['steps3_filtered_rows_3'] = merged_3steps[
+ (
+ (merged_3steps['joker_1'] == False)
+ | (merged_3steps['joker_2'] == False)
+ | (merged_3steps['joker_3'] == False)
+ )
+ & (merged_3steps['joker_multi'] == False)
+ ]
+ metrics['steps3_filtered_rows_4_loose'] = merged_3steps[
+ ((merged_3steps['joker_1'] == True) | (merged_3steps['joker_2'] == True) | (merged_3steps['joker_3'] == True))
+ & (merged_3steps['joker_multi'] == True)
+ ]
+ metrics['steps3_filtered_rows_4_strict'] = merged_3steps[
+ ((merged_3steps['joker_1'] == True) & (merged_3steps['joker_2'] == True) & (merged_3steps['joker_3'] == True))
+ & (merged_3steps['joker_multi'] == True)
+ ]
+ # metrics.to_csv("/Users/mac/Desktop/测试结果/error_anal/csv/gpt4o-0626.csv", index = False)
+ return metrics
+
+
+# Function to compute evaluation rates and final scores
+def evaluate_compute_final_scores(metrics, total_count):
+ total_counts = {
+ 'InadequateGeneralization': len(metrics['steps2_filtered_rows_2']) + len(metrics['steps3_filtered_rows_2']),
+ 'InsufficientKnowledge': len(metrics['steps2_filtered_rows_3']) + len(metrics['steps3_filtered_rows_3']),
+ 'CompleteMastery_loose': len(metrics['steps2_filtered_rows_4_loose'])
+ + len(metrics['steps3_filtered_rows_4_loose']),
+ 'CompleteMastery_strict': len(metrics['steps2_filtered_rows_4_strict'])
+ + len(metrics['steps3_filtered_rows_4_strict']),
+ 'RoteMemorization_loose': len(metrics['steps2_filtered_rows_1_loose'])
+ + len(metrics['steps3_filtered_rows_1_loose']),
+ 'RoteMemorization_strict': len(metrics['steps2_filtered_rows_1_strict'])
+ + len(metrics['steps3_filtered_rows_1_strict']),
+ }
+ rates = {
+ 'InadequateGeneralization_rate': "{:.2%}".format(total_counts['InadequateGeneralization'] / total_count),
+ 'InsufficientKnowledge_rate': "{:.2%}".format(total_counts['InsufficientKnowledge'] / total_count),
+ 'CompleteMastery_loose_rate': "{:.2%}".format(total_counts['CompleteMastery_loose'] / total_count),
+ 'CompleteMastery_strict_rate': "{:.2%}".format(total_counts['CompleteMastery_strict'] / total_count),
+ 'RoteMemorization_loose_rate': "{:.2%}".format(
+ total_counts['RoteMemorization_loose']
+ / (total_counts['CompleteMastery_loose'] + total_counts['RoteMemorization_loose'])
+ ),
+ 'RoteMemorization_strict_rate': "{:.2%}".format(
+ total_counts['RoteMemorization_strict']
+ / (total_counts['CompleteMastery_strict'] + total_counts['RoteMemorization_strict'])
+ ),
+ }
+ return total_counts, rates
+
+
+# Function to update main results DataFrame
+def evaluate_update_main_results_df(main_results_df, total_counts, rates):
+
+ final_score_loose = "{:.2%}".format(
+ (
+ 525
+ - 0.5 * total_counts['InadequateGeneralization']
+ - total_counts['RoteMemorization_loose']
+ - total_counts['InsufficientKnowledge']
+ )
+ / 525
+ )
+ final_score_strict = "{:.2%}".format(
+ (
+ 525
+ - 0.5 * total_counts['InadequateGeneralization']
+ - total_counts['RoteMemorization_strict']
+ - total_counts['InsufficientKnowledge']
+ )
+ / 525
+ )
+
+ new_row = {
+ # 'Model': model,
+ 'Score (Strict)': final_score_strict,
+ 'InsufficientKnowledge (Strict)': f"{rates['InsufficientKnowledge_rate']} ({total_counts['InsufficientKnowledge']})",
+ 'InadequateGeneralization (Strict)': f"{rates['InadequateGeneralization_rate']} ({total_counts['InadequateGeneralization']})",
+ 'CompleteMastery (Strict)': f"{rates['CompleteMastery_strict_rate']} ({total_counts['CompleteMastery_strict']})",
+ 'RoteMemorization (Strict)': f"{rates['RoteMemorization_strict_rate']} ({total_counts['RoteMemorization_strict']})",
+ 'Score (Loose)': final_score_loose,
+ 'InsufficientKnowledge (Loose)': f"{rates['InsufficientKnowledge_rate']} ({total_counts['InsufficientKnowledge']})",
+ 'InadequateGeneralization (Loose)': f"{rates['InadequateGeneralization_rate']} ({total_counts['InadequateGeneralization']})",
+ 'CompleteMastery (Loose)': f"{rates['CompleteMastery_loose_rate']} ({total_counts['CompleteMastery_loose']})",
+ 'RoteMemorization (Loose)': f"{rates['RoteMemorization_loose_rate']} ({total_counts['RoteMemorization_loose']})",
+ }
+ main_results_df = main_results_df._append(new_row, ignore_index=True)
+ return main_results_df
+
+
+# Main function to evaluate models
+def wemath_evaluate_models(output_json, main_results_csv_path=None):
+
+ main_results_df = pd.DataFrame(
+ columns=[
+ 'Model',
+ 'Score (Strict)',
+ 'InsufficientKnowledge (Strict)',
+ 'InadequateGeneralization (Strict)',
+ 'CompleteMastery (Strict)',
+ 'RoteMemorization (Strict)',
+ 'Score (Loose)',
+ 'InsufficientKnowledge (Loose)',
+ 'InadequateGeneralization (Loose)',
+ 'CompleteMastery (Loose)',
+ 'RoteMemorization (Loose)',
+ ]
+ )
+
+ # print(f"Evaluating model: {model_name}, JSON path: {output_json}")
+ data = load_and_process_data(output_json)
+ data_2steps = data[data['key'].str.contains('2steps')]
+ data_3steps = data[data['key'].str.contains('3steps')]
+ merged_2steps = evaluate_process_steps_data(data_2steps, 2)
+ merged_3steps = evaluate_process_steps_data(data_3steps, 3)
+
+ metrics = evaluate_calculate_metrics(merged_2steps, merged_3steps)
+ total_counts, rates = evaluate_compute_final_scores(metrics, total_count=525)
+
+ main_results_df = evaluate_update_main_results_df(main_results_df, total_counts, rates)
+
+ print(main_results_df.to_string(index=False))
+ if main_results_csv_path is not None:
+ main_results_df.to_csv(main_results_csv_path, index=False)
+ print("Evaluation completed and results saved to CSV.")
+ return main_results_df.to_dict()
+
+
+### Accuracy.py
+# Function to load knowledge structure nodes
+def load_knowledge_structure_nodes(filepath):
+ # with open(filepath, "r") as file:
+ # nodes = json.load(file)
+ nodes = knowledge_structure_nodes
+ nodes = pd.DataFrame(nodes)
+ nodes['final_key'] = nodes['full node'].str.split('_').str[-1]
+ nodes['root_2'] = nodes['full node'].str.split('_').str[1]
+ return nodes
+
+
+# Function to evaluate steps
+def accuracy_evaluate_steps(json, steps, nodes):
+ jokers = [json[[f'joker_{i}', f'knowledge concept_{i}']] for i in range(1, steps + 1)]
+ for i in range(steps):
+ jokers[i] = pd.merge(
+ jokers[i],
+ nodes[['final_key', 'full node', 'root_2']],
+ left_on=f'knowledge concept_{i + 1}',
+ right_on='final_key',
+ how='left',
+ )
+ jokers[i].rename(
+ columns={f'joker_{i + 1}': 'joker', f'knowledge concept_{i + 1}': 'knowledge_concept'},
+ inplace=True,
+ )
+ concatenated_steps = pd.concat(jokers, axis=0)
+ return concatenated_steps
+
+
+# Function to process steps data and merge results
+def accuracy_process_steps_data(df, steps):
+ steps_data = {f'{steps}steps_{i}': df[df['key'] == f'{steps}steps_{i}'] for i in range(1, steps + 1)}
+ steps_data[f'{steps}steps_multi'] = df[df['key'] == f'{steps}steps_multi']
+ for key, data in steps_data.items():
+ data.columns = [col + f'_{key.split("_")[-1]}' for col in data.columns]
+ merged_data = steps_data[f'{steps}steps_1']
+ for i in range(2, steps + 1):
+ merged_data = pd.merge(
+ merged_data, steps_data[f'{steps}steps_{i}'], left_on=f'ID_1', right_on=f'ID_{i}', how='left'
+ )
+ merged_data = pd.merge(
+ merged_data, steps_data[f'{steps}steps_multi'], left_on=f'ID_1', right_on='ID_multi', how='left'
+ )
+ return merged_data
+
+
+# Function to update main results DataFrame
+def accuracy_update_main_results_df(nodes, main_results_df, concatenated_data, merged_2steps, merged_3steps):
+ One_step_acc = "{:.2%}".format(concatenated_data['joker'].mean())
+ Two_step_acc = "{:.2%}".format(merged_2steps['joker_multi'].mean())
+ Three_step_acc = "{:.2%}".format(merged_3steps['joker_multi'].mean())
+
+ new_row = {
+ # 'Model': model_name,
+ 'One-step(S1)': One_step_acc,
+ 'Two-step(S2)': Two_step_acc,
+ 'Three-step(S3)': Three_step_acc,
+ }
+ # Calculate rates according to Nodes
+ nodes['final_rode'] = nodes['full node'].str.split('_').str[-1]
+ csv_final_score = concatenated_data.groupby('final_key')['joker'].mean()
+ csv_final_score = pd.merge(nodes, csv_final_score, left_on='final_rode', right_on='final_key', how='left')
+
+ new_row.update(csv_final_score.groupby('root2')['joker'].mean().apply(lambda x: "{:.2%}".format(x)).to_dict())
+ main_results_df = main_results_df._append(new_row, ignore_index=True)
+
+ return main_results_df
+
+
+# Main function to evaluate models
+def wemath_accuracy(output_json, main_results_csv_path=None):
+
+ # nodes = load_knowledge_structure_nodes(knowledge_structure_nodes_path)
+ nodes = knowledge_structure_nodes
+ nodes = pd.DataFrame(nodes)
+ nodes['final_key'] = nodes['full node'].str.split('_').str[-1]
+ nodes['root_2'] = nodes['full node'].str.split('_').str[1]
+
+ main_results_df = pd.DataFrame(
+ columns=[
+ 'Model',
+ 'One-step(S1)',
+ 'Two-step(S2)',
+ 'Three-step(S3)',
+ 'Understanding and Conversion of Units',
+ 'Angles and Length',
+ 'Calculation of Plane Figures',
+ 'Understanding of Plane Figures',
+ 'Calculation of Solid Figures',
+ 'Understanding of Solid Figures',
+ 'Basic Transformations of Figures',
+ 'Cutting and Combining of Figures',
+ 'Direction',
+ 'Position',
+ 'Route Map',
+ 'Correspondence of Coordinates and Positions',
+ ]
+ )
+
+ # print(f"Evaluating model: {model_name}, JSON path: {output_json}")
+ data = load_and_process_data(output_json)
+ data_2steps = data[data['key'].str.contains('2steps')]
+ data_3steps = data[data['key'].str.contains('3steps')]
+ merged_2steps = accuracy_process_steps_data(data_2steps, 2)
+ merged_3steps = accuracy_process_steps_data(data_3steps, 3)
+
+ concatenated_data = pd.concat(
+ [accuracy_evaluate_steps(merged_2steps, 2, nodes), accuracy_evaluate_steps(merged_3steps, 3, nodes)],
+ axis=0,
+ )
+ main_results_df = accuracy_update_main_results_df(
+ nodes, main_results_df, concatenated_data, merged_2steps, merged_3steps
+ )
+
+ print(main_results_df.to_string(index=False))
+ if main_results_csv_path is not None:
+ main_results_df.to_csv(main_results_csv_path, index=False)
+ print("Evaluation completed and results saved to CSV.")
+
+ return main_results_df.to_dict()
+
+
+knowledge_structure_nodes = [
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Measurement",
+ "root2": "Understanding and Conversion of Units",
+ "root3": "Conversion Rates and Calculations Between Area Units",
+ "root4": None,
+ "full node": "Measurement_Understanding and Conversion of Units_Conversion Rates and Calculations Between Area Units",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Measurement",
+ "root2": "Understanding and Conversion of Units",
+ "root3": "Conversion Rates and Calculations Between Volume Units (Including Liters and Milliliters)",
+ "root4": None,
+ "full node": "Measurement_Understanding and Conversion of Units_Conversion Rates and Calculations Between Volume Units (Including Liters and Milliliters)",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Measurement",
+ "root2": "Understanding and Conversion of Units",
+ "root3": "Conversion Rates and Calculations Between Length Units",
+ "root4": None,
+ "full node": "Measurement_Understanding and Conversion of Units_Conversion Rates and Calculations Between Length Units",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Measurement",
+ "root2": "Angles and Length",
+ "root3": "Understanding Angles (Using a Protractor)",
+ "root4": None,
+ "full node": "Measurement_Angles and Length_Understanding Angles (Using a Protractor)",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Measurement",
+ "root2": "Angles and Length",
+ "root3": "Understanding Length (Using a Ruler)",
+ "root4": None,
+ "full node": "Measurement_Angles and Length_Understanding Length (Using a Ruler)",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Solid Figures",
+ "root2": "Calculation of Solid Figures",
+ "root3": "Calculation of Surface Area of Solid Figures",
+ "root4": "Surface Area of Cylinders",
+ "full node": "Solid Figures_Calculation of Solid Figures_Calculation of Surface Area of Solid Figures_Surface Area of Cylinders",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Solid Figures",
+ "root2": "Calculation of Solid Figures",
+ "root3": "Calculation of Surface Area of Solid Figures",
+ "root4": "Surface Area of Rectangular Cuboids",
+ "full node": "Solid Figures_Calculation of Solid Figures_Calculation of Surface Area of Solid Figures_Surface Area of Rectangular Cuboids",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Solid Figures",
+ "root2": "Calculation of Solid Figures",
+ "root3": "Calculation of Surface Area of Solid Figures",
+ "root4": "Surface Area of Cubes",
+ "full node": "Solid Figures_Calculation of Solid Figures_Calculation of Surface Area of Solid Figures_Surface Area of Cubes",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Solid Figures",
+ "root2": "Calculation of Solid Figures",
+ "root3": "Calculation of Volume of Solid Figures",
+ "root4": "Volume and Capacity of Cylinders",
+ "full node": "Solid Figures_Calculation of Solid Figures_Calculation of Volume of Solid Figures_Volume and Capacity of Cylinders",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Solid Figures",
+ "root2": "Calculation of Solid Figures",
+ "root3": "Calculation of Volume of Solid Figures",
+ "root4": "Volume and Capacity of Cones",
+ "full node": "Solid Figures_Calculation of Solid Figures_Calculation of Volume of Solid Figures_Volume and Capacity of Cones",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Solid Figures",
+ "root2": "Calculation of Solid Figures",
+ "root3": "Calculation of Volume of Solid Figures",
+ "root4": "Volume and Capacity of Rectangular Cuboids",
+ "full node": "Solid Figures_Calculation of Solid Figures_Calculation of Volume of Solid Figures_Volume and Capacity of Rectangular Cuboids",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Solid Figures",
+ "root2": "Calculation of Solid Figures",
+ "root3": "Calculation of Volume of Solid Figures",
+ "root4": "Volume and Capacity of Cubes",
+ "full node": "Solid Figures_Calculation of Solid Figures_Calculation of Volume of Solid Figures_Volume and Capacity of Cubes",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Solid Figures",
+ "root2": "Understanding of Solid Figures",
+ "root3": "Expanded View of Solids",
+ "root4": "Expanded View of Cylinders",
+ "full node": "Solid Figures_Understanding of Solid Figures_Expanded View of Solids_Expanded View of Cylinders",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Solid Figures",
+ "root2": "Understanding of Solid Figures",
+ "root3": "Expanded View of Solids",
+ "root4": "Expanded View of Rectangular Cuboids",
+ "full node": "Solid Figures_Understanding of Solid Figures_Expanded View of Solids_Expanded View of Rectangular Cuboids",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Solid Figures",
+ "root2": "Understanding of Solid Figures",
+ "root3": "Expanded View of Solids",
+ "root4": "Expanded View of Cubes",
+ "full node": "Solid Figures_Understanding of Solid Figures_Expanded View of Solids_Expanded View of Cubes",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Solid Figures",
+ "root2": "Understanding of Solid Figures",
+ "root3": "Cylinders and Cones",
+ "root4": "Properties of Cylinders",
+ "full node": "Solid Figures_Understanding of Solid Figures_Cylinders and Cones_Properties of Cylinders",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Solid Figures",
+ "root2": "Understanding of Solid Figures",
+ "root3": "Cylinders and Cones",
+ "root4": "Properties of Cones",
+ "full node": "Solid Figures_Understanding of Solid Figures_Cylinders and Cones_Properties of Cones",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Solid Figures",
+ "root2": "Understanding of Solid Figures",
+ "root3": "Rectangular Cuboids and Cubes",
+ "root4": "Properties and Understanding of Rectangular Cuboids",
+ "full node": "Solid Figures_Understanding of Solid Figures_Rectangular Cuboids and Cubes_Properties and Understanding of Rectangular Cuboids",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Solid Figures",
+ "root2": "Understanding of Solid Figures",
+ "root3": "Rectangular Cuboids and Cubes",
+ "root4": "Properties and Understanding of Cubes",
+ "full node": "Solid Figures_Understanding of Solid Figures_Rectangular Cuboids and Cubes_Properties and Understanding of Cubes",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Solid Figures",
+ "root2": "Understanding of Solid Figures",
+ "root3": "Observing Objects",
+ "root4": None,
+ "full node": "Solid Figures_Understanding of Solid Figures_Observing Objects",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Calculation of Plane Figures",
+ "root3": "Sum of Interior Angles of Polygons",
+ "root4": "Sum of Interior Angles of Other Polygons",
+ "full node": "Plane Figures_Calculation of Plane Figures_Sum of Interior Angles of Polygons_Sum of Interior Angles of Other Polygons",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Calculation of Plane Figures",
+ "root3": "Sum of Interior Angles of Polygons",
+ "root4": "Sum of Interior Angles of Triangles",
+ "full node": "Plane Figures_Calculation of Plane Figures_Sum of Interior Angles of Polygons_Sum of Interior Angles of Triangles",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Calculation of Plane Figures",
+ "root3": "Calculation and Comparison of Angles",
+ "root4": None,
+ "full node": "Plane Figures_Calculation of Plane Figures_Calculation and Comparison of Angles",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Calculation of Plane Figures",
+ "root3": "Calculation of Areas",
+ "root4": "Area of Parallelograms",
+ "full node": "Plane Figures_Calculation of Plane Figures_Calculation of Areas_Area of Parallelograms",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Calculation of Plane Figures",
+ "root3": "Calculation of Areas",
+ "root4": "Area of Triangles",
+ "full node": "Plane Figures_Calculation of Plane Figures_Calculation of Areas_Area of Triangles",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Calculation of Plane Figures",
+ "root3": "Calculation of Areas",
+ "root4": "Area of Sectors",
+ "full node": "Plane Figures_Calculation of Plane Figures_Calculation of Areas_Area of Sectors",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Calculation of Plane Figures",
+ "root3": "Calculation of Areas",
+ "root4": "Area of Trapezoids",
+ "full node": "Plane Figures_Calculation of Plane Figures_Calculation of Areas_Area of Trapezoids",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Calculation of Plane Figures",
+ "root3": "Calculation of Areas",
+ "root4": "Area of Circles",
+ "full node": "Plane Figures_Calculation of Plane Figures_Calculation of Areas_Area of Circles",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Calculation of Plane Figures",
+ "root3": "Calculation of Areas",
+ "root4": "Area of Rectangles",
+ "full node": "Plane Figures_Calculation of Plane Figures_Calculation of Areas_Area of Rectangles",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Calculation of Plane Figures",
+ "root3": "Calculation of Areas",
+ "root4": "Area of Squares",
+ "full node": "Plane Figures_Calculation of Plane Figures_Calculation of Areas_Area of Squares",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Calculation of Plane Figures",
+ "root3": "Calculation of Perimeters",
+ "root4": "Perimeter of Parallelograms",
+ "full node": "Plane Figures_Calculation of Plane Figures_Calculation of Perimeters_Perimeter of Parallelograms",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Calculation of Plane Figures",
+ "root3": "Calculation of Perimeters",
+ "root4": "Perimeter of Triangles",
+ "full node": "Plane Figures_Calculation of Plane Figures_Calculation of Perimeters_Perimeter of Triangles",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Calculation of Plane Figures",
+ "root3": "Calculation of Perimeters",
+ "root4": "Perimeter of Trapezoids",
+ "full node": "Plane Figures_Calculation of Plane Figures_Calculation of Perimeters_Perimeter of Trapezoids",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Calculation of Plane Figures",
+ "root3": "Calculation of Perimeters",
+ "root4": "Circumference of Circles",
+ "full node": "Plane Figures_Calculation of Plane Figures_Calculation of Perimeters_Circumference of Circles",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Calculation of Plane Figures",
+ "root3": "Calculation of Perimeters",
+ "root4": "Perimeter of Rectangles",
+ "full node": "Plane Figures_Calculation of Plane Figures_Calculation of Perimeters_Perimeter of Rectangles",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Calculation of Plane Figures",
+ "root3": "Calculation of Perimeters",
+ "root4": "Perimeter of Squares",
+ "full node": "Plane Figures_Calculation of Plane Figures_Calculation of Perimeters_Perimeter of Squares",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Understanding of Plane Figures",
+ "root3": "Polygons",
+ "root4": "Properties and Understanding of Parallelograms",
+ "full node": "Plane Figures_Understanding of Plane Figures_Polygons_Properties and Understanding of Parallelograms",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Understanding of Plane Figures",
+ "root3": "Polygons",
+ "root4": "Properties and Understanding of Triangles",
+ "full node": "Plane Figures_Understanding of Plane Figures_Polygons_Properties and Understanding of Triangles",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Understanding of Plane Figures",
+ "root3": "Polygons",
+ "root4": "Properties and Understanding of Trapezoids",
+ "full node": "Plane Figures_Understanding of Plane Figures_Polygons_Properties and Understanding of Trapezoids",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Understanding of Plane Figures",
+ "root3": "Polygons",
+ "root4": "Properties and Understanding of Rectangles",
+ "full node": "Plane Figures_Understanding of Plane Figures_Polygons_Properties and Understanding of Rectangles",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Understanding of Plane Figures",
+ "root3": "Polygons",
+ "root4": "Properties and Understanding of Squares",
+ "full node": "Plane Figures_Understanding of Plane Figures_Polygons_Properties and Understanding of Squares",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Understanding of Plane Figures",
+ "root3": "Classification and Understanding of Angles",
+ "root4": "Understanding Triangular Rulers",
+ "full node": "Plane Figures_Understanding of Plane Figures_Classification and Understanding of Angles_Understanding Triangular Rulers",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Understanding of Plane Figures",
+ "root3": "Classification and Understanding of Angles",
+ "root4": "Understanding and Representing Angles",
+ "full node": "Plane Figures_Understanding of Plane Figures_Classification and Understanding of Angles_Understanding and Representing Angles",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Understanding of Plane Figures",
+ "root3": "Properties and Understanding of Line Segments",
+ "root4": "Distance Between Two Points",
+ "full node": "Plane Figures_Understanding of Plane Figures_Properties and Understanding of Line Segments_Distance Between Two Points",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Understanding of Plane Figures",
+ "root3": "Properties and Understanding of Line Segments",
+ "root4": "Understanding Line Segments, Lines, and Rays",
+ "full node": "Plane Figures_Understanding of Plane Figures_Properties and Understanding of Line Segments_Understanding Line Segments, Lines, and Rays",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Understanding of Plane Figures",
+ "root3": "Positional Relationships Between Line Segments",
+ "root4": "perpendicularity",
+ "full node": "Plane Figures_Understanding of Plane Figures_Positional Relationships Between Line Segments_perpendicularity",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Understanding of Plane Figures",
+ "root3": "Positional Relationships Between Line Segments",
+ "root4": "Parallel",
+ "full node": "Plane Figures_Understanding of Plane Figures_Positional Relationships Between Line Segments_Parallel",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Understanding of Plane Figures",
+ "root3": "Circles and Sectors",
+ "root4": "Understanding Sectors",
+ "full node": "Plane Figures_Understanding of Plane Figures_Circles and Sectors_Understanding Sectors",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Understanding of Plane Figures",
+ "root3": "Circles and Sectors",
+ "root4": "Understanding Circles",
+ "full node": "Plane Figures_Understanding of Plane Figures_Circles and Sectors_Understanding Circles",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Plane Figures",
+ "root2": "Understanding of Plane Figures",
+ "root3": "Observing Figures",
+ "root4": None,
+ "full node": "Plane Figures_Understanding of Plane Figures_Observing Figures",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Transformation and Motion of Figures",
+ "root2": "Basic Transformations of Figures",
+ "root3": "Axial Symmetry",
+ "root4": None,
+ "full node": "Transformation and Motion of Figures_Basic Transformations of Figures_Axial Symmetry",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Transformation and Motion of Figures",
+ "root2": "Basic Transformations of Figures",
+ "root3": "Translation",
+ "root4": None,
+ "full node": "Transformation and Motion of Figures_Basic Transformations of Figures_Translation",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Transformation and Motion of Figures",
+ "root2": "Basic Transformations of Figures",
+ "root3": "Rotation",
+ "root4": None,
+ "full node": "Transformation and Motion of Figures_Basic Transformations of Figures_Rotation",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Transformation and Motion of Figures",
+ "root2": "Cutting and Combining of Figures",
+ "root3": "Combining and Dividing Solids",
+ "root4": None,
+ "full node": "Transformation and Motion of Figures_Cutting and Combining of Figures_Combining and Dividing Solids",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Transformation and Motion of Figures",
+ "root2": "Cutting and Combining of Figures",
+ "root3": "Combining Plane Figures",
+ "root4": "Division of Plane Figures",
+ "full node": "Transformation and Motion of Figures_Cutting and Combining of Figures_Combining Plane Figures_Division of Plane Figures",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Transformation and Motion of Figures",
+ "root2": "Cutting and Combining of Figures",
+ "root3": "Combining Plane Figures",
+ "root4": "Combining Plane Figures",
+ "full node": "Transformation and Motion of Figures_Cutting and Combining of Figures_Combining Plane Figures_Combining Plane Figures",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Transformation and Motion of Figures",
+ "root2": "Cutting and Combining of Figures",
+ "root3": "Combining Plane Figures",
+ "root4": "Tessellation of Figures",
+ "full node": "Transformation and Motion of Figures_Cutting and Combining of Figures_Combining Plane Figures_Tessellation of Figures",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Transformation and Motion of Figures",
+ "root2": "Cutting and Combining of Figures",
+ "root3": "Combining Plane Figures",
+ "root4": "Folding Problems of Figures",
+ "full node": "Transformation and Motion of Figures_Cutting and Combining of Figures_Combining Plane Figures_Folding Problems of Figures",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Position and Direction",
+ "root2": "Direction",
+ "root3": "Southeast, Southwest, Northeast, Northwest Directions",
+ "root4": None,
+ "full node": "Position and Direction_Direction_Southeast, Southwest, Northeast, Northwest Directions",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Position and Direction",
+ "root2": "Direction",
+ "root3": "Cardinal Directions (East, South, West, North)",
+ "root4": None,
+ "full node": "Position and Direction_Direction_Cardinal Directions (East, South, West, North)",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Position and Direction",
+ "root2": "Route Map",
+ "root3": "Determining the Positions of Objects Based on Direction, Angle, and Distance",
+ "root4": None,
+ "full node": "Position and Direction_Route Map_Determining the Positions of Objects Based on Direction, Angle, and Distance",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Position and Direction",
+ "root2": "Route Map",
+ "root3": "Describing Simple Routes Based on Direction and Distance",
+ "root4": None,
+ "full node": "Position and Direction_Route Map_Describing Simple Routes Based on Direction and Distance",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Position and Direction",
+ "root2": "Correspondence of Coordinates and Positions",
+ "root3": "Representing Positions Using Ordered Pairs",
+ "root4": None,
+ "full node": "Position and Direction_Correspondence of Coordinates and Positions_Representing Positions Using Ordered Pairs",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Position and Direction",
+ "root2": "Correspondence of Coordinates and Positions",
+ "root3": "Finding Positions Based on Ordered Pairs",
+ "root4": None,
+ "full node": "Position and Direction_Correspondence of Coordinates and Positions_Finding Positions Based on Ordered Pairs",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Position and Direction",
+ "root2": "Position",
+ "root3": "Front-Back Position",
+ "root4": None,
+ "full node": "Position and Direction_Position_Front-Back Position",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Position and Direction",
+ "root2": "Position",
+ "root3": "Up-Down Position",
+ "root4": None,
+ "full node": "Position and Direction_Position_Up-Down Position",
+ },
+ {
+ "root0": "Geometry and Figures",
+ "root1": "Position and Direction",
+ "root2": "Position",
+ "root3": "Left-Right Position",
+ "root4": None,
+ "full node": "Position and Direction_Position_Left-Right Position",
+ },
+]
diff --git a/vlmeval/dataset/utils/worldsense.py b/vlmeval/dataset/utils/worldsense.py
new file mode 100644
index 0000000000000000000000000000000000000000..a1f8acefa49337cf34c6f7c449c5cdaf78800d47
--- /dev/null
+++ b/vlmeval/dataset/utils/worldsense.py
@@ -0,0 +1,238 @@
+from ...smp import *
+from .multiple_choice import extract_answer_from_item
+import numpy as np
+import re
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+DURATIONS = [
+ "<1min",
+ "1-2min",
+ "2-4min",
+ "4-6min",
+ "6-8min",
+ ">8min"
+]
+
+DOMAINS = [
+ 'Tech & Science',
+ 'Culture & Politics',
+ 'Daily Life',
+ 'Film & TV',
+ 'Performance',
+ 'Games',
+ 'Sports',
+ 'Music',
+]
+
+SUB_CATEGORIES = [
+ "Academic Lectures",
+ "Auto",
+ "Software",
+ "Physics",
+ "Climate Change",
+ "Space Missions",
+ "Chemistry",
+ "Engineering Projects",
+ "Biology",
+ "Science Explainers",
+ "Artificial Intelligence",
+ "Astronomy",
+ "Tech Reviews",
+ "Editorials",
+ "Politics",
+ "Historical Analysis",
+ "Social Commentary",
+ "Book Reviews",
+ "Cultural Explainers",
+ "Drawing Tutorials",
+ "Celebrity Interviews",
+ "Art Exhibitions",
+ "Fashion",
+ "Travel",
+ "Daily Vlogs",
+ "Cooking",
+ "Pranks",
+ "Camping",
+ "Nutrition & Health",
+ "Home Improvement",
+ "Painting & Photography",
+ "Unboxing Videos",
+ "Family Vlogs",
+ "DIY & Crafts",
+ "Skincare & Makeup",
+ "Documentaries",
+ "Film Trailers",
+ "Event Livestreams",
+ "Short Films",
+ "Documentary Profiles",
+ "Movie Reviews",
+ "World News",
+ "Talks",
+ "Parodies",
+ "Storytime",
+ "Stand-up",
+ "Sketches",
+ "FPS Game",
+ "Casual Game",
+ "Role Playing Game",
+ "Sports Game",
+ "Basketball",
+ "Racing",
+ "Football",
+ "Bowling Ball",
+ "Soccer",
+ "Motorsport",
+ "swimming",
+ "Boxing",
+ "Other Sports",
+ "Fitness",
+ "Fishing",
+ "Hiking",
+ "Covers",
+ "Music Videos",
+ "Remixes",
+ "Walkthroughs"
+]
+
+TASK_DOMAINS = [
+ 'Recognition',
+ 'Understanding',
+ 'Reasoning'
+]
+
+TASK_CATEGORIES = [
+ "Anomaly Recognition",
+ "Event Recognition",
+ "Attribute Recognition",
+ "Human Interaction",
+ "Temporal Localization",
+ "Video Emotions",
+ "Event Sorting",
+ "Hallucination",
+ "Text and Diagram Understanding",
+ "Attribute Reasoning",
+ "Causal Reasoning",
+ "Object Counting",
+ "Action Counting",
+ "Temporal Prediction",
+ "Emotion Change",
+ "Audio Counting",
+ "Scene Recognition",
+ "Human-object Interaction",
+ "Human Emotions",
+ "Object State Change",
+ "Relation Reasoning",
+ "Spatial Relation",
+ "Audio Source Localization",
+ "Audio Recognition",
+ "Object Existence Recognition",
+ "Audio Change"
+]
+
+AUDIO_CLASSES = [
+ "Speech",
+ "Event",
+ "Music",
+]
+
+
+def get_dimension_rating(data_path):
+ data = load(data_path)
+
+ duration_rating = {k: {} for k in DURATIONS}
+ for duration in DURATIONS + ['overall']:
+ duration_rating[duration] = {
+ 'overall': '',
+ 'domain': {k: [] for k in DOMAINS},
+ 'sub_category': {k: [] for k in SUB_CATEGORIES},
+ 'task_domain': {k: [] for k in TASK_DOMAINS},
+ 'task_type': {k: [] for k in TASK_CATEGORIES},
+ 'audio_class': {k: [] for k in AUDIO_CLASSES},
+ }
+
+ for i in range(len(data)):
+
+ domain = data.iloc[i]['domain']
+ sub_ctg = data.iloc[i]['sub_category']
+ task_domain_ctg = data.iloc[i]['task_domain']
+ task_ctg = data.iloc[i]['task_type']
+ audio_ctg = eval(data.iloc[i]['audio_class'])
+
+ duration = data.iloc[i]['duration']
+ score = float(data.iloc[i]['score'])
+
+ duration_rating['overall']['domain'][domain].append(score)
+ duration_rating['overall']['sub_category'][sub_ctg].append(score)
+ duration_rating['overall']['task_domain'][task_domain_ctg].append(score)
+ duration_rating['overall']['task_type'][task_ctg].append(score)
+
+ duration_rating[duration]['domain'][domain].append(score)
+ duration_rating[duration]['sub_category'][sub_ctg].append(score)
+ duration_rating[duration]['task_domain'][task_domain_ctg].append(score)
+ duration_rating[duration]['task_type'][task_ctg].append(score)
+
+ for _audio_ctg in audio_ctg:
+ duration_rating['overall']['audio_class'][_audio_ctg].append(score)
+ duration_rating[duration]['audio_class'][_audio_ctg].append(score)
+
+ for duration in ['overall'] + DURATIONS:
+
+ overall_res_dur = f'{np.mean([x for x in sum(duration_rating[duration]["domain"].values(), []) if x >= 0]):.3f}'
+ duration_rating[duration]['overall'] = overall_res_dur
+
+ for domain in DOMAINS:
+ domain_res_dur = f'{np.mean([x for x in duration_rating[duration]["domain"][domain] if x >= 0]):.3f}'
+ duration_rating[duration]['domain'][domain] = domain_res_dur
+
+ for sub_ctg in SUB_CATEGORIES:
+ sub_res_dur = f'{np.mean([x for x in duration_rating[duration]["sub_category"][sub_ctg] if x >= 0]):.3f}'
+ duration_rating[duration]['sub_category'][sub_ctg] = sub_res_dur
+
+ for task_ctg in TASK_DOMAINS:
+ task_res_dur = f'{np.mean([x for x in duration_rating[duration]["task_domain"][task_ctg] if x >= 0]):.3f}'
+ duration_rating[duration]['task_domain'][task_ctg] = task_res_dur
+
+ for task_ctg in TASK_CATEGORIES:
+ task_res_dur = f'{np.mean([x for x in duration_rating[duration]["task_type"][task_ctg] if x >= 0]):.3f}'
+ duration_rating[duration]['task_type'][task_ctg] = task_res_dur
+
+ for audio_ctg in AUDIO_CLASSES:
+ audio_res_dur = f'{np.mean([x for x in duration_rating[duration]["audio_class"][audio_ctg] if x >= 0]):.3f}'
+ duration_rating[duration]['audio_class'][audio_ctg] = audio_res_dur
+
+ return duration_rating
+
+
+def extract_option(model, input_item, dataset_name):
+ options = input_item['question'].split('\n')[1:]
+ for id, option in enumerate(options):
+ option_id = chr(ord('A') + id) + '.'
+ if option.find(option_id) >= 0:
+ input_item[chr(ord('A') + id)] = option[option.find(option_id) + len(option_id):].strip('. \n')
+ return extract_answer_from_item(model, input_item, dataset_name)['opt']
+
+
+def extract_characters_regex(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:',
+ 'Answer:',
+ 'Option:',
+ ]
+ for answer_prefix in answer_prefixes:
+ s = s.replace(answer_prefix, '')
+
+ if len(s.split()) > 10 and not re.search('[ABCD]', s):
+ return ''
+ matches = re.search(r'[ABCD]', s)
+ if matches is None:
+ return ''
+ return matches[0]
diff --git a/vlmeval/dataset/utils/yorn.py b/vlmeval/dataset/utils/yorn.py
new file mode 100644
index 0000000000000000000000000000000000000000..5dd266b4dcfdb8286e0badca4899badfd9b6eb41
--- /dev/null
+++ b/vlmeval/dataset/utils/yorn.py
@@ -0,0 +1,244 @@
+from ...smp import *
+
+
+def AMBER_rating(data_file):
+ data = load(data_file)
+ stats = defaultdict(dict)
+ lt = len(data)
+ category_mapping = {
+ 'discriminative-attribute-state': 'Attribute',
+ 'discriminative-attribute-number': 'Attribute',
+ 'discriminative-attribute-action': 'Attribute',
+ 'discriminative-hallucination': 'Existence',
+ 'discriminative-relation': 'Relation',
+ 'relation': 'Relation'
+ }
+
+ for i in range(lt):
+ item = data.iloc[i]
+ category = item['category']
+ image_path = item['image_path']
+ score = item['score']
+
+ new_category = category_mapping.get(category, category)
+
+ if image_path not in stats[new_category]:
+ stats[new_category][image_path] = []
+ stats[new_category][image_path].append(score)
+
+ def acc(key):
+ res = stats[key]
+ values = []
+ for val in res.values():
+ values.extend(val)
+ return np.mean(values) * 100
+
+ scores = {}
+ for k in stats:
+ scores[k] = acc(k)
+
+ scores['Avg ACC'] = np.mean(list(scores.values()))
+ ret = d2df(scores)
+ return ret
+
+
+def MME_rating(data_file):
+ data = load(data_file)
+ stats = defaultdict(dict)
+ lt = len(data)
+ for i in range(lt):
+ item = data.iloc[i]
+ category = item['category']
+ image_path = item['image_path']
+ score = item['score']
+ if image_path not in stats[category]:
+ stats[category][image_path] = []
+ stats[category][image_path].append(score)
+
+ def acc(key, mode='normal'):
+ res = stats[key]
+ values = []
+ for val in res.values():
+ if mode == 'normal':
+ values.extend(val)
+ elif mode == 'plus':
+ values.append(val[0] * val[1])
+ return np.mean(values) * 100
+
+ scores = {}
+ for k in stats:
+ scores[k] = acc(k) + acc(k, 'plus')
+
+ super_cates = dict(
+ perception=[
+ 'OCR', 'artwork', 'celebrity', 'color', 'count', 'existence',
+ 'landmark', 'position', 'posters', 'scene'
+ ],
+ reasoning=['code_reasoning', 'commonsense_reasoning', 'numerical_calculation', 'text_translation']
+ )
+
+ ret = {}
+ for sc, cate_list in super_cates.items():
+ base = 0
+ for c in cate_list:
+ base += scores[c]
+ ret[sc] = base
+ ret.update(scores)
+ ret = d2df(ret)
+ return ret
+
+
+def Hallusion_rating(data_file):
+ def calc_fAcc(data):
+ res = defaultdict(list)
+ lt = len(data)
+ for i in range(lt):
+ line = data.iloc[i]
+ res[f"{line['l2-category']}_{line['set_id']}_{line['figure_id']}"].append(line['score'])
+ return np.mean([np.all(x) for x in res.values()]) * 100
+
+ def calc_qAcc(data):
+ res = defaultdict(list)
+ lt = len(data)
+ for i in range(lt):
+ line = data.iloc[i]
+ res[f"{line['l2-category']}_{line['set_id']}_{line['question_id']}"].append(line['score'])
+ return np.mean([np.all(x) for x in res.values()]) * 100
+
+ def calc_aAcc(data):
+ return np.mean(data['score']) * 100
+
+ data = load(data_file)
+ data['set_id'] = [x.split('_')[3] for x in data['index']]
+ data['figure_id'] = [x.split('_')[4] for x in data['index']]
+ data['question_id'] = [x.split('_')[5] for x in data['index']]
+
+ res = dict(split=[], aAcc=[], fAcc=[], qAcc=[])
+ res['split'].append('Overall')
+ res['aAcc'].append(calc_aAcc(data))
+ res['fAcc'].append(calc_fAcc(data))
+ res['qAcc'].append(calc_qAcc(data))
+
+ if 'category' in data:
+ cates = list(set(data['category']))
+ for c in cates:
+ sub = data[data['category'] == c]
+ res['split'].append(c)
+ res['aAcc'].append(calc_aAcc(sub))
+ res['fAcc'].append(calc_fAcc(sub))
+ res['qAcc'].append(calc_qAcc(sub))
+
+ if 'l2-category' in data:
+ cates = list(set(data['l2-category']))
+ for c in cates:
+ sub = data[data['l2-category'] == c]
+ res['split'].append(c)
+ res['aAcc'].append(calc_aAcc(sub))
+ res['fAcc'].append(calc_fAcc(sub))
+ res['qAcc'].append(calc_qAcc(sub))
+ ret = pd.DataFrame(res)
+ return ret
+
+
+def POPE_rating(data_file):
+ def cal_f1_score(y_true, y_pred):
+ tp = sum((y_true == 1) & (y_pred == 1))
+ fp = sum((y_true == 0) & (y_pred == 1))
+ fn = sum((y_true == 1) & (y_pred == 0))
+
+ precision = tp / (tp + fp) if (tp + fp) != 0 else 0
+ recall = tp / (tp + fn) if (tp + fn) != 0 else 0
+ f1_score = 2 * (precision * recall) / (precision + recall) if (precision + recall) != 0 else 0
+ return f1_score, precision, recall
+
+ data = load(data_file)
+ data = data.assign(category=data['category'].str.split(',')).explode('category')
+ data['index'] = range(len(data))
+ res = dict(split=[], Overall=[], acc=[], precision=[], recall=[])
+ y_true = np.array([1 if i == 'Yes' else 0 for i in data['answer']])
+ y_pred = np.array([1 if i == 'Yes' else 0 for i in data['extracted']])
+ f1_score, precision, recall = cal_f1_score(y_true, y_pred)
+ res['split'].append('Overall')
+ res['Overall'].append(f1_score * 100)
+ res['acc'].append(np.mean(data['score']) * 100)
+ res['precision'].append(precision * 100)
+ res['recall'].append(recall * 100)
+
+ if 'category' in data:
+ cates = list(set(data['category']))
+ cates = [c for c in cates if not pd.isna(c)]
+ for c in cates:
+ sub = data[data['category'] == c]
+ y_true = np.array([1 if i == 'Yes' else 0 for i in sub['answer']])
+ y_pred = np.array([1 if i == 'Yes' else 0 for i in sub['extracted']])
+ f1_score, precision, recall = cal_f1_score(y_true, y_pred)
+ res['split'].append(c)
+ res['Overall'].append(f1_score * 100)
+ res['acc'].append(np.mean(sub['score']) * 100)
+ res['precision'].append(precision * 100)
+ res['recall'].append(recall * 100)
+
+ ret = pd.DataFrame(res)
+ return ret
+
+
+def default_rating(data_file):
+ data = load(data_file)
+ res = {}
+ res['Overall'] = np.mean(data['score']) * 100
+ if 'category' in data:
+ cates = list(set(data['category']))
+ cates = [c for c in cates if not pd.isna(c)]
+ cates.sort()
+ for c in cates:
+ sub = data[data['category'] == c]
+ res[c] = np.mean(sub['score']) * 100
+ if 'l2-category' in data:
+ cates = list(set(data['l2-category']))
+ cates = [c for c in cates if not pd.isna(c)]
+ cates.sort()
+ for c in cates:
+ sub = data[data['l2-category'] == c]
+ res[c] = np.mean(sub['score']) * 100
+ ret = d2df(res)
+ return ret
+
+
+def YOrN_match_prompt(line):
+ tmpl = (
+ 'You are an AI assistant who will help me to match an answer with two options of a question. '
+ 'The options are only Yes / No. '
+ 'You are provided with a question and an answer, '
+ 'and you need to find which option (Yes / No) is most similar to the answer. '
+ 'If the meaning of all options are significantly different from the answer, output Unknown. '
+ 'Your should output a single word among the following 3 choices: Yes, No, Unknown.\n'
+ 'Example 1: \n'
+ "Question: Is the word in this image 'Hello'?\nAnswer: The word in this image is 'Hello'.\nYour output: Yes\n"
+ 'Example 2: \n'
+ "Question: Is the word in this image 'Hello'?\n"
+ "Answer: The word in this image is not 'Hello'.\nYour output: No\n"
+ 'Example 3: \n'
+ 'Question: {}?\nAnswer: {}\nYour output: '
+ )
+ return tmpl.format(line['question'], line['prediction'])
+
+
+def YOrN_Extraction(output):
+ s = output.lower()
+ words = process_punctuation(s).split()
+ if 'yes' in words and 'no' not in words:
+ return 'Yes'
+ if 'yes' not in words and 'no' in words:
+ return 'No'
+ return 'Unknown'
+
+
+def YOrN_auxeval(model, line):
+ prompt = YOrN_match_prompt(line)
+ retry = 5
+ for i in range(retry):
+ output = model.generate(prompt, temperature=0.5 * i)
+ ans = YOrN_Extraction(output)
+ if ans != 'Unknown':
+ return ans
+ return 'Unknown'
diff --git a/vlmeval/dataset/vcr.py b/vlmeval/dataset/vcr.py
new file mode 100644
index 0000000000000000000000000000000000000000..c659c60f406eaec1a1c3508bb4ba323efeef29ea
--- /dev/null
+++ b/vlmeval/dataset/vcr.py
@@ -0,0 +1,335 @@
+import uuid
+from functools import partial
+from .image_base import ImageBaseDataset
+from ..smp import *
+
+rouge = None
+nlp_en = None
+nlp_zh = None
+nlp = None
+
+
+def initialize():
+ import evaluate
+ import spacy
+
+ global rouge, nlp_en, nlp_zh, nlp
+
+ try:
+ rouge = evaluate.load('rouge', experiment_id=str(uuid.uuid4()))
+ except Exception as e:
+ logging.critical(f'{type(e)}: {e}')
+ logging.critical('Please first `pip install rouge_score`.')
+
+ try:
+ nlp_en = spacy.load('en_core_web_sm')
+ except Exception as e:
+ logging.warning(f'{type(e)}: {e}')
+ logging.warning('Will automatically download en_core_web_sm via spacy.')
+ spacy.cli.download('en_core_web_sm')
+ nlp_en = spacy.load('en_core_web_sm')
+
+ try:
+ nlp_zh = spacy.load('zh_core_web_sm')
+ except Exception as e:
+ logging.warning(f'{type(e)}: {e}')
+ logging.warning('Will automatically download zh_core_web_sm via spacy.')
+ spacy.cli.download('zh_core_web_sm')
+ nlp_zh = spacy.load('zh_core_web_sm')
+
+ nlp = {'en': nlp_en, 'zh': nlp_zh}
+
+
+def rough_filter(answer_text):
+ if "I can't" in answer_text:
+ return False
+ elif 'I cannot' in answer_text:
+ return False
+ elif 'sorry' in answer_text.lower():
+ return False
+ if '无法' in answer_text:
+ return False
+ elif '抱歉' in answer_text:
+ return False
+ else:
+ return True
+
+
+def zero_template(crossed_text):
+ return {
+ 'crossed_text': crossed_text,
+ 'max_sim_val': 0,
+ 'max_sim_string': '',
+ 'precision': 0,
+ 'recall': 0,
+ 'f1': 0,
+ 'jaccard': 0,
+ 'rouge1': 0,
+ 'exact_match': 0,
+ }
+
+
+def tokenize(text, language):
+ """
+ Tokenize the text and return the tokens.
+
+ Parameters:
+ text (str): The text to tokenize.
+ language (str): The language of the text.
+
+ Returns:
+ list: The list of tokens.
+ """
+ assert language in ['en', 'zh']
+ nlp_language = nlp[language]
+ processed_text = nlp_language(text)
+ return [token.text for token in processed_text]
+
+
+def find_best_match(needle, hay, language, rouge):
+ """
+ Finds the best matching n-gram in the haystack for the given needle.
+
+ Parameters:
+ needle (str): The string to find.
+ hay (str): The text to search within.
+
+ Returns:
+ tuple: The highest similarity value and the best matching string.
+ """
+ assert language in ['en', 'zh']
+ from nltk.util import ngrams
+ from difflib import SequenceMatcher as SM
+
+ tokens_hay = tokenize(hay, language)
+ tokens_needle = tokenize(needle, language)
+
+ splitter = '' if language == 'zh' else ' '
+ ngrams_ = ngrams(tokens_hay, len(tokens_needle))
+ max_sim_val = 0
+ max_sim_string = ''
+ max_sim_ngram = []
+ tokens_needle_set = set(tokens_needle)
+ ngrams_hasjoint = [
+ ngram
+ for ngram in ngrams_
+ if not set(ngram).isdisjoint(tokens_needle_set)
+ ]
+
+ for ngram in ngrams_hasjoint:
+ hay_ngram = splitter.join(ngram)
+ similarity = SM(None, hay_ngram, needle).ratio()
+ if similarity > max_sim_val:
+ max_sim_val = similarity
+ max_sim_string = hay_ngram
+ max_sim_ngram = ngram
+
+ # Evaluate
+ if len(max_sim_ngram) == 0:
+ return {
+ 'crossed_text': needle,
+ 'max_sim_val': 0,
+ 'max_sim_string': '',
+ 'precision': 0,
+ 'recall': 0,
+ 'f1': 0,
+ 'jaccard': 0,
+ 'rouge1': 0,
+ 'exact_match': 0,
+ }
+ pred_set = set(max_sim_ngram)
+ ref_set = set(tokens_needle)
+ correct_tokens = pred_set.intersection(ref_set)
+ len_correct_tokens = len(correct_tokens)
+
+ precision = len_correct_tokens / len(pred_set)
+ recall = len_correct_tokens / len(ref_set)
+ if (precision + recall) == 0:
+ f1 = 0
+ else:
+ f1 = 2 * precision * recall / (precision + recall)
+ union = pred_set.union(ref_set)
+ jaccard = len_correct_tokens / len(union) if len(union) > 0 else 0
+ rouge_1 = rouge.compute(
+ predictions=[max_sim_string],
+ references=[needle],
+ tokenizer=partial(tokenize, language=language),
+ rouge_types=['rouge1'],
+ )['rouge1']
+ exact_match = float(list(max_sim_ngram) == list(tokens_needle))
+ out = {
+ 'crossed_text': needle,
+ 'max_sim_string': max_sim_string,
+ 'max_sim_val': max_sim_val,
+ 'precision': precision,
+ 'recall': recall,
+ 'f1': f1,
+ 'jaccard': jaccard,
+ 'rouge1': rouge_1,
+ 'exact_match': exact_match,
+ }
+ return out
+
+
+def process_match_single_new(
+ image_id, prediction, answer, language, progress
+):
+ """
+ process the inference results for a single image and calculate the metrics
+
+ Parameters:
+ image_id (int): The image id (question id).
+ prediction (str): The prediction text.
+ answer (Union[str, List[str]]): The answer text, or a list of answer texts. The masked n-grams in the image.
+ language (str): The language of the text. Can be "en" or "zh".
+ rouge (rouge): The rouge metric object.
+ progress (multiprocessing.Queue): The progress queue.
+
+ Returns:
+ tuple: The image id (question_id, int) and the result per id (dict of dict of dict).
+ """
+ result_per_id = {image_id: {}}
+ if isinstance(answer, str):
+ answer = eval(answer)
+ assert isinstance(answer, list)
+ result = prediction.split('Assistant: ')[-1]
+ for i, crossed_text in enumerate(answer):
+ if rough_filter(result):
+ find_best_match_result = find_best_match(
+ crossed_text, result, language, rouge
+ )
+ if i == 0:
+ result_per_id[image_id] = {str(i): find_best_match_result}
+ else:
+ result_per_id[image_id][str(i)] = find_best_match_result
+ else:
+ if i == 0:
+ result_per_id[image_id] = {str(i): zero_template(crossed_text)}
+ else:
+ result_per_id[image_id][str(i)] = zero_template(crossed_text)
+ progress.put(1)
+ return image_id, result_per_id
+
+
+class VCRDataset(ImageBaseDataset):
+ TYPE = 'VQA'
+
+ URL_PREFIX = 'https://huggingface.co/datasets/vcr-org'
+
+ DATASET_URL = {
+ 'VCR_EN_EASY_500': f'{URL_PREFIX}/VCR-wiki-en-easy-test-500/resolve/main/VCR-wiki-en-easy-test-500.tsv',
+ 'VCR_EN_EASY_100': f'{URL_PREFIX}/VCR-wiki-en-easy-test-100/resolve/main/VCR-wiki-en-easy-test-100.tsv',
+ 'VCR_EN_EASY_ALL': f'{URL_PREFIX}/VCR-wiki-en-easy-test/resolve/main/VCR-wiki-en-easy-test.tsv',
+ 'VCR_EN_HARD_500': f'{URL_PREFIX}/VCR-wiki-en-hard-test-500/resolve/main/VCR-wiki-en-hard-test-500.tsv',
+ 'VCR_EN_HARD_100': f'{URL_PREFIX}/VCR-wiki-en-hard-test-100/resolve/main/VCR-wiki-en-hard-test-100.tsv',
+ 'VCR_EN_HARD_ALL': f'{URL_PREFIX}/VCR-wiki-en-hard-test/resolve/main/VCR-wiki-en-hard-test.tsv',
+ 'VCR_ZH_EASY_500': f'{URL_PREFIX}/VCR-wiki-zh-easy-test-500/resolve/main/VCR-wiki-zh-easy-test-500.tsv',
+ 'VCR_ZH_EASY_100': f'{URL_PREFIX}/VCR-wiki-zh-easy-test-100/resolve/main/VCR-wiki-zh-easy-test-100.tsv',
+ 'VCR_ZH_EASY_ALL': f'{URL_PREFIX}/VCR-wiki-zh-easy-test/resolve/main/VCR-wiki-zh-easy-test.tsv',
+ 'VCR_ZH_HARD_500': f'{URL_PREFIX}/VCR-wiki-zh-hard-test-500/resolve/main/VCR-wiki-zh-hard-test-500.tsv',
+ 'VCR_ZH_HARD_100': f'{URL_PREFIX}/VCR-wiki-zh-hard-test-100/resolve/main/VCR-wiki-zh-hard-test-100.tsv',
+ 'VCR_ZH_HARD_ALL': f'{URL_PREFIX}/VCR-wiki-zh-hard-test/resolve/main/VCR-wiki-zh-hard-test.tsv',
+ }
+
+ DATASET_MD5 = {
+ 'VCR_EN_EASY_500': 'fd9258db52f8685dc710619a0ea0a261',
+ 'VCR_EN_EASY_100': '9df5d7266683458621ecbe122beb72f0',
+ 'VCR_EN_EASY_ALL': '8a9b96885f251d1c85f42f84073327f1',
+ 'VCR_EN_HARD_500': '0a22a85080b6a1f52b1f95e302d43df4',
+ 'VCR_EN_HARD_100': '1b20f5cbcbeae0b0bec77f7a36143958',
+ 'VCR_EN_HARD_ALL': '2d8b8b1ee0eba0e0b618fd3aa7d9710e',
+ 'VCR_ZH_EASY_500': 'beca5fd54176adf44cf94bd9b50cf048',
+ 'VCR_ZH_EASY_100': '4a86a5678a79844d6d22ab0629c51cd5',
+ 'VCR_ZH_EASY_ALL': '5050fe7f0027ad2068fd4c7f220edaea',
+ 'VCR_ZH_HARD_500': '617e3360f75c54455625cb0a8da5c1e7',
+ 'VCR_ZH_HARD_100': 'b0e38c85f5d5e63894a3b881c372a62b',
+ 'VCR_ZH_HARD_ALL': '54bbfef448206518b03127ef8b61404c',
+ }
+
+ def __init__(self, dataset='VCR_EN_EASY_500', skip_noimg=True):
+ super().__init__(dataset, skip_noimg)
+
+ initialize()
+ self.language = 'en' if 'EN' in dataset else 'zh'
+ self.difficulty = 'easy' if 'EASY' in dataset else 'hard'
+
+ # def build_prompt(self, line):
+ # msgs = super().build_prompt(line)
+ # assert msgs[-1]['type'] == 'text'
+ # if self.language == 'zh':
+ # msgs[-1]['value'] += '图像中被覆盖的文本是什么？请在不输出解释的情况下还原被覆盖的文本。'
+ # else:
+ # msgs[-1]['value'] += ('What is the covered texts in the image? '
+ # 'Please restore the covered texts without outputting the explanations.')
+ # return msgs
+
+ def evaluate(self, eval_file, **judge_kwargs):
+ import multiprocessing
+
+ vcr_score_list = {'Exact_Match': [], 'Jaccard': []}
+ vcr_score = {'Exact_Match': 0, 'Jaccard': 0}
+ logger = get_logger('Evaluation')
+ data = load(eval_file)
+
+ lt = len(data)
+ lines = [data.iloc[i] for i in range(lt)]
+
+ pool = multiprocessing.Pool()
+ manager = multiprocessing.Manager()
+ progress_queue = manager.Queue()
+ results = []
+
+ overall_results = {str(image_id): {} for image_id in range(len(lines))}
+
+ for instance_id, instance in enumerate(lines):
+ results.append(
+ pool.apply_async(
+ process_match_single_new,
+ args=(
+ str(instance_id),
+ instance['prediction'],
+ instance['answer'],
+ self.language,
+ progress_queue,
+ ),
+ )
+ )
+ pool.close()
+
+ # Display progress bar
+ for _ in tqdm(range(len(results))):
+ progress_queue.get()
+
+ pool.join()
+
+ # Merging results into overall_result
+ for result in results:
+ image_id, result_per_id = result.get()
+ overall_results[str(image_id)].update(result_per_id[image_id])
+ for blank_id_str in result_per_id[image_id].keys():
+ vcr_score_list['Exact_Match'].append(
+ result_per_id[image_id][blank_id_str]['exact_match']
+ )
+ vcr_score_list['Jaccard'].append(
+ result_per_id[image_id][blank_id_str]['jaccard']
+ )
+ vcr_score['Exact_Match'] = np.mean(vcr_score_list['Exact_Match'])
+ vcr_score['Jaccard'] = np.mean(vcr_score_list['Jaccard'])
+ results_out = {
+ k: v for i in range(len(results)) for k, v in results[i].get()[1].items()
+ }
+ results_with_metrics = {
+ 'Exact_Match': vcr_score['Exact_Match'],
+ 'Jaccard': vcr_score['Jaccard'],
+ 'Predictions': results_out,
+ }
+ score_pth = eval_file.replace(
+ '.xlsx', f'{self.language}_{self.difficulty}_score.json'
+ )
+ dump(results_with_metrics, score_pth)
+ logger.info(
+ f'VCR successfully finished evaluating {eval_file}, results saved in {score_pth}'
+ )
+ logger.info('Score: ')
+ for key, value in vcr_score.items():
+ logger.info('{}:{}'.format(key, value))
diff --git a/vlmeval/dataset/vdc.py b/vlmeval/dataset/vdc.py
new file mode 100644
index 0000000000000000000000000000000000000000..984154bd7f594f05519bf821280a0fca58593b78
--- /dev/null
+++ b/vlmeval/dataset/vdc.py
@@ -0,0 +1,429 @@
+from huggingface_hub import snapshot_download
+from ..smp import *
+from .video_base import VideoBaseDataset
+from .utils import build_judge, DEBUG_MESSAGE
+from ..utils import track_progress_rich
+import random
+import json
+import ast
+from glob import glob
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+camera_caption_prompts = [
+ "Summary of the view shot, camera movement and changes in shooting angles in the sequence of video frames.",
+ "Describe the camera movements in these frames.",
+ "What are the camera angles and movements throughout the video?",
+ "Summarize the camera actions and perspectives.",
+ "Describe any camera zooms, pans, or angle changes.",
+ "What camera movements are present in these frames?",
+ "Describe the camera's movements, including pans, zooms, and angle changes in these frames.",
+ "Summarize the camera actions and changes in shooting angles during the video.",
+ "Provide a detailed description of the camera's movements and perspectives.",
+ "Describe the camera's actions and how it follows the main subject.",
+ "What are the camera movements and angle shifts in these frames?",
+ "Given these equally spaced frames, provide a comprehensive description of the camera's movements, including any pans, zooms, and changes in shooting angles.",
+ "Describe the camera's movements and angles in detail, explaining how it follows the main subject and changes perspectives.",
+ "Based on these frames, provide a detailed description of the camera's actions, including any pans, zooms, angle shifts, and how it captures the scene.",
+ "Using these frames, describe the camera's movements, including its tracking of the main subject, changes in angles, and any zooms or pans.",
+ "Provide an elaborate description of the camera movements, covering pans, zooms, and changes in shooting angles as shown in these frames."
+]
+
+detailed_caption_prompts = [
+ "The images are given containing equally spaced video frames. Please imagine the video based on the sequence of frames, and provide a faithfully detailed description of this video in more than three sentences.",
+ "You are given a sequence of equally spaced video frames. Based on these frames, imagine the full video and provide a detailed description of what is happening in more than three sentences.",
+ "The following set contains equally spaced video frames. Imagine the video from which these frames were taken and describe it in detail in at least three sentences.",
+ "Below are equally spaced frames from a video. Use these frames to visualize the entire video and provide a detailed description in more than three sentences.",
+ "A sequence of equally spaced video frames is presented. Please imagine the full video and write a faithfully detailed description of the events in more than three sentences.",
+ "The images provided include equally spaced frames from a video. Based on these frames, imagine the video and describe it comprehensively in at least three sentences.",
+ "You are given equally spaced frames from a video. Use these frames to envision the entire video and provide a detailed description of the events in more than three sentences.",
+ "The sequence includes equally spaced frames from a video. Imagine the full video based on these frames and provide a detailed description in more than three sentences.",
+ "The provided images contain equally spaced frames from a video. Visualize the video from these frames and describe it in detail in more than three sentences.",
+ "Here are equally spaced frames from a video. Based on these frames, imagine the video and provide a detailed, faithful description of it in more than three sentences.",
+ "The set of images includes equally spaced video frames. Please imagine the video these frames come from and describe it comprehensively in at least three sentences.",
+ "Describe the video based on these frames in a few sentences.",
+ "What is happening in the video shown in these frames?",
+ "Explain the video using these frames.",
+ "Imagine the video from these frames and describe it in detail in a few sentences.",
+ "Based on these frames, provide a narrative of the video in more than three sentences.",
+ "Describe the events in the video shown by these frames in at least three sentences.",
+ "Visualize the video from these frames and explain what is happening in more than three sentences.",
+ "Describe the sequence of events in the video depicted by these frames in a detailed manner.",
+ "Given these equally spaced frames, imagine the entire video and provide a detailed description of the events, including the setting, characters, and actions, in more than three sentences.",
+ "Visualize the video based on these frames and write a comprehensive description of what happens, describing the beginning, middle, and end in at least three sentences.",
+ "Using these frames as a reference, imagine the full video and provide a thorough description of the plot, including key details and actions, in more than three sentences.",
+ "Based on the sequence of these frames, describe the entire video in detail, mentioning important aspects such as the context, movements, and transitions in more than three sentences.",
+ "Imagine the video that corresponds to these frames and provide an elaborate description, covering the storyline, visual elements, and any notable features in at least three sentences."
+]
+
+background_caption_prompts = [
+ "The images are given containing equally spaced video frames.Summary of the background. This should also include the objects, location, weather, and time.",
+ "Describe the background, including objects, location, weather, and time.",
+ "Summarize the background setting of the video based on these frames.",
+ "What is the environment like in these frames?",
+ "Describe the location and weather in these frames.",
+ "What background objects and settings are visible in these frames?",
+ "Summarize the background of the video, including details about the location, objects, weather, and time.",
+ "Describe the environment shown in these frames, covering objects, location, weather, and time.",
+ "Provide a detailed background description based on these frames, mentioning objects, location, weather, and time.",
+ "Explain the setting of the video, focusing on the background elements like objects, location, weather, and time.",
+ "Describe the overall environment in these frames, including details about objects, location, weather, and time.",
+ "Given these equally spaced frames, provide a comprehensive background description, covering the objects, location, weather, and time of day.",
+ "Imagine the environment from these frames and write a detailed description of the background, including objects, location, weather, and time.",
+ "Based on these frames, describe the setting in detail, mentioning the objects present, the specific location, the weather conditions, and the time of day.",
+ "Provide an elaborate background description based on these frames, covering all aspects of the environment such as objects, location, weather, and time.",
+ "Using these frames as a reference, give a thorough description of the background, including details about the objects, location, weather, and time."
+]
+
+short_caption_prompts = [
+ "Write a one-sentence summary of the video.",
+ "Summarize the video in one concise sentence.",
+ "Provide a brief description of the video in one sentence.",
+ "Describe the main action in the video in one sentence.",
+ "What is the video about? Summarize it in one sentence.",
+ "In one sentence, summarize the key visual elements of the video.",
+ "Provide a one-sentence summary that captures the main subject and action in the video.",
+ "Write a concise one-sentence description that encapsulates the essence of the video.",
+ "Describe the main theme or action of the video in a single sentence.",
+ "What is happening in the video? Provide a one-sentence summary.",
+ "Given these frames, write a brief one-sentence summary that captures the essence of the video's visual and artistic style.",
+ "Summarize the key visual and thematic elements of the video in one concise sentence.",
+ "Provide a one-sentence description that highlights the main subject and action depicted in the video.",
+ "In one sentence, describe the primary visual and artistic elements of the video.",
+ "Write a concise one-sentence summary that encapsulates the main action and visual style of the video.",
+ "Briefly one-sentence Summary of the visual, Photographic and artistic style."
+]
+
+main_object_caption_prompts = [
+ "Description of the main subject actions or status sequence. This suggests including the main subjects (person, object, animal, or none) and their attributes, their action, their position, and movements during the video frames.",
+ "Describe the main subject's actions and movements.",
+ "What is the main object doing in these frames?",
+ "Summarize the primary subject's attributes and actions.",
+ "Describe the main subject's position and movements.",
+ "What actions does the main object take in these frames?",
+ "Describe the main subject, including their attributes and movements throughout the video.",
+ "Provide a detailed description of the main object's actions and positions in these frames.",
+ "Summarize the main subject's actions, attributes, and movements during the video.",
+ "Describe the primary subject's movements and actions in detail.",
+ "What are the main object's attributes and how do they move throughout the video?",
+ "Given these equally spaced frames, provide a comprehensive description of the main subject, including their attributes, actions, positions, and movements.",
+ "Describe the primary object or subject in the video, detailing their attributes, actions, positions, and movements in these frames.",
+ "Based on these frames, provide a detailed description of the main subject, including their attributes, actions, positions, and how they navigate through the video.",
+ "Using these frames, describe the main subject's attributes, actions, and movements, detailing their positions and how they interact with the environment.",
+ "Provide an elaborate description of the main object in the video, covering their attributes, actions, positions, and movements as shown in these frames."
+]
+
+
+class VDC(VideoBaseDataset):
+
+ MD5 = 'df8efe00d7e7a7621807693f762d0016'
+
+ TYPE = 'Video-VQA'
+
+ def __init__(self, dataset='VDC', pack=False, nframe=0, fps=-1, subset='all', limit=1.0):
+ super().__init__(dataset=dataset, pack=pack, nframe=nframe, fps=fps)
+
+ if subset == 'all':
+ pass
+ elif subset == 'breakpoint':
+ self.data = self.data[self.data['caption_type'] == 'breakpoint']
+ elif subset == 'short':
+ self.data = self.data[self.data['caption_type'] == 'short']
+ elif subset == 'detailed':
+ self.data = self.data[self.data['caption_type'] == 'detailed']
+ elif subset == 'background':
+ self.data = self.data[self.data['caption_type'] == 'background']
+ elif subset == 'main_object':
+ self.data = self.data[self.data['caption_type'] == 'main_object']
+ else:
+ raise ValueError(f'Invalid subset: {subset}')
+
+ if limit <= 1.0 and limit > 0:
+ sample_num = int(limit * len(self.data))
+ self.data = self.data.iloc[:sample_num]
+ elif limit > 1.0 and limit < len(self.data):
+ self.data = self.data.iloc[:limit]
+ else:
+ raise ValueError(f'Invalid limit: {limit}')
+
+
+ @classmethod
+ def supported_datasets(cls):
+ return ['VDC']
+
+ def prepare_dataset(self, dataset_name='VDC', repo_id='Enxin/VLMEval-VDC'):
+ def check_integrity(pth):
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+ if md5(data_file) != self.MD5:
+ return False
+ data = load(data_file)
+ for video_pth in data['video']:
+ if not osp.exists(osp.join(pth, 'videos', video_pth)):
+ return False
+ return True
+
+ if os.path.exists(repo_id):
+ dataset_path = repo_id
+ else:
+ cache_path = get_cache_path(repo_id)
+ if cache_path is not None and check_integrity(cache_path):
+ dataset_path = cache_path
+ else:
+ cache_path = snapshot_download(repo_id=repo_id, repo_type="dataset")
+ if not glob(osp.join(cache_path, "video")):
+ tar_files = glob(osp.join(cache_path, "**/*.tar*"), recursive=True)
+
+ def untar_video_data(tar_file, cache_dir):
+ import tarfile
+ with tarfile.open(tar_file, "r") as tar_ref:
+ tar_ref.extractall(cache_dir)
+ print(f"Extracted all files from {tar_file} to {cache_dir}")
+
+ def concat_tar_parts(tar_parts, output_tar):
+ with open(output_tar, "wb") as out_tar:
+ from tqdm import tqdm
+ for part in tqdm(sorted(tar_parts)):
+ with open(part, "rb") as part_file:
+ out_tar.write(part_file.read())
+ print(f"Concatenated parts {tar_parts} into {output_tar}")
+
+ tar_parts_dict = {}
+
+ # Group tar parts together
+ for tar_file in tar_files:
+ base_name = tar_file.split(".tar")[0]
+ if base_name not in tar_parts_dict:
+ tar_parts_dict[base_name] = []
+ tar_parts_dict[base_name].append(tar_file)
+
+ # Concatenate and untar split parts
+ for base_name, parts in tar_parts_dict.items():
+ print(f"Extracting following tar files: {parts}")
+ output_tar = base_name + ".tar"
+ if not osp.exists(output_tar):
+ print('Start concatenating tar files')
+
+ concat_tar_parts(parts, output_tar)
+ print('Finish concatenating tar files')
+
+ if not osp.exists(osp.join(cache_path, osp.basename(base_name))):
+ untar_video_data(output_tar, cache_path)
+ dataset_path = cache_path
+ self.video_path = osp.join(dataset_path, 'videos/')
+ data_file = osp.join(dataset_path, f'{dataset_name}.tsv')
+
+ return dict(data_file=data_file, root=osp.join(dataset_path, 'video'))
+
+ def build_prompt_pack(self, line):
+ if isinstance(line, int):
+ assert line < len(self)
+ video = self.videos[line]
+ elif isinstance(line, pd.Series):
+ video = line['video']
+ elif isinstance(line, str):
+ video = line
+
+ frames = self.save_video_frames(video)
+ message = []
+ for im in frames:
+ message.append(dict(type='image', value=im))
+
+ if self.data['caption_type'] == 'short':
+ prompt = random.choice(short_caption_prompts)
+ elif self.data['caption_type'] == 'detailed':
+ prompt = random.choice(detailed_caption_prompts)
+ elif self.data['caption_type'] == 'background':
+ prompt = random.choice(background_caption_prompts)
+ elif self.data['caption_type'] == 'main_object':
+ prompt = random.choice(main_object_caption_prompts)
+ else:
+ prompt = random.choice(camera_caption_prompts)
+ message.append(dict(type='text', value=prompt, role='user'))
+ return message
+
+ def build_prompt_nopack(self, line, video_llm):
+ """Build prompt for a single line without packing"""
+ if isinstance(line, int):
+ assert line < len(self)
+ line = self.data.iloc[line]
+
+ # 构建提示内容
+ if line['caption_type'] == 'short':
+ prompt = random.choice(short_caption_prompts)
+ elif line['caption_type'] == 'detailed':
+ prompt = random.choice(detailed_caption_prompts)
+ elif line['caption_type'] == 'background':
+ prompt = random.choice(background_caption_prompts)
+ elif line['caption_type'] == 'main_object':
+ prompt = random.choice(main_object_caption_prompts)
+ else:
+ prompt = random.choice(camera_caption_prompts)
+
+ if video_llm:
+ # 对于视频LLM，返回视频路径和文本
+ video_path = os.path.join(self.video_path, line['video'])
+ return [
+ dict(type='video', value=video_path), # 添加视频信息
+ dict(type='text', value=prompt)
+ ]
+ else:
+ # 如果不是视频LLM，返回帧图像和文本
+ frames = self.save_video_frames(os.path.splitext(line['video'])[0])
+ message = []
+ for im in frames:
+ message.append(dict(type='image', value=im))
+ message.append(dict(type='text', value=prompt))
+ return message
+
+ def build_prompt(self, line, video_llm):
+ if self.pack and not video_llm:
+ return self.build_prompt_pack(line)
+ else:
+ return self.build_prompt_nopack(line, video_llm)
+
+ @staticmethod
+ def remove_side_quote(s, syms=[',', '"', "'"]):
+ if np.all([x in syms for x in s]):
+ return ''
+ while s[0] in syms:
+ s = s[1:]
+ while s[-1] in syms:
+ s = s[:-1]
+ return s
+
+ @staticmethod
+ def robust_json_load(s):
+ try:
+ jsons = list(extract_json_objects(s))
+ assert len(jsons) == 1
+ return jsons[0]
+ except:
+ if '{' in s and s.find('{') == s.rfind('{'):
+ sub_str = s[s.find('{') + 1:].strip()
+ lines = sub_str.split('\n')
+ res = {}
+ for l in lines:
+ l = l.strip()
+ if ': ' in l:
+ key = l.split(': ')[0].strip()
+ val = l.split(': ')[1].strip()
+ key = VDC.remove_side_quote(key)
+ val = VDC.remove_side_quote(val)
+ if len(key) and len(val):
+ res[key] = val
+ return res
+ return None
+
+ def load_pack_answers(self, data_raw):
+ vstats = defaultdict(lambda: 0)
+ data = defaultdict(lambda: {})
+
+ for k in data_raw:
+ ans = data_raw[k].strip()
+ if FAIL_MSG in ans:
+ vstats['GEN_FAIL'] += 1
+ continue
+ res = self.robust_json_load(ans)
+ if res is not None:
+ data[k] = res
+ vstats['PARSE_OK'] += 1
+ else:
+ vstats['PARSE_FAIL'] += 1
+
+ # return data
+ meta = cp.deepcopy(self.data)
+ lt = len(meta)
+ prediction = []
+ for i in range(lt):
+ line = meta.iloc[i]
+ vid = line['video']
+ idx = str(line['index'])
+ prediction.append(data[vid][idx] if idx in data[vid] else None)
+ meta['prediction'] = prediction
+ vstats['VALIDQ'] = len([x for x in prediction if x is not None])
+ vstats['INVALIDQ'] = len([x for x in prediction if x is None])
+ return meta, vstats
+
+ # It returns a dictionary
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.vdc import get_dimension_rating, prepare_response_prompt, prepare_score_prompt, SYSTEM_CAL_SCORE_PROMPT, SYSTEM_GENER_PRED_PROMPT
+
+ assert eval_file.endswith('.xlsx'), 'data file should be an xlsx file'
+ judge = judge_kwargs['model']
+ nproc = judge_kwargs.pop('nproc', 4)
+ _ = judge_kwargs.pop('verbose', None)
+ _ = judge_kwargs.pop('retry', None)
+
+ response_file = eval_file.replace('.xlsx', f'_{judge}_response.pkl')
+ tmp_file = eval_file.replace('.xlsx', f'_{judge}_tmp.pkl')
+ tgt_file = eval_file.replace('.xlsx', f'_{judge}_rating.json')
+ score_file = eval_file.replace('.xlsx', f'_{judge}_score.xlsx')
+
+ model = build_judge(**judge_kwargs)
+
+ if not osp.exists(score_file):
+ res = {} if not osp.exists(tmp_file) else load(tmp_file)
+ res = {k: v for k, v in res.items() if FAIL_MSG not in v}
+
+ data = load(eval_file)
+
+ expanded_data = []
+ for idx, row in data.iterrows():
+ try:
+ questions = ast.literal_eval(row['question']) if isinstance(row['question'], str) else row['question']
+ for q_dict in questions:
+ new_row = row.copy()
+ new_row['question'] = q_dict['question']
+ new_row['answer'] = q_dict['answer']
+ expanded_data.append(new_row)
+ except Exception as e:
+ print(f"Error parsing questions for row {idx}")
+ print(f"Error message: {str(e)}")
+ continue
+
+ # 转换回DataFrame并重置index
+ expanded_df = pd.DataFrame(expanded_data).reset_index(drop=True)
+
+ # 继续处理展开后的数据
+ data_un = expanded_df[~expanded_df['index'].isin(res)]
+ data_un = data_un[~pd.isna(data_un['prediction'])]
+ lt = len(data_un)
+
+ response_prompts = [prepare_response_prompt(data_un.iloc[i]) for i in range(lt)]
+ indices = [data_un.iloc[i]['index'] for i in range(lt)]
+
+ model.system_prompt = SYSTEM_GENER_PRED_PROMPT
+ if len(response_prompts):
+ print(f"Processing {len(response_prompts)} valid prompts out of {lt} total items")
+ _ = track_progress_rich(
+ model.generate,
+ response_prompts,
+ keys=indices,
+ save=response_file,
+ nproc=nproc,
+ chunksize=nproc
+ )
+
+ pred_map = load(response_file)
+ data_un['pred_response'] = [pred_map[idx] for idx in data_un['index']]
+ score_prompts = [prepare_score_prompt(data_un.iloc[i]) for i in range(lt)]
+ model.system_prompt = SYSTEM_CAL_SCORE_PROMPT
+ if len(score_prompts):
+ _ = track_progress_rich(
+ model.generate,
+ score_prompts,
+ keys=indices,
+ save=tmp_file,
+ nproc=nproc,
+ chunksize=nproc
+ )
+
+ score_map = load(tmp_file)
+ data['score'] = [score_map[idx] for idx in data['index']]
+
+ dump(data, score_file)
+
+ rating = get_dimension_rating(score_file)
+ dump(rating, tgt_file)
+ return rating
diff --git a/vlmeval/dataset/video_base.py b/vlmeval/dataset/video_base.py
new file mode 100644
index 0000000000000000000000000000000000000000..effbbe8aa3d8161a09d4e675a2d44c6404e74c21
--- /dev/null
+++ b/vlmeval/dataset/video_base.py
@@ -0,0 +1,137 @@
+from abc import abstractmethod
+from ..smp import *
+
+
+class VideoBaseDataset:
+
+ MODALITY = 'VIDEO'
+
+ def __init__(self,
+ dataset='MMBench-Video',
+ pack=False,
+ nframe=0,
+ fps=-1):
+ try:
+ import decord
+ except Exception as e:
+ logging.critical(f'{type(e)}: {e}')
+ logging.critical('Please install decord via `pip install decord`.')
+
+ self.dataset_name = dataset
+ ret = self.prepare_dataset(dataset)
+ assert ret is not None
+ lmu_root = LMUDataRoot()
+ self.frame_root = osp.join(lmu_root, 'images', dataset)
+ os.makedirs(self.frame_root, exist_ok=True)
+ self.frame_tmpl = 'frame-{}-of-{}.jpg'
+ self.frame_tmpl_fps = 'frame-{}-of-{}-{}fps.jpg'
+
+ self.data_root = ret['root']
+ self.data_file = ret['data_file']
+ self.data = load(self.data_file)
+ if 'index' not in self.data:
+ self.data['index'] = np.arange(len(self.data))
+
+ assert 'question' in self.data and 'video' in self.data
+ videos = list(set(self.data['video']))
+ videos.sort()
+ self.videos = videos
+ self.pack = pack
+ self.nframe = nframe
+ self.fps = fps
+ if self.fps > 0 and self.nframe > 0:
+ raise ValueError('fps and nframe should not be set at the same time')
+ if self.fps <= 0 and self.nframe <= 0:
+ raise ValueError('fps and nframe should be set at least one valid value')
+
+ def __len__(self):
+ return len(self.videos) if self.pack else len(self.data)
+
+ def __getitem__(self, idx):
+ if self.pack:
+ assert idx < len(self.videos)
+ sub_data = self.data[self.data['video'] == self.videos[idx]]
+ return sub_data
+ else:
+ assert idx < len(self.data)
+ return dict(self.data.iloc[idx])
+
+ def frame_paths(self, video):
+ frame_root = osp.join(self.frame_root, video)
+ os.makedirs(frame_root, exist_ok=True)
+ return [osp.join(frame_root, self.frame_tmpl.format(i, self.nframe)) for i in range(1, self.nframe + 1)]
+
+ def frame_paths_fps(self, video, num_frames):
+ frame_root = osp.join(self.frame_root, video)
+ os.makedirs(frame_root, exist_ok=True)
+ return [osp.join(frame_root,
+ self.frame_tmpl_fps.format(i, num_frames, self.fps)) for i in range(1, num_frames + 1)]
+
+ def save_video_frames(self, video):
+ if self.fps > 0:
+ vid_path = osp.join(self.data_root, video + '.mp4')
+ vid = decord.VideoReader(vid_path)
+
+ # 计算视频的总帧数和总时长
+ total_frames = len(vid)
+ video_fps = vid.get_avg_fps()
+ total_duration = total_frames / video_fps
+
+ # 计算需要提取的总帧数
+ required_frames = int(total_duration * self.fps)
+
+ # 计算提取帧的间隔
+ step_size = video_fps / self.fps
+
+ # 计算提取帧的索引
+ indices = [int(i * step_size) for i in range(required_frames)]
+
+ # 提取帧并保存
+ frame_paths = self.frame_paths_fps(video, len(indices))
+ flag = np.all([osp.exists(p) for p in frame_paths])
+ if flag:
+ return frame_paths
+
+ images = [vid[i].asnumpy() for i in indices]
+ images = [Image.fromarray(arr) for arr in images]
+ for im, pth in zip(images, frame_paths):
+ if not osp.exists(pth):
+ im.save(pth)
+ return frame_paths
+
+ else:
+ frame_paths = self.frame_paths(video)
+ flag = np.all([osp.exists(p) for p in frame_paths])
+ if flag:
+ return frame_paths
+ vid_path = osp.join(self.data_root, video + '.mp4')
+ vid = decord.VideoReader(vid_path)
+ step_size = len(vid) / (self.nframe + 1)
+ indices = [int(i * step_size) for i in range(1, self.nframe + 1)]
+ images = [vid[i].asnumpy() for i in indices]
+ images = [Image.fromarray(arr) for arr in images]
+ for im, pth in zip(images, frame_paths):
+ if not osp.exists(pth):
+ im.save(pth)
+ return frame_paths
+
+ # Return a list of dataset names that are supported by this class, can override
+ @classmethod
+ def supported_datasets(cls):
+ return ['MMBench-Video', 'Video-MME', 'MVBench', 'MVBench_MP4', 'LongVideoBench', 'WorldSense', 'VDC', 'MovieChat1k']
+
+ # Given the prediction file, return the evaluation results in the format of a dictionary or pandas dataframe
+ @abstractmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ pass
+
+ @abstractmethod
+ def build_prompt(self, idx):
+ pass
+
+ @abstractmethod
+ def prepare_dataset(self, dataset):
+ # The prepare_dataset function should return a dictionary containing:
+ # `root` (directory that containing video files)
+ # `data_file` (the TSV dataset file)
+ pass
diff --git a/vlmeval/dataset/video_concat_dataset.py b/vlmeval/dataset/video_concat_dataset.py
new file mode 100644
index 0000000000000000000000000000000000000000..dab1ae1d798004558ded1b95a52cfefd9fb55eac
--- /dev/null
+++ b/vlmeval/dataset/video_concat_dataset.py
@@ -0,0 +1,85 @@
+from ..smp import *
+from .video_base import VideoBaseDataset
+
+
+class ConcatVideoDataset(VideoBaseDataset):
+ # This dataset takes multiple dataset names as input and aggregate them into a single dataset.
+ # Each single dataset should not have a field named `SUB_DATASET`
+
+ DATASET_SETS = {}
+
+ def __init__(self, dataset, **kwargs):
+ from . import build_dataset
+ datasets = self.DATASET_SETS[dataset]
+ self.dataset_map = {}
+ # The name of the compliation
+ self.dataset_name = dataset
+ self.datasets = datasets
+ self.nframe = kwargs.get('nframe', 0)
+ self.fps = kwargs.get('fps', -1)
+ for dname in datasets:
+ dataset = build_dataset(dname, **kwargs)
+ assert dataset is not None, dataset
+ self.dataset_map[dname] = dataset
+ TYPES = [x.TYPE for x in self.dataset_map.values()]
+ MODALITIES = [x.MODALITY for x in self.dataset_map.values()]
+ # assert np.all([x == TYPES[0] for x in TYPES]), (datasets, TYPES)
+ assert np.all([x == MODALITIES[0] for x in MODALITIES]), (datasets, MODALITIES)
+ self.TYPE = TYPES
+ self.MODALITY = MODALITIES[0]
+ data_all = []
+ for dname in datasets:
+ data = self.dataset_map[dname].data
+ data['SUB_DATASET'] = [dname] * len(data)
+ data_all.append(data)
+
+ data = pd.concat(data_all)
+ data['original_index'] = data.pop('index')
+ data['index'] = np.arange(len(data))
+ self.data = data
+
+ def build_prompt(self, line, video_llm):
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+ idx = line['original_index']
+ dname = line['SUB_DATASET']
+ org_data = self.dataset_map[dname].data
+ org_line = cp.deepcopy(org_data[org_data['index'] == idx]).iloc[0]
+ return self.dataset_map[dname].build_prompt(org_line, video_llm)
+
+ def dump_image(self, line):
+ # Assert all images are pre-dumped
+ assert 'image' not in line
+ assert 'image_path' in line
+ tgt_path = toliststr(line['image_path'])
+ return tgt_path
+
+ @classmethod
+ def supported_datasets(cls):
+ return [] # list(cls.DATASET_SETS)
+
+ def evaluate(self, eval_file, **judge_kwargs):
+ suffix = eval_file.split('.')[-1]
+ # First, split the eval_file by dataset
+ data_all = load(eval_file)
+ for dname in self.datasets:
+ tgt = eval_file.replace(self.dataset_name, dname)
+ data_sub = data_all[data_all['SUB_DATASET'] == dname]
+ data_sub.pop('index')
+ data_sub['index'] = data_sub.pop('original_index')
+ data_sub.pop('SUB_DATASET')
+ dump(data_sub, tgt)
+ # Then, evaluate each dataset separately
+ results_all = {}
+ for dname in self.datasets:
+ tgt = eval_file.replace(self.dataset_name, dname)
+ res = self.dataset_map[dname].evaluate(tgt, **judge_kwargs)
+ results_all.update(res)
+
+ result = pd.DataFrame(results_all, index=['success', 'overall'])
+ result = result.T
+ for idx, item in result.iterrows():
+ result.loc[idx, 'acc'] = round(item['success'] / item['overall'] * 100, 1)
+ score_file = eval_file.replace(f'.{suffix}', '_acc.csv')
+ dump(result, score_file)
+ return result
diff --git a/vlmeval/dataset/video_dataset_config.py b/vlmeval/dataset/video_dataset_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..6e548b499547a3d0d3634715b50948c280fc4fb6
--- /dev/null
+++ b/vlmeval/dataset/video_dataset_config.py
@@ -0,0 +1,156 @@
+from vlmeval.dataset import *
+from functools import partial
+
+mmbench_video_dataset = {
+ 'MMBench_Video_8frame_nopack': partial(MMBenchVideo, dataset='MMBench-Video', nframe=8, pack=False),
+ 'MMBench_Video_8frame_pack': partial(MMBenchVideo, dataset='MMBench-Video', nframe=8, pack=True),
+ 'MMBench_Video_16frame_nopack': partial(MMBenchVideo, dataset='MMBench-Video', nframe=16, pack=False),
+ 'MMBench_Video_64frame_nopack': partial(MMBenchVideo, dataset='MMBench-Video', nframe=64, pack=False),
+ 'MMBench_Video_1fps_nopack': partial(MMBenchVideo, dataset='MMBench-Video', fps=1.0, pack=False),
+ 'MMBench_Video_1fps_pack': partial(MMBenchVideo, dataset='MMBench-Video', fps=1.0, pack=True)
+}
+
+mvbench_dataset = {
+ 'MVBench_8frame': partial(MVBench, dataset='MVBench', nframe=8),
+ 'MVBench_64frame': partial(MVBench, dataset='MVBench', nframe=64),
+ # MVBench not support fps, but MVBench_MP4 does
+ 'MVBench_MP4_8frame': partial(MVBench_MP4, dataset='MVBench_MP4', nframe=8),
+ 'MVBench_MP4_1fps': partial(MVBench_MP4, dataset='MVBench_MP4', fps=1.0),
+}
+
+tamperbench_dataset = {
+ 'MVTamperBench_8frame': partial(MVTamperBench, dataset='MVTamperBench', nframe=8),
+ 'MVTamperBenchStart_8frame': partial(MVTamperBench, dataset='MVTamperBenchStart', nframe=8),
+ 'MVTamperBenchEnd_8frame': partial(MVTamperBench, dataset='MVTamperBenchEnd', nframe=8),
+}
+
+videomme_dataset = {
+ 'Video-MME_8frame': partial(VideoMME, dataset='Video-MME', nframe=8),
+ 'Video-MME_64frame': partial(VideoMME, dataset='Video-MME', nframe=64),
+ 'Video-MME_8frame_subs': partial(VideoMME, dataset='Video-MME', nframe=8, use_subtitle=True),
+ 'Video-MME_1fps': partial(VideoMME, dataset='Video-MME', fps=1.0),
+ 'Video-MME_0.5fps': partial(VideoMME, dataset='Video-MME', fps=0.5),
+ 'Video-MME_0.5fps_subs': partial(VideoMME, dataset='Video-MME', fps=0.5, use_subtitle=True),
+}
+
+longvideobench_dataset = {
+ 'LongVideoBench_8frame': partial(LongVideoBench, dataset='LongVideoBench', nframe=8),
+ 'LongVideoBench_8frame_subs': partial(LongVideoBench, dataset='LongVideoBench', nframe=8, use_subtitle=True),
+ 'LongVideoBench_64frame': partial(LongVideoBench, dataset='LongVideoBench', nframe=64),
+ 'LongVideoBench_1fps': partial(LongVideoBench, dataset='LongVideoBench', fps=1.0),
+ 'LongVideoBench_0.5fps': partial(LongVideoBench, dataset='LongVideoBench', fps=0.5),
+ 'LongVideoBench_0.5fps_subs': partial(LongVideoBench, dataset='LongVideoBench', fps=0.5, use_subtitle=True)
+}
+
+mlvu_dataset = {
+ 'MLVU_8frame': partial(MLVU, dataset='MLVU', nframe=8),
+ 'MLVU_64frame': partial(MLVU, dataset='MLVU', nframe=64),
+ 'MLVU_1fps': partial(MLVU, dataset='MLVU', fps=1.0)
+}
+
+tempcompass_dataset = {
+ 'TempCompass_8frame': partial(TempCompass, dataset='TempCompass', nframe=8),
+ 'TempCompass_64frame': partial(TempCompass, dataset='TempCompass', nframe=64),
+ 'TempCompass_1fps': partial(TempCompass, dataset='TempCompass', fps=1.0),
+ 'TempCompass_0.5fps': partial(TempCompass, dataset='TempCompass', fps=0.5)
+}
+
+# In order to reproduce the experimental results in CGbench paper,
+# use_subtitle, use_subtitle_time and use_frame_time need to be set to True.
+# When measuring clue-related results, if the number of frames used is greater
+# than 32, the frame capture limit will be set to 32.
+cgbench_dataset = {
+ 'CGBench_MCQ_Grounding_Mini_8frame_subs_subt': partial(
+ CGBench_MCQ_Grounding_Mini,
+ dataset='CG-Bench_MCQ_Grounding_Mini',
+ nframe=8,
+ use_subtitle=True,
+ use_subtitle_time=True
+ ),
+ 'CGBench_OpenEnded_Mini_8frame_subs_subt_ft': partial(
+ CGBench_OpenEnded_Mini,
+ dataset='CG-Bench_OpenEnded_Mini',
+ nframe=8,
+ use_subtitle=True,
+ use_subtitle_time=True,
+ use_frame_time=True
+ ),
+ 'CGBench_MCQ_Grounding_32frame_subs': partial(
+ CGBench_MCQ_Grounding,
+ dataset='CG-Bench_MCQ_Grounding',
+ nframe=32,
+ use_subtitle=True
+ ),
+ 'CGBench_OpenEnded_8frame': partial(
+ CGBench_OpenEnded,
+ dataset='CG-Bench_OpenEnded',
+ nframe=8
+ ),
+ 'CGBench_MCQ_Grounding_16frame_subs_subt_ft': partial(
+ CGBench_MCQ_Grounding,
+ dataset='CG-Bench_MCQ_Grounding',
+ nframe=16,
+ use_subtitle=True,
+ use_subtitle_time=True,
+ use_frame_time=True
+ ),
+ 'CGBench_OpenEnded_16frame_subs_subt_ft': partial(
+ CGBench_OpenEnded,
+ dataset='CG-Bench_OpenEnded',
+ nframe=16,
+ use_subtitle=True,
+ use_subtitle_time=True,
+ use_frame_time=True
+ )
+}
+
+
+megabench_dataset = {
+ 'MEGABench_core_16frame': partial(MEGABench, dataset='MEGABench', nframe=16, subset_name="core"),
+ 'MEGABench_open_16frame': partial(MEGABench, dataset='MEGABench', nframe=16, subset_name="open"),
+ 'MEGABench_core_64frame': partial(MEGABench, dataset='MEGABench', nframe=64, subset_name="core"),
+ 'MEGABench_open_64frame': partial(MEGABench, dataset='MEGABench', nframe=64, subset_name="open")
+}
+
+moviechat1k_dataset = {
+ 'moviechat1k_breakpoint_8frame': partial(MovieChat1k, dataset='MovieChat1k', subset='breakpoint', nframe=8),
+ 'moviechat1k_global_14frame': partial(MovieChat1k, dataset='MovieChat1k', subset='global', nframe=14),
+ 'moviechat1k_global_8frame_limit0.01': partial(MovieChat1k, dataset='MovieChat1k', subset='global', nframe=8, limit=0.01)
+}
+
+vdc_dataset = {
+ 'VDC_8frame': partial(VDC, dataset='VDC', nframe=8),
+ 'VDC_1fps': partial(VDC, dataset='VDC', fps=1.0),
+}
+
+worldsense_dataset = {
+ 'WorldSense_8frame': partial(WorldSense, dataset='WorldSense', nframe=8),
+ 'WorldSense_8frame_subs': partial(WorldSense, dataset='WorldSense', nframe=8, use_subtitle=True),
+ 'WorldSense_8frame_audio': partial(WorldSense, dataset='WorldSense', nframe=8, use_audio=True),
+ 'WorldSense_32frame': partial(WorldSense, dataset='WorldSense', nframe=32),
+ 'WorldSense_32frame_subs': partial(WorldSense, dataset='WorldSense', nframe=32, use_subtitle=True),
+ 'WorldSense_32frame_audio': partial(WorldSense, dataset='WorldSense', nframe=32, use_audio=True),
+ 'WorldSense_1fps': partial(WorldSense, dataset='WorldSense', fps=1.0),
+ 'WorldSense_1fps_subs': partial(WorldSense, dataset='WorldSense', fps=1.0, use_subtitle=True),
+ 'WorldSense_1fps_audio': partial(WorldSense, dataset='WorldSense', fps=1.0, use_audio=True),
+ 'WorldSense_0.5fps': partial(WorldSense, dataset='WorldSense', fps=0.5),
+ 'WorldSense_0.5fps_subs': partial(WorldSense, dataset='WorldSense', fps=0.5, use_subtitle=True),
+ 'WorldSense_0.5fps_audio': partial(WorldSense, dataset='WorldSense', fps=0.5, use_audio=True)
+}
+
+qbench_video_dataset = {
+ 'QBench_Video_8frame': partial(QBench_Video, dataset='QBench_Video', nframe=8),
+ 'QBench_Video_16frame': partial(QBench_Video, dataset='QBench_Video', nframe=16),
+}
+
+supported_video_datasets = {}
+
+dataset_groups = [
+ mmbench_video_dataset, mvbench_dataset, videomme_dataset, longvideobench_dataset,
+ mlvu_dataset, tempcompass_dataset, cgbench_dataset, worldsense_dataset, tamperbench_dataset,
+ megabench_dataset, qbench_video_dataset, moviechat1k_dataset, vdc_dataset
+
+]
+
+for grp in dataset_groups:
+ supported_video_datasets.update(grp)
diff --git a/vlmeval/dataset/videomme.py b/vlmeval/dataset/videomme.py
new file mode 100644
index 0000000000000000000000000000000000000000..afb2c1beb1c35e61993d15e12c65f89de1a14d98
--- /dev/null
+++ b/vlmeval/dataset/videomme.py
@@ -0,0 +1,283 @@
+from huggingface_hub import snapshot_download
+from ..smp import *
+from .video_base import VideoBaseDataset
+from .utils import build_judge, DEBUG_MESSAGE
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+def unwrap_hf_pkl(pth, suffix='.mp4'):
+ base_dir = os.path.join(pth, 'video_pkl/')
+ target_dir = os.path.join(pth, 'video/')
+ pickle_files = [os.path.join(base_dir, file) for file in os.listdir(base_dir)]
+ pickle_files.sort()
+
+ if not os.path.exists(target_dir):
+ os.makedirs(target_dir, exist_ok=True)
+ for pickle_file in pickle_files:
+ with open(pickle_file, 'rb') as file:
+ video_data = pickle.load(file)
+ # For each video file in the pickle file, write its contents to a new mp4 file
+ for video_name, video_content in video_data.items():
+ output_path = os.path.join(target_dir, f'{video_name}{suffix}')
+ with open(output_path, 'wb') as output_file:
+ output_file.write(video_content)
+ print('The video file has been restored and stored from the pickle file.')
+ else:
+ print('The video file already exists.')
+
+
+class VideoMME(VideoBaseDataset):
+
+ MD5 = '85bdd91f9b29a99354c23b97ab7c113c'
+ SYS = ''
+
+ FRAMES_TMPL_NOSUB = """
+These are the frames of a video. \
+Select the best answer to the following multiple-choice question based on the video. \
+Respond with only the letter (A, B, C, or D) of the correct option.
+"""
+
+ FRAMES_TMPL_SUB = """
+These are the frames of a video. \
+This video's subtitles are listed below:
+{}
+Select the best answer to the following multiple-choice question based on the video. \
+Respond with only the letter (A, B, C, or D) of the correct option.
+"""
+
+ TYPE = 'Video-MCQ'
+
+ def __init__(self, dataset='Video-MME', use_subtitle=False, nframe=0, fps=-1):
+ super().__init__(dataset=dataset, nframe=nframe, fps=fps)
+ self.use_subtitle = use_subtitle
+ self.dataset_name = dataset
+
+ @classmethod
+ def supported_datasets(cls):
+ return ['Video-MME']
+
+ def prepare_dataset(self, dataset_name='Video-MME', repo_id='lmms-lab/Video-MME'):
+
+ def check_integrity(pth):
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+
+ if not os.path.exists(data_file):
+ return False
+
+ if md5(data_file) != self.MD5:
+ return False
+ data = load(data_file)
+ for video_pth in data['video_path']:
+ if not osp.exists(osp.join(pth, video_pth)):
+ return False
+ return True
+
+ cache_path = get_cache_path(repo_id)
+ if cache_path is not None and check_integrity(cache_path):
+ dataset_path = cache_path
+ else:
+
+ def unzip_hf_zip(pth):
+ import zipfile
+ base_dir = pth
+ target_dir = os.path.join(pth, 'video/')
+ zip_files = [
+ os.path.join(base_dir, file) for file in os.listdir(base_dir)
+ if file.endswith('.zip') and file.startswith('video')
+ ]
+ zip_files.sort()
+
+ if not os.path.exists(target_dir):
+ os.makedirs(target_dir, exist_ok=True)
+ for zip_file in zip_files:
+ with zipfile.ZipFile(zip_file, 'r') as zip_ref:
+ for member in zip_ref.namelist():
+ # Check if the member is a file (not a directory)
+ if not member.endswith('/'):
+ # Extract the file to the specified directory
+ source = zip_ref.open(member)
+ target = open(os.path.join(target_dir, os.path.basename(member)), 'wb')
+ with source, target:
+ target.write(source.read())
+ print('The video file has been restored and stored from the zip file.')
+ else:
+ print('The video file already exists.')
+
+ subtitle_zip_file = os.path.join(base_dir, 'subtitle.zip')
+ subtitle_target_dir = os.path.join(base_dir, 'subtitle')
+
+ if not os.path.exists(subtitle_target_dir):
+ os.makedirs(subtitle_target_dir, exist_ok=True)
+ with zipfile.ZipFile(subtitle_zip_file, 'r') as zip_ref:
+ for member in zip_ref.namelist():
+ # Check if the member is a file (not a directory)
+ if not member.endswith('/'):
+ # Extract the file to the specified directory
+ source = zip_ref.open(member)
+ target = open(os.path.join(subtitle_target_dir, os.path.basename(member)), 'wb')
+ with source, target:
+ target.write(source.read())
+ print('The subtitle file has been restored and stored from the zip file.')
+ else:
+ print('The subtitle file already exists.')
+
+ def generate_tsv(pth):
+
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+ if os.path.exists(data_file) and md5(data_file) == self.MD5:
+ return
+
+ data_file = pd.read_parquet(os.path.join(pth, 'videomme/test-00000-of-00001.parquet'))
+ data_file = data_file.assign(index=range(len(data_file)))
+ data_file['video'] = data_file['videoID']
+ data_file['video_path'] = data_file['videoID'].apply(lambda x: f'./video/{x}.mp4')
+ data_file['subtitle_path'] = data_file['videoID'].apply(lambda x: f'./subtitle/{x}.srt')
+ data_file['candidates'] = data_file['options'].apply(lambda x: x.tolist())
+
+ data_file = data_file[['index', 'video', 'video_path', 'duration', 'domain', 'candidates',
+ 'sub_category', 'task_type', 'subtitle_path', 'question', 'answer']]
+
+ data_file.to_csv(osp.join(pth, f'{dataset_name}.tsv'), sep='\t', index=False)
+
+ if modelscope_flag_set():
+ from modelscope import dataset_snapshot_download
+ dataset_path = dataset_snapshot_download(dataset_id=repo_id)
+ else:
+ dataset_path = snapshot_download(repo_id=repo_id, repo_type='dataset')
+ unzip_hf_zip(dataset_path)
+ generate_tsv(dataset_path)
+
+ data_file = osp.join(dataset_path, f'{dataset_name}.tsv')
+
+ return dict(data_file=data_file, root=dataset_path)
+
+ def save_video_frames(self, video, video_llm=False):
+
+ vid_path = osp.join(self.data_root, 'video', video + '.mp4')
+ vid = decord.VideoReader(vid_path)
+ video_info = {
+ 'fps': vid.get_avg_fps(),
+ 'n_frames': len(vid),
+ }
+ if self.nframe > 0 and self.fps < 0:
+ step_size = len(vid) / (self.nframe + 1)
+ indices = [int(i * step_size) for i in range(1, self.nframe + 1)]
+ frame_paths = self.frame_paths(video)
+ elif self.fps > 0:
+ # not constrained by num_frames, get frames by fps
+ total_duration = video_info['n_frames'] / video_info['fps']
+ required_frames = int(total_duration * self.fps)
+ step_size = video_info['fps'] / self.fps
+ indices = [int(i * step_size) for i in range(required_frames)]
+ frame_paths = self.frame_paths_fps(video, len(indices))
+
+ flag = np.all([osp.exists(p) for p in frame_paths])
+
+ if not flag:
+ images = [vid[i].asnumpy() for i in indices]
+ images = [Image.fromarray(arr) for arr in images]
+ for im, pth in zip(images, frame_paths):
+ if not osp.exists(pth) and not video_llm:
+ im.save(pth)
+
+ return frame_paths, indices, video_info
+
+ def build_prompt(self, line, video_llm):
+ if isinstance(line, int):
+ assert line < len(self)
+ line = self.data.iloc[line]
+
+ frames, indices, video_info = self.save_video_frames(line['video'], video_llm)
+
+ if self.use_subtitle and os.path.exists(osp.join(self.data_root, line['subtitle_path'])):
+ import pysubs2
+ subs = pysubs2.load(osp.join(self.data_root, line['subtitle_path']), encoding='utf-8')
+ subtitles = []
+
+ for seleced_frame_id in indices:
+ sub_text = ''
+ cur_time = pysubs2.make_time(fps=video_info['fps'], frames=seleced_frame_id)
+ for sub in subs:
+ if sub.start < cur_time and sub.end > cur_time:
+ sub_text = sub.text.replace('\\N', ' ')
+ break
+ if sub_text.strip():
+ subtitles.append(sub_text)
+ subtitles = '\n'.join(subtitles)
+ else:
+ subtitles = ''
+
+ message = [dict(type='text', value=self.SYS)]
+ if video_llm:
+ message.append(dict(type='video', value=osp.join(self.data_root, 'video', line['video'] + '.mp4')))
+ else:
+ for im in frames:
+ message.append(dict(type='image', value=im))
+
+ text_prompt = self.FRAMES_TMPL_NOSUB if not self.use_subtitle else self.FRAMES_TMPL_SUB.format(subtitles)
+ message.append(dict(type='text', value=text_prompt))
+ line['question'] += '\n' + '\n'.join(eval(line['candidates']))
+ prompt = 'Question: {}\nAnswer: '.format(line['question'])
+ message.append(dict(type='text', value=prompt))
+ return message
+
+ # It returns a dictionary
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.videomme import get_dimension_rating, extract_characters_regex, extract_option
+
+ assert eval_file.endswith('.xlsx'), 'data file should be an xlsx file'
+
+ tmp_file = eval_file.replace('.xlsx', '_tmp.pkl')
+ tgt_file = eval_file.replace('.xlsx', '_rating.json')
+ score_file = eval_file.replace('.xlsx', '_score.xlsx')
+
+ if not osp.exists(score_file):
+ model = judge_kwargs.get('model', 'exact_matching')
+ assert model in ['chatgpt-0125', 'exact_matching', 'gpt-4-0125']
+
+ if model == 'exact_matching':
+ model = None
+ elif gpt_key_set():
+ model = build_judge(**judge_kwargs)
+ if not model.working():
+ warnings.warn('OPENAI API is not working properly, will use exact matching for evaluation')
+ warnings.warn(DEBUG_MESSAGE)
+ model = None
+ else:
+ warnings.warn('OPENAI_API_KEY is not set properly, will use exact matching for evaluation')
+ model = None
+ res = {} if not osp.exists(tmp_file) else load(tmp_file)
+ res = {k: v for k, v in res.items() if FAIL_MSG not in v}
+
+ data = load(eval_file)
+ data_un = data[~pd.isna(data['prediction'])]
+
+ for idx in data['index']:
+ ans = data.loc[data['index'] == idx, 'answer'].values[0]
+ pred = str(data.loc[data['index'] == idx, 'prediction'].values[0])
+
+ if extract_characters_regex(pred) == '':
+ extract_pred = extract_option(
+ model,
+ data.loc[data['index'] == idx].to_dict(orient='records')[0],
+ 'Video-MME'
+ )
+ data.loc[idx, 'score'] = int(extract_pred == ans)
+ else:
+ data.loc[idx, 'score'] = int(extract_characters_regex(pred) == ans)
+
+ rejected = [x for x in data['score'] if x == -1]
+
+ print(
+ f'Among {len(data)} questions, failed to obtain prediction for {len(data) - len(data_un)} questions, '
+ f'failed to obtain the score for another {len(rejected)} questions. '
+ f'Those questions will be counted as -1 score in ALL rating, and will not be counted in VALID rating.'
+ )
+
+ dump(data, score_file)
+
+ rating = get_dimension_rating(score_file)
+ dump(rating, tgt_file)
+ return rating
diff --git a/vlmeval/dataset/vl_rewardbench.py b/vlmeval/dataset/vl_rewardbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..d8dad7383462c8db53a6e9862493de98cdb37641
--- /dev/null
+++ b/vlmeval/dataset/vl_rewardbench.py
@@ -0,0 +1,174 @@
+from ast import literal_eval
+
+from .image_base import ImageBaseDataset
+from .utils import build_judge, DEBUG_MESSAGE
+from ..smp import *
+from ..utils import track_progress_rich
+
+
+LLM_PARSE_ANSWER_PROMPT = '''
+You are given a pairwise judgement for two responses. Please return the better response according to the judgement.
+Return the Answer X ONLY. e.g., Answer 1 or Answer 2.
+
+Judgement: {judgement}
+'''
+
+
+PROMPT_TEMPLATE = '''\
+You are a highly capable multimodal AI assistant tasked with evaluating answers to visual questions.
+Please analyze the following image and question, then determine which of the two provided answers is better.
+
+Question: {query}
+
+Answer 1: {answer_0}
+
+Answer 2: {answer_1}
+
+Please evaluate both answers based on the following criteria:
+1. Accuracy: How well does the answer align with the visual information in the image?
+2. Completeness: Does the answer fully address all aspects of the question?
+3. Clarity: Is the answer easy to understand and well-articulated?
+4. Relevance: Does the answer directly relate to the question and the image?
+
+After your evaluation, please:
+1. Explain your reasoning for each criterion.
+2. Provide an overall judgment on which answer is better (Answer 1 or Answer 2).\
+For example: Overall Judgment: Answer X is better.
+
+Your response should be structured and detailed, \
+demonstrating your understanding of both the visual and textual elements of the task.'''
+
+
+def get_score(line, parsed_response, random_number):
+ gt_ans = line['human_ranking'].index(0 if random_number == 0 else 1) + 1
+ if 'Answer 1'.lower() in parsed_response.lower():
+ pred = 1
+ elif 'Answer 2'.lower() in parsed_response.lower():
+ pred = 2
+ else: # failed
+ pred = 'None' # random.choice([1, 2])
+
+ if pred == gt_ans:
+ return 1.0
+ else:
+ return 0.0
+
+
+def VLRewardBench_eval_answer(model, line):
+ response = toliststr(line['response'])
+ random_number = sum(len(res) for res in response) % 2
+
+ prompt = LLM_PARSE_ANSWER_PROMPT.format(judgement=line['prediction'])
+ messages = [dict(type='text', value=prompt)]
+
+ resp = model.generate(messages)
+ score = get_score(line, resp, random_number)
+
+ if score is None:
+ return 'Unknown'
+ return score
+
+
+class VLRewardBench(ImageBaseDataset):
+ TYPE = 'VQA'
+ DATASET_URL = {
+ 'VL-RewardBench': 'https://huggingface.co/datasets/MMInstruction/VL-RewardBench/resolve/main/vl_rewardbench.tsv'
+ }
+ DATASET_MD5 = {'VL-RewardBench': '1d2676f4ab4a5f755019ec0af2b28189'}
+
+ # Given one data record, return the built prompt (a multi-modal message), can override
+ def build_prompt(self, line):
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+ tgt_path = self.dump_image(line) # save image to local
+ question = line['question']
+ msgs = []
+ if isinstance(tgt_path, list):
+ msgs.extend([dict(type='image', value=p) for p in tgt_path])
+ else:
+ msgs = [dict(type='image', value=tgt_path)]
+
+ response = toliststr(line['response'])
+ random_number = sum(len(res) for res in response) % 2
+ if random_number == 1:
+ # randomly shuffle the order of the responses
+ response = response[::-1]
+ query_prompt = PROMPT_TEMPLATE.format(
+ query=question, answer_0=response[0], answer_1=response[1]
+ )
+ msgs = msgs + [dict(type='text', value=query_prompt)]
+ return msgs
+
+ # It returns a DataFrame
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ suffix = eval_file.split('.')[-1]
+ model = judge_kwargs['model']
+ storage = eval_file.replace(f'.{suffix}', f'_{model}.xlsx')
+ score_file = eval_file.replace(f'.{suffix}', f'_{model}_score.csv')
+ tmp_file = eval_file.replace(f'.{suffix}', f'_{model}.pkl')
+ nproc = judge_kwargs.pop('nproc', 4)
+
+ if not osp.exists(storage):
+ raw_data = VLRewardBench('VL-RewardBench').data
+ data = load(eval_file)
+ data['prediction'] = [str(x) for x in data['prediction']]
+ data['human_ranking'] = [literal_eval(x) for x in raw_data['answer']]
+
+ judge_kwargs['temperature'] = 0
+ judge_kwargs['timeout'] = 60
+ model = build_judge(max_tokens=128, **judge_kwargs)
+
+ assert model.working(), (
+ 'VLRewardBench evaluation requires a working OPENAI API\n'
+ + DEBUG_MESSAGE
+ )
+
+ lt = len(data)
+ lines = [data.iloc[i] for i in range(lt)]
+ tups = [(model, line) for line in lines]
+ indices = [line['index'] for line in lines]
+
+ ans = load(tmp_file) if osp.exists(tmp_file) else {}
+ tups = [x for x, i in zip(tups, indices) if i not in ans]
+ indices = [i for i in indices if i not in ans]
+
+ if len(indices):
+ new_results = track_progress_rich(
+ VLRewardBench_eval_answer,
+ tups,
+ nproc=nproc,
+ chunksize=nproc,
+ keys=indices,
+ save=tmp_file,
+ )
+ ans = load(tmp_file)
+ for k, v in zip(indices, new_results):
+ ans[k] = v
+
+ data['score'] = [ans[idx] for idx in data['index']]
+ # data.pop('image')
+ dump(data, storage)
+
+ data = load(storage)
+ lt = len(data)
+
+ category_scores = defaultdict(lambda: 0)
+ category_cnt = defaultdict(lambda: 0)
+ scores = defaultdict(lambda: 0)
+ for i in range(lt):
+ item = data.iloc[i]
+ category_scores[item['category']] += item['score']
+ category_cnt[item['category']] += 1
+ # calculate the average score for each category
+ for k, v in category_scores.items():
+ scores[k] = v / category_cnt[k]
+ # calculate category macro accuracy (average across categories)
+ scores['Macro Accuracy'] = sum(scores.values()) / len(scores)
+ # calculate the total average score
+ scores['Overall Consistency'] = sum(category_scores.values()) / lt
+
+ scores = {k: [v] for k, v in scores.items()}
+ scores = pd.DataFrame(scores)
+ dump(scores, score_file)
+ return scores
diff --git a/vlmeval/dataset/vlm2bench.py b/vlmeval/dataset/vlm2bench.py
new file mode 100644
index 0000000000000000000000000000000000000000..a7e6f540d48cc836a5007aa8069da63c366a2fd9
--- /dev/null
+++ b/vlmeval/dataset/vlm2bench.py
@@ -0,0 +1,122 @@
+import os
+import pandas as pd
+from .image_base import ImageBaseDataset
+from .utils.vlm2bench import (
+ common_process_results,
+ tf_pair_aggregate_accuracy,
+ cnt_aggregate_metric,
+ grp_aggregate_accuracy,
+)
+
+
+class VLM2Bench(ImageBaseDataset):
+ TYPE = "VQA"
+
+ DATASET_URL = {
+ "VLM2Bench": 'https://huggingface.co/datasets/Sterzhang/vlm2-bench/resolve/main/VLM2Bench_img.tsv' # all 2860 image cases from VLM2Bench huggingface repo
+ }
+ # DATASET_MD5
+ DATASET_MD5 = {'VLM2Bench': '16f474bfc4e269c583468bf89139da8f'}
+
+ def build_prompt(self, line):
+ """
+ Build multimodal input:
+ - If the record does not have "image_path", generate the image_path list based on the "image" field (stored as a regular list of image encodings),
+ and update the "image" field to contain a list of multiple image paths.
+ - Call dump_image to process the image and image_path fields to obtain all local paths of the images.
+ - Construct the text prompt in the format "Question: {question}".
+ - Encapsulate all image paths as image messages and append the text message, returning the final multimodal message list.
+ """
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ # If there is no image_path, generate the image_path list based on the image field
+ if "image_path" not in line:
+ img_field = line.get("image")
+ # Assume the image field is already a regular list of image encodings, not a JSON-encoded string
+ image_paths = [f"{line['index']}_{i}.jpg" for i in range(len(img_field))]
+ line["image_path"] = image_paths
+ # Also update the image field to the list of image encodings
+ line["image"] = img_field
+
+ # Call dump_image (implemented in the parent class) to process the image and image_path fields, returning the list of local image paths
+ img_paths = self.dump_image(line)
+ if not isinstance(img_paths, list):
+ img_paths = [img_paths]
+
+ # Construct the text prompt (only containing the question)
+ prompt = f"Question: {line['question']}\n"
+
+ # Encapsulate all image paths as image messages and append the text message
+ msgs = [{"type": "image", "value": p} for p in img_paths]
+ msgs.append({"type": "text", "value": prompt})
+ return msgs
+
+ @classmethod
+ def evaluate(cls, eval_file, **judge_kwargs):
+ """
+ Evaluation function:
+ - Automatically read the model prediction result file (xlsx or TSV), which contains fields: index, question, answer, category, prediction
+ - Directly use the original fields for evaluation without additional conversion;
+ - For categories "oc-cnt" or "pc-cnt", calculate image_seq_len based on the "image" field (stored as a regular multi-image encoding)
+ and write it into each record;
+ - Group by category and use different evaluation functions to calculate metrics for each sub-task:
+ • tf pair: suitable for gc-mat, gc-trk, oc-cpr, pc-cpr
+ • cnt: suitable for oc-cnt, pc-cnt
+ • grp: suitable for oc-grp, pc-grp
+ - Write the scores of each sub-task to a CSV file and return a DataFrame.
+ """
+ model = judge_kwargs.get("model")
+ if model:
+ suffix = eval_file.split('.')[-1]
+ storage = eval_file.replace(f'.{suffix}', f'_{model}.xlsx')
+ score_file = eval_file.replace(f'.{suffix}', f'_{model}_score.csv')
+ tmp_file = eval_file.replace(f'.{suffix}', f'_{model}.pkl')
+ if os.path.exists(storage):
+ if storage.lower().endswith(".xlsx"):
+ data = pd.read_excel(storage)
+ else:
+ data = pd.read_csv(storage, sep="\t", encoding="latin1", engine="python")
+ else:
+ if eval_file.lower().endswith(".xlsx"):
+ data = pd.read_excel(eval_file)
+ else:
+ data = pd.read_csv(eval_file, sep="\t", encoding="latin1", engine="python")
+ else:
+ if eval_file.lower().endswith(".xlsx"):
+ data = pd.read_excel(eval_file)
+ else:
+ data = pd.read_csv(eval_file, sep="\t", encoding="latin1", engine="python")
+
+ results = data.to_dict(orient="records")
+ processed = common_process_results(results)
+
+ # For cnt category, calculate image_seq_len (i.e., number of images) based on the list of image encodings stored in the image field
+ for rec in processed:
+ if rec.get("category", "").lower() in ["oc-cnt", "pc-cnt"]:
+ try:
+ rec["image_seq_len"] = len(rec["image"])
+ except Exception as e:
+ rec["image_seq_len"] = 2
+
+ eval_scores = {}
+ for cat in sorted(set([r["category"] for r in processed])):
+ sub_results = [r for r in processed if r["category"] == cat]
+ if cat in ["gc-mat", "gc-trk", "oc-cpr", "pc-cpr"]:
+ score = tf_pair_aggregate_accuracy(sub_results)
+ elif cat in ["oc-cnt", "pc-cnt"]:
+ score = cnt_aggregate_metric(sub_results)
+ elif cat in ["oc-grp", "pc-grp"]:
+ score = grp_aggregate_accuracy(sub_results)
+ else:
+ score = None
+ eval_scores[cat] = score
+
+ score_df = pd.DataFrame({k: [v] for k, v in eval_scores.items()})
+ if model:
+ final_score_file = score_file
+ else:
+ suffix = os.path.splitext(eval_file)[1]
+ final_score_file = eval_file.replace(suffix, "_score.csv")
+ score_df.to_csv(final_score_file, index=False)
+ return score_df
\ No newline at end of file
diff --git a/vlmeval/dataset/wildvision.py b/vlmeval/dataset/wildvision.py
new file mode 100644
index 0000000000000000000000000000000000000000..b1ad1fd2630db73f45c77aa892daec805818929d
--- /dev/null
+++ b/vlmeval/dataset/wildvision.py
@@ -0,0 +1,222 @@
+import re
+from functools import partial
+
+from .image_base import ImageBaseDataset
+from .utils import build_judge, DEBUG_MESSAGE
+from ..smp import *
+from ..utils import track_progress_rich
+
+
+SYSTEM_PROMPT = """\
+Please act as an impartial judge and evaluate the quality of the responses provided by two AI assistants to the user \
+prompt displayed below. You will be given assistant A's answer and assistant B's answer. Your job is to evaluate \
+which assistant's answer is better.
+
+Begin your evaluation by generating your own answer to the prompt. You must provide your answers before judging any \
+answers.
+
+When evaluating the assistants' answers, compare both assistants' answers with your answer. \
+You must identify and correct any mistakes or inaccurate information.
+
+Then consider if the assistant's answers are helpful, relevant, and concise. Helpful means the answer correctly \
+responds to the prompt or follows the instructions. Note when user prompt has any ambiguity or more than one \
+interpretation, it is more helpful and appropriate to ask for clarifications or more information from the user than \
+providing an answer based on assumptions. Relevant means all parts of the response closely connect or are appropriate \
+to what is being asked. Concise means the response is clear and not verbose or excessive.
+
+Then consider the creativity and novelty of the assistant's answers when needed. Finally, identify any missing \
+important information in the assistants' answers that would be beneficial to include when responding to the user \
+prompt.
+
+After providing your explanation, you must output only one of the following choices as your final verdict with a label:
+
+1. Assistant A is significantly better: [[A>>B]]
+2. Assistant A is slightly better: [[A>B]]
+3. Tie, relatively the same: [[A=B]]
+4. Assistant B is slightly better: [[B>A]]
+5. Assistant B is significantly better: [[B>>A]]
+
+Example output: "My final verdict is tie: [[A=B]]".\
+"""
+
+
+PROMPT_TEMPLATE = """\
+"<|User Prompt|>\n{question}
+
+<|The Start of Assistant A's Answer|>\n{answer_1}\n<|The End of Assistant A's Answer|>
+
+<|The Start of Assistant B's Answer|>\n{answer_2}\n<|The End of Assistant B's Answer|>
+"""
+
+
+REGEX_PATTERN = re.compile("\[\[([AB<>=]+)\]\]") # noqa: W605
+
+
+def get_score(judgement, pattern=REGEX_PATTERN):
+ matches = pattern.findall(judgement)
+ matches = [m for m in matches if m != ""]
+ if len(set(matches)) == 0:
+ return None, True
+ elif len(set(matches)) == 1:
+ return matches[0].strip("\n"), False
+ else:
+ return None, True
+
+
+def WildVision_auxeval(model, line):
+ config = dict(question=line['question'], answer_1=line['A'], answer_2=line['B'])
+ prompt = PROMPT_TEMPLATE.format(**config)
+
+ prefix = 'data:image/jpeg;base64,'
+ img = prefix + line['image']
+
+ messages = [
+ dict(type='text', value=prompt),
+ dict(type='image', value=img)
+ ]
+
+ retry = 2
+ while retry:
+ resp = model.generate(messages)
+ score, try_again = get_score(resp)
+ if not try_again:
+ break
+ retry -= 1
+
+ if score is None:
+ return 'Unknown'
+ return score
+
+
+class WildVision(ImageBaseDataset):
+ TYPE = 'VQA'
+ DATASET_URL = {
+ 'WildVision': 'https://opencompass.openxlab.space/utils/VLMEval/WildVision.tsv'
+ }
+ DATASET_MD5 = {'WildVision': 'b38f80156d49411c594772866b0d0b52'}
+
+ score_map = {
+ 'A>>B': -2,
+ 'A>B': -1,
+ 'A=B': 0,
+ 'B>A': 1,
+ 'B>>A': 2
+ }
+
+ # Given one data record, return the built prompt (a multi-modal message), can override
+ def build_prompt(self, line):
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ if self.meta_only:
+ tgt_path = toliststr(line['image_path'])
+ else:
+ tgt_path = self.dump_image(line)
+
+ question = line['question']
+
+ msgs = []
+ if isinstance(tgt_path, list):
+ msgs.extend([dict(type='image', value=p) for p in tgt_path])
+ else:
+ msgs = [dict(type='image', value=tgt_path)]
+ # WildVision adopts text first
+ msgs = [dict(type='text', value=question)] + msgs
+ return msgs
+
+ @classmethod
+ def gen_eval_base(self, eval_file, b64_map):
+ data = load(eval_file)
+ data['B'] = data.pop('prediction')
+ data['A'] = data.pop('claude3_sonnet')
+ data['image'] = [b64_map[x] for x in data['index']]
+ return data
+ # rev = cp.deepcopy(data)
+ # rev['A'] = data['B']
+ # rev['B'] = data['A']
+ # rev['index'] = [x + '_rev' for x in data['index']]
+ # return pd.concat([data, rev], ignore_index=True)
+
+ # It returns a DataFrame
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ # We adopt pairwise evaluation (twice for a pair) for this dataset
+ suffix = eval_file.split('.')[-1]
+ model = judge_kwargs['model']
+ storage = eval_file.replace(f'.{suffix}', f'_{model}.xlsx')
+ score_file = eval_file.replace(f'.{suffix}', f'_{model}_score.csv')
+ tmp_file = eval_file.replace(f'.{suffix}', f'_{model}.pkl')
+ nproc = judge_kwargs.pop('nproc', 4)
+
+ if not osp.exists(storage):
+ raw_data = WildVision('WildVision').data
+ b64_map = {x: y for x, y in zip(raw_data['index'], raw_data['image'])}
+ data = self.gen_eval_base(eval_file, b64_map)
+
+ judge_kwargs['system_prompt'] = SYSTEM_PROMPT
+ judge_kwargs['temperature'] = 0
+ judge_kwargs['img_detail'] = 'high'
+ judge_kwargs['timeout'] = 300
+ model = build_judge(max_tokens=4096, **judge_kwargs)
+
+ assert model.working(), ('WildVision evaluation requires a working OPENAI API\n' + DEBUG_MESSAGE)
+
+ lt = len(data)
+ lines = [data.iloc[i] for i in range(lt)]
+ tups = [(model, line) for line in lines]
+ indices = [line['index'] for line in lines]
+
+ ans = load(tmp_file) if osp.exists(tmp_file) else {}
+ tups = [x for x, i in zip(tups, indices) if i not in ans]
+ indices = [i for i in indices if i not in ans]
+
+ if len(indices):
+ new_results = track_progress_rich(
+ WildVision_auxeval,
+ tups,
+ nproc=nproc,
+ chunksize=nproc,
+ keys=indices,
+ save=tmp_file,
+ )
+ ans = load(tmp_file)
+ for k, v in zip(indices, new_results):
+ ans[k] = v
+
+ data['score'] = [ans[idx] for idx in data['index']]
+ data.pop('image')
+ dump(data, storage)
+
+ data = load(storage)
+ lt = len(data)
+
+ scores = defaultdict(lambda: 0)
+ for i in range(lt):
+ item = data.iloc[i]
+ if item['score'] not in self.score_map:
+ score = 0
+ else:
+ score = self.score_map[item['score']]
+ if '_rev' in item['index']:
+ score = -score
+ scores[score] += 1
+ name_map = {
+ 2: 'Much Better',
+ 1: 'Better',
+ 0: 'Tie',
+ -1: 'Worse',
+ -2: 'Much Worse'
+ }
+ scores = {name_map[k]: v for k, v in scores.items()}
+ much_better = scores.get('Much Better', 0)
+ better = scores.get('Better', 0)
+ worse = scores.get('Worse', 0)
+ much_worse = scores.get('Much Worse', 0)
+ scores['Reward'] = (
+ 100 * much_better + 50 * better - 50 * worse - 100 * much_worse
+ ) / lt
+ scores['Win Rate'] = (better + much_better) / lt
+ scores = {k: [v] for k, v in scores.items()}
+ scores = pd.DataFrame(scores)
+ dump(scores, score_file)
+ return scores
diff --git a/vlmeval/dataset/worldsense.py b/vlmeval/dataset/worldsense.py
new file mode 100644
index 0000000000000000000000000000000000000000..aa9b88f4d113372b2888543d7be8bce009747165
--- /dev/null
+++ b/vlmeval/dataset/worldsense.py
@@ -0,0 +1,331 @@
+from huggingface_hub import snapshot_download
+from ..smp import *
+from .video_base import VideoBaseDataset
+from .utils import build_judge, DEBUG_MESSAGE
+import json
+
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+class WorldSense(VideoBaseDataset):
+
+ MD5 = 'bfc25490be4080aa5494b883370b6b1f'
+
+ BASE_SYS = 'Carefully watch this video and pay attention to every detail. '
+ SYS = BASE_SYS + 'Based on your observations, select the best option that accurately addresses the question.'
+
+ FRAMES_TMPL_NOSUB = """
+These are the frames of a video. \
+Select the best answer to the following multiple-choice question based on the video. \
+Respond with only the letter (A, B, C, or D) of the correct option.
+"""
+
+ FRAMES_TMPL_SUB = """
+These are the frames of a video. \
+This video's subtitles are listed below:
+{}
+Select the best answer to the following multiple-choice question based on the video. \
+Respond with only the letter (A, B, C, or D) of the correct option.
+"""
+
+ FRAMES_TMPL_AUDIO = """
+These are the frames of a video and the corresponding audio. \
+Select the best answer to the following multiple-choice question based on the video. \
+Respond with only the letter (A, B, C, or D) of the correct option.
+"""
+
+ TYPE = 'Video-MCQ'
+
+ def __init__(self, dataset='WorldSense', use_subtitle=False, use_audio=False, nframe=0, fps=-1):
+ super().__init__(dataset=dataset, nframe=nframe, fps=fps)
+ self.use_subtitle = use_subtitle
+ self.use_audio = use_audio
+ self.dataset_name = dataset
+
+ assert not (self.use_subtitle and self.use_audio), 'Cannot use both subtitle and audio at the same time.'
+
+ @classmethod
+ def supported_datasets(cls):
+ return ['WorldSense']
+
+ def prepare_dataset(self, dataset_name='WorldSense', repo_id='honglyhly/WorldSense'):
+
+ def check_integrity(pth):
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+
+ if not os.path.exists(data_file):
+ return False
+
+ if md5(data_file) != self.MD5:
+ return False
+ data = load(data_file)
+ for video_pth in data['video_path']:
+ if not osp.exists(osp.join(pth, video_pth)):
+ return False
+ return True
+
+ cache_path = get_cache_path(repo_id)
+ if cache_path is not None and check_integrity(cache_path):
+ dataset_path = cache_path
+ else:
+
+ def unzip_hf_zip(pth):
+ import zipfile
+ from moviepy.editor import VideoFileClip
+ base_dir = pth
+ target_dir = os.path.join(pth, 'videos/')
+ zip_files = [
+ os.path.join(base_dir, file) for file in os.listdir(base_dir)
+ if file.endswith('.zip') and file.startswith('worldsense_videos')
+ ]
+ zip_files.sort()
+
+ if not os.path.exists(target_dir):
+ os.makedirs(target_dir, exist_ok=True)
+ for zip_file in zip_files:
+ with zipfile.ZipFile(zip_file, 'r') as zip_ref:
+ for member in zip_ref.namelist():
+ # Check if the member is a file (not a directory)
+ if not member.endswith('/'):
+ # Extract the file to the specified directory
+ source = zip_ref.open(member)
+ target = open(os.path.join(target_dir, os.path.basename(member)), 'wb')
+ with source, target:
+ target.write(source.read())
+ print('The video file has been restored and stored from the zip file.')
+ else:
+ print('The video file already exists.')
+
+ subtitle_zip_file = os.path.join(base_dir, 'worldsense_subtitles.zip')
+ subtitle_target_dir = os.path.join(base_dir, 'subtitles')
+
+ if not os.path.exists(subtitle_target_dir):
+ os.makedirs(subtitle_target_dir, exist_ok=True)
+ with zipfile.ZipFile(subtitle_zip_file, 'r') as zip_ref:
+ for member in zip_ref.namelist():
+ # Check if the member is a file (not a directory)
+ if not member.endswith('/'):
+ # Extract the file to the specified directory
+ source = zip_ref.open(member)
+ target = open(os.path.join(subtitle_target_dir, os.path.basename(member)), 'wb')
+ with source, target:
+ target.write(source.read())
+ print('The subtitle file has been restored and stored from the zip file.')
+ else:
+ print('The subtitle file already exists.')
+
+ audio_target_dir = os.path.join(base_dir, 'audios')
+ if not os.path.exists(audio_target_dir):
+ os.makedirs(audio_target_dir, exist_ok=True)
+ videos = os.listdir(target_dir)
+ for video in videos:
+ video_path = os.path.join(target_dir, video)
+ audio_path = os.path.join(audio_target_dir, video.replace('.mp4', '.wav'))
+ video = VideoFileClip(video_path)
+ audio = video.audio
+ audio.write_audiofile(audio_path, verbose=False, logger=None)
+ video.close()
+ audio.close()
+ print('The audio file has been extracted from videos.')
+ else:
+ print('The audio file already exists.')
+
+
+ def generate_tsv(pth):
+
+ data_file = osp.join(pth, f'{dataset_name}.tsv')
+ print (data_file, md5(data_file))
+ if os.path.exists(data_file) and md5(data_file) == self.MD5:
+ return
+
+ with open(osp.join(pth, 'worldsense_qa.json'), 'rb') as file:
+ json_data = json.load(file)
+
+ videos = list(json_data.keys())
+ qa_index = 0
+ data_list = []
+ data_list.append(['index', 'video', 'video_path', 'duration', 'domain', 'candidates', 'sub_category', 'audio_class', 'task_domain', 'task_type', 'subtitle_path', 'audio_path', 'video_caption', 'question', 'answer'])
+ for video in videos:
+ video_data = json_data[video]
+ tasks_data = list(video_data.keys())
+ tasks_data = [task for task in tasks_data if 'task' in task]
+ for _task in tasks_data:
+ task_list = []
+ _task_data = video_data[_task]
+ task_list.append(qa_index)
+ task_list.append(str(video))
+ task_list.append(f'./videos/{video}.mp4')
+ task_list.append(video_data['duration'])
+ task_list.append(video_data['domain'])
+ task_list.append(_task_data['candidates'])
+ task_list.append(video_data['sub_category'])
+ task_list.append(video_data['audio_class'])
+ task_list.append(_task_data['task_domain'])
+ task_list.append(_task_data['task_type'])
+ task_list.append(f'./subtitles/{video}.srt')
+ task_list.append(f'./audios/{video}.wav')
+ task_list.append(video_data['video_caption'])
+ task_list.append(_task_data['question'])
+ task_list.append(_task_data['answer'])
+
+ data_list.append(task_list)
+ qa_index += 1
+
+ data_file = data_list
+ data_file = pd.DataFrame(data_file[1:], columns=data_file[0])
+
+ data_file.to_csv(osp.join(pth, f'{dataset_name}.tsv'), sep='\t', index=False)
+
+ if modelscope_flag_set():
+ from modelscope import dataset_snapshot_download
+ dataset_path = dataset_snapshot_download(dataset_id=repo_id)
+ else:
+ dataset_path = snapshot_download(repo_id=repo_id, repo_type='dataset')
+ unzip_hf_zip(dataset_path)
+ generate_tsv(dataset_path)
+
+ data_file = osp.join(dataset_path, f'{dataset_name}.tsv')
+
+ return dict(data_file=data_file, root=dataset_path)
+
+ def save_video_frames(self, video, video_llm=False):
+
+ vid_path = osp.join(self.data_root, 'videos', video + '.mp4')
+ vid = decord.VideoReader(vid_path)
+ video_info = {
+ 'fps': vid.get_avg_fps(),
+ 'n_frames': len(vid),
+ }
+ if self.nframe > 0 and self.fps < 0:
+ step_size = len(vid) / (self.nframe + 1)
+ indices = [int(i * step_size) for i in range(1, self.nframe + 1)]
+ frame_paths = self.frame_paths(video)
+ elif self.fps > 0:
+ # not constrained by num_frames, get frames by fps
+ total_duration = video_info['n_frames'] / video_info['fps']
+ required_frames = int(total_duration * self.fps)
+ step_size = video_info['fps'] / self.fps
+ indices = [int(i * step_size) for i in range(required_frames)]
+ frame_paths = self.frame_paths_fps(video, len(indices))
+
+ flag = np.all([osp.exists(p) for p in frame_paths])
+
+ if not flag:
+ images = [vid[i].asnumpy() for i in indices]
+ images = [Image.fromarray(arr) for arr in images]
+ for im, pth in zip(images, frame_paths):
+ if not osp.exists(pth) and not video_llm:
+ im.save(pth)
+
+ return frame_paths, indices, video_info
+
+ def build_prompt(self, line, video_llm):
+ if isinstance(line, int):
+ assert line < len(self)
+ line = self.data.iloc[line]
+
+ frames, indices, video_info = self.save_video_frames(line['video'], video_llm)
+
+ if self.use_subtitle and os.path.exists(osp.join(self.data_root, line['subtitle_path'])):
+ import pysubs2
+ subs = pysubs2.load(osp.join(self.data_root, line['subtitle_path']), encoding='utf-8')
+ subtitles = []
+
+ if video_llm:
+ n_frame_list = list(range(0, video_info['n_frames'], 1))
+ indices = n_frame_list[0:-1:int(video_info['fps'])]
+ for seleced_frame_id in indices:
+ sub_text = ''
+ cur_time = pysubs2.make_time(fps=video_info['fps'], frames=seleced_frame_id)
+ for sub in subs:
+ if sub.start < cur_time and sub.end > cur_time:
+ sub_text = sub.text.replace('\\N', ' ')
+ break
+ if sub_text.strip():
+ subtitles.append(sub_text)
+ subtitles = '\n'.join(subtitles)
+ else:
+ subtitles = ''
+
+ message = [dict(type='text', value=self.SYS)]
+ if video_llm:
+ message.append(dict(type='video', value=osp.join(self.data_root, 'videos', line['video'] + '.mp4')))
+ if self.use_audio:
+ message.append(dict(type='audio', value=osp.join(self.data_root, 'audios', line['video'] + '.wav')))
+ else:
+ for im in frames:
+ message.append(dict(type='image', value=im))
+ if self.use_audio:
+ message.append(dict(type='audio', value=osp.join(self.data_root, 'audios', line['video'] + '.wav')))
+
+ if self.use_subtitle:
+ text_prompt = self.FRAMES_TMPL_SUB.format(subtitles)
+ elif self.use_audio:
+ text_prompt = self.FRAMES_TMPL_AUDIO
+ else:
+ text_prompt = self.FRAMES_TMPL_NOSUB
+ message.append(dict(type='text', value=text_prompt))
+ question_str = line['question'] + '\n' + '\n'.join(eval(line['candidates']))
+ prompt = 'Question: {}\nAnswer: '.format(question_str)
+ message.append(dict(type='text', value=prompt))
+ return message
+
+ # It returns a dictionary
+ @classmethod
+ def evaluate(self, eval_file, **judge_kwargs):
+ from .utils.worldsense import get_dimension_rating, extract_characters_regex, extract_option
+
+ assert eval_file.endswith('.xlsx'), 'data file should be an xlsx file'
+
+ tmp_file = eval_file.replace('.xlsx', '_tmp.pkl')
+ tgt_file = eval_file.replace('.xlsx', '_rating.json')
+ score_file = eval_file.replace('.xlsx', '_score.xlsx')
+
+ if not osp.exists(score_file):
+ model = judge_kwargs.get('model', 'exact_matching')
+ assert model in ['chatgpt-0125', 'exact_matching', 'gpt-4-0125']
+
+ if model == 'exact_matching':
+ model = None
+ elif gpt_key_set():
+ model = build_judge(**judge_kwargs)
+ if not model.working():
+ warnings.warn('OPENAI API is not working properly, will use exact matching for evaluation')
+ warnings.warn(DEBUG_MESSAGE)
+ model = None
+ else:
+ warnings.warn('OPENAI_API_KEY is not set properly, will use exact matching for evaluation')
+ model = None
+ res = {} if not osp.exists(tmp_file) else load(tmp_file)
+ res = {k: v for k, v in res.items() if FAIL_MSG not in v}
+
+ data = load(eval_file)
+ data_un = data[~pd.isna(data['prediction'])]
+
+ for idx in data['index']:
+ ans = data.loc[data['index'] == idx, 'answer'].values[0]
+ pred = str(data.loc[data['index'] == idx, 'prediction'].values[0])
+
+ if extract_characters_regex(pred) == '':
+ extract_pred = extract_option(
+ model,
+ data.loc[data['index'] == idx].to_dict(orient='records')[0],
+ 'WorldSense'
+ )
+ data.loc[idx, 'score'] = int(extract_pred == ans)
+ else:
+ data.loc[idx, 'score'] = int(extract_characters_regex(pred) == ans)
+
+ rejected = [x for x in data['score'] if x == -1]
+
+ print(
+ f'Among {len(data)} questions, failed to obtain prediction for {len(data) - len(data_un)} questions, '
+ f'failed to obtain the score for another {len(rejected)} questions. '
+ f'Those questions will be counted as -1 score in ALL rating, and will not be counted in VALID rating.'
+ )
+
+ dump(data, score_file)
+
+ rating = get_dimension_rating(score_file)
+ dump(rating, tgt_file)
+ return rating
diff --git a/vlmeval/inference.py b/vlmeval/inference.py
new file mode 100644
index 0000000000000000000000000000000000000000..f144ef1a1a5f649618f93247449361a8b0aab398
--- /dev/null
+++ b/vlmeval/inference.py
@@ -0,0 +1,201 @@
+import torch
+import torch.distributed as dist
+from vlmeval.config import supported_VLM
+from vlmeval.utils import track_progress_rich
+from vlmeval.smp import *
+from vlmeval.dataset.utils import extract_answer
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+def parse_args():
+ parser = argparse.ArgumentParser()
+ parser.add_argument('--data', type=str, nargs='+', required=True)
+ parser.add_argument('--model', type=str, nargs='+', required=True)
+ parser.add_argument('--nproc', type=int, default=4, required=True)
+ parser.add_argument('--verbose', action='store_true')
+ args = parser.parse_args()
+ return args
+
+
+# Only API model is accepted
+def infer_data_api(model, work_dir, model_name, dataset, index_set=None, api_nproc=4, ignore_failed=False):
+ rank, world_size = get_rank_and_world_size()
+ assert rank == 0 and world_size == 1
+ dataset_name = dataset.dataset_name
+ data = dataset.data
+ if index_set is not None:
+ data = data[data['index'].isin(index_set)]
+
+ model = supported_VLM[model_name]() if isinstance(model, str) else model
+ assert getattr(model, 'is_api', False)
+ if hasattr(model, 'set_dump_image'):
+ model.set_dump_image(dataset.dump_image)
+
+ lt, indices = len(data), list(data['index'])
+
+ structs = []
+ for i in range(lt):
+ item = data.iloc[i]
+ if hasattr(model, 'use_custom_prompt') and model.use_custom_prompt(dataset_name):
+ assert hasattr(model, 'build_prompt')
+ struct = model.build_prompt(item, dataset=dataset_name)
+ else:
+ struct = dataset.build_prompt(item)
+ structs.append(struct)
+
+ out_file = f'{work_dir}/{model_name}_{dataset_name}_supp.pkl'
+
+ # To reuse records in MMBench_V11
+ if dataset_name in ['MMBench', 'MMBench_CN']:
+ v11_pred = f'{work_dir}/{model_name}_{dataset_name}_V11.xlsx'
+ if osp.exists(v11_pred):
+ try:
+ reuse_inds = load('http://opencompass.openxlab.space/utils/mmb_reuse.pkl')
+ data = load(v11_pred)
+ ans_map = {x: y for x, y in zip(data['index'], data['prediction']) if x in reuse_inds}
+ dump(ans_map, out_file)
+ except Exception as err:
+ print(type(err), err)
+
+ res = {}
+ if osp.exists(out_file):
+ res = load(out_file)
+ if ignore_failed:
+ res = {k: v for k, v in res.items() if FAIL_MSG not in v}
+
+ structs = [s for i, s in zip(indices, structs) if i not in res]
+ indices = [i for i in indices if i not in res]
+
+ gen_func = model.generate
+ structs = [dict(message=struct, dataset=dataset_name) for struct in structs]
+
+ if len(structs):
+ track_progress_rich(gen_func, structs, nproc=api_nproc, chunksize=api_nproc, save=out_file, keys=indices)
+
+ res = load(out_file)
+ if index_set is not None:
+ res = {k: v for k, v in res.items() if k in index_set}
+ os.remove(out_file)
+ return res
+
+
+def infer_data(model, model_name, work_dir, dataset, out_file, verbose=False, api_nproc=4):
+ dataset_name = dataset.dataset_name
+ prev_file = f'{work_dir}/{model_name}_{dataset_name}_PREV.pkl'
+ res = load(prev_file) if osp.exists(prev_file) else {}
+ if osp.exists(out_file):
+ res.update(load(out_file))
+
+ rank, world_size = get_rank_and_world_size()
+ sheet_indices = list(range(rank, len(dataset), world_size))
+ lt = len(sheet_indices)
+ data = dataset.data.iloc[sheet_indices]
+ data_indices = [i for i in data['index']]
+
+ # If finished, will exit without building the model
+ all_finished = True
+ for i in range(lt):
+ idx = data.iloc[i]['index']
+ if idx not in res:
+ all_finished = False
+ if all_finished:
+ res = {k: res[k] for k in data_indices}
+ dump(res, out_file)
+ return
+
+ # Data need to be inferred
+ data = data[~data['index'].isin(res)]
+ lt = len(data)
+
+ model = supported_VLM[model_name]() if isinstance(model, str) else model
+
+ is_api = getattr(model, 'is_api', False)
+ if is_api:
+ lt, indices = len(data), list(data['index'])
+ supp = infer_data_api(
+ model=model,
+ work_dir=work_dir,
+ model_name=model_name,
+ dataset=dataset,
+ index_set=set(indices),
+ api_nproc=api_nproc)
+ for idx in indices:
+ assert idx in supp
+ res.update(supp)
+ res = {k: res[k] for k in data_indices}
+ dump(res, out_file)
+ return model
+ else:
+ model.set_dump_image(dataset.dump_image)
+
+ for i in tqdm(range(lt)):
+ idx = data.iloc[i]['index']
+ if idx in res:
+ continue
+
+ if hasattr(model, 'use_custom_prompt') and model.use_custom_prompt(dataset_name):
+ struct = model.build_prompt(data.iloc[i], dataset=dataset_name)
+ else:
+ struct = dataset.build_prompt(data.iloc[i])
+
+ response = model.generate(message=struct, dataset=dataset_name)
+ torch.cuda.empty_cache()
+
+ if verbose:
+ print(response, flush=True)
+
+ res[idx] = response
+ if (i + 1) % 10 == 0:
+ dump(res, out_file)
+
+ res = {k: res[k] for k in data_indices}
+ dump(res, out_file)
+ return model
+
+
+# A wrapper for infer_data, do the pre & post processing
+def infer_data_job(model, work_dir, model_name, dataset, verbose=False, api_nproc=4, ignore_failed=False):
+ rank, world_size = get_rank_and_world_size()
+ dataset_name = dataset.dataset_name
+ result_file = osp.join(work_dir, f'{model_name}_{dataset_name}.xlsx')
+
+ prev_file = f'{work_dir}/{model_name}_{dataset_name}_PREV.pkl'
+ if osp.exists(result_file):
+ if rank == 0:
+ data = load(result_file)
+ results = {k: v for k, v in zip(data['index'], data['prediction'])}
+ if not ignore_failed:
+ results = {k: v for k, v in results.items() if FAIL_MSG not in str(v)}
+ dump(results, prev_file)
+ if world_size > 1:
+ dist.barrier()
+
+ tmpl = osp.join(work_dir, '{}' + f'{world_size}_{dataset_name}.pkl')
+ out_file = tmpl.format(rank)
+
+ model = infer_data(
+ model=model, work_dir=work_dir, model_name=model_name, dataset=dataset,
+ out_file=out_file, verbose=verbose, api_nproc=api_nproc)
+ if world_size > 1:
+ dist.barrier()
+
+ if rank == 0:
+ data_all = {}
+ for i in range(world_size):
+ data_all.update(load(tmpl.format(i)))
+
+ data = dataset.data
+ for x in data['index']:
+ assert x in data_all
+ data['full_prediction'] = [str(data_all[x]) for x in data['index']]
+ data['prediction'] = [extract_answer(x) for x in data['full_prediction']]
+ if 'image' in data:
+ data.pop('image')
+
+ dump(data, result_file)
+ for i in range(world_size):
+ os.remove(tmpl.format(i))
+ if world_size > 1:
+ dist.barrier()
+ return model
diff --git a/vlmeval/inference_mt.py b/vlmeval/inference_mt.py
new file mode 100644
index 0000000000000000000000000000000000000000..976e79ac4cc1d7aa891cba94f0914bc8209a846a
--- /dev/null
+++ b/vlmeval/inference_mt.py
@@ -0,0 +1,182 @@
+import torch
+import torch.distributed as dist
+from vlmeval.config import supported_VLM
+from vlmeval.utils import track_progress_rich
+from vlmeval.smp import *
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+def parse_args():
+ parser = argparse.ArgumentParser()
+ parser.add_argument('--data', type=str, nargs='+', required=True)
+ parser.add_argument('--model', type=str, nargs='+', required=True)
+ parser.add_argument('--nproc', type=int, default=4, required=True)
+ parser.add_argument('--verbose', action='store_true')
+ args = parser.parse_args()
+ return args
+
+
+def chat_mt(model, messages, dataset_name):
+ assert len(messages) % 2 == 0
+ nturn = len(messages) // 2
+ utter_stack = []
+ predictions = []
+
+ for i in range(nturn):
+ utter = messages[2 * i]
+ utter_stack.append(utter)
+ try:
+ resp = model.chat(utter_stack, dataset=dataset_name)
+ utter_stack.append(dict(role='assistant', content=resp))
+ except Exception as e:
+ resp = FAIL_MSG + str(e)
+ utter_stack.append(dict(role='assistant', content=resp))
+ predictions.append(resp)
+ return predictions
+
+
+# Only API model is accepted
+def infer_data_api(model, work_dir, model_name, dataset, index_set=None, api_nproc=4, ignore_failed=False):
+ rank, world_size = get_rank_and_world_size()
+ assert rank == 0 and world_size == 1
+ dataset_name = dataset.dataset_name
+ data = dataset.data
+ if index_set is not None:
+ data = data[data['index'].isin(index_set)]
+
+ model = supported_VLM[model_name]() if isinstance(model, str) else model
+ assert getattr(model, 'is_api', False)
+ assert hasattr(model, 'chat_inner')
+
+ lt, indices = len(data), list(data['index'])
+ structs = [dataset.build_prompt(data.iloc[i]) for i in range(lt)]
+
+ out_file = f'{work_dir}/{model_name}_{dataset_name}_supp.pkl'
+ res = {}
+ if osp.exists(out_file):
+ res = load(out_file)
+ if ignore_failed:
+ res = {k: v for k, v in res.items() if FAIL_MSG not in v}
+
+ structs = [s for i, s in zip(indices, structs) if i not in res]
+ indices = [i for i in indices if i not in res]
+
+ structs = [dict(model=model, messages=struct, dataset_name=dataset_name) for struct in structs]
+
+ if len(structs):
+ track_progress_rich(chat_mt, structs, nproc=api_nproc, chunksize=api_nproc, save=out_file, keys=indices)
+
+ res = load(out_file)
+ if index_set is not None:
+ res = {k: v for k, v in res.items() if k in index_set}
+ os.remove(out_file)
+ return res
+
+
+def infer_data(model, model_name, work_dir, dataset, out_file, verbose=False, api_nproc=4):
+ dataset_name = dataset.dataset_name
+ res = {}
+ if osp.exists(out_file):
+ res.update(load(out_file))
+
+ rank, world_size = get_rank_and_world_size()
+ sheet_indices = list(range(rank, len(dataset), world_size))
+ lt = len(sheet_indices)
+ data = dataset.data.iloc[sheet_indices]
+ data_indices = [i for i in data['index']]
+
+ # If finished, will exit without building the model
+ all_finished = True
+ for i in range(lt):
+ idx = data.iloc[i]['index']
+ if idx not in res:
+ all_finished = False
+ if all_finished:
+ res = {k: res[k] for k in data_indices}
+ dump(res, out_file)
+ return
+
+ # Data need to be inferred
+ data = data[~data['index'].isin(res)]
+ lt = len(data)
+
+ model = supported_VLM[model_name]() if isinstance(model, str) else model
+ assert hasattr(model, 'chat_inner')
+
+ is_api = getattr(model, 'is_api', False)
+ if is_api:
+ lt, indices = len(data), list(data['index'])
+ supp = infer_data_api(
+ model=model,
+ work_dir=work_dir,
+ model_name=model_name,
+ dataset=dataset,
+ index_set=set(indices),
+ api_nproc=api_nproc)
+ for idx in indices:
+ assert idx in supp
+ res.update(supp)
+ res = {k: res[k] for k in data_indices}
+ dump(res, out_file)
+ return model
+ else:
+ model.set_dump_image(dataset.dump_image)
+
+ for i in tqdm(range(lt)):
+ idx = data.iloc[i]['index']
+ if idx in res:
+ continue
+
+ if hasattr(model, 'use_custom_prompt') and model.use_custom_prompt(dataset_name):
+ struct = model.build_prompt(data.iloc[i], dataset=dataset_name)
+ else:
+ struct = dataset.build_prompt(data.iloc[i])
+
+ response = chat_mt(model, struct, dataset_name)
+ torch.cuda.empty_cache()
+
+ if verbose:
+ print(response, flush=True)
+
+ res[idx] = response
+ if (i + 1) % 20 == 0:
+ dump(res, out_file)
+
+ res = {k: res[k] for k in data_indices}
+ dump(res, out_file)
+ return model
+
+
+# A wrapper for infer_data, do the pre & post processing
+def infer_data_job_mt(model, work_dir, model_name, dataset, verbose=False, api_nproc=4, ignore_failed=False):
+ rank, world_size = get_rank_and_world_size()
+ dataset_name = dataset.dataset_name
+ result_file = osp.join(work_dir, f'{model_name}_{dataset_name}.tsv')
+
+ tmpl = osp.join(work_dir, '{}' + f'{world_size}_{dataset_name}.pkl')
+ out_file = tmpl.format(rank)
+
+ model = infer_data(
+ model=model, model_name=model_name,work_dir=work_dir, dataset=dataset,
+ out_file=out_file, verbose=verbose, api_nproc=api_nproc)
+ if world_size > 1:
+ dist.barrier()
+
+ if rank == 0:
+ data_all = {}
+ for i in range(world_size):
+ data_all.update(load(tmpl.format(i)))
+
+ data = dataset.data
+ for x in data['index']:
+ assert x in data_all
+
+ data['prediction'] = [data_all[x] for x in data['index']]
+ if 'image' in data:
+ data.pop('image')
+
+ dump(data, result_file)
+ for i in range(world_size):
+ os.remove(tmpl.format(i))
+ return model
diff --git a/vlmeval/inference_video.py b/vlmeval/inference_video.py
new file mode 100644
index 0000000000000000000000000000000000000000..a9f514c6383266e8e46d6f0d6788e3477d35fb1d
--- /dev/null
+++ b/vlmeval/inference_video.py
@@ -0,0 +1,183 @@
+import torch
+import torch.distributed as dist
+from vlmeval.config import supported_VLM
+from vlmeval.utils import track_progress_rich
+from vlmeval.smp import *
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+def parse_args():
+ parser = argparse.ArgumentParser()
+ parser.add_argument('--data', type=str, nargs='+', required=True)
+ parser.add_argument('--model', type=str, nargs='+', required=True)
+ parser.add_argument('--nproc', type=int, default=4, required=True)
+ parser.add_argument('--verbose', action='store_true')
+ args = parser.parse_args()
+ return args
+
+
+# Only API model is accepted
+def infer_data_api(model, work_dir, model_name, dataset, samples_dict={}, api_nproc=4):
+ rank, world_size = get_rank_and_world_size()
+ assert rank == 0 and world_size == 1
+ dataset_name = dataset.dataset_name
+ model = supported_VLM[model_name]() if isinstance(model, str) else model
+ assert getattr(model, 'is_api', False)
+
+ indices = list(samples_dict.keys())
+ structs = [dataset.build_prompt(samples_dict[idx], video_llm=getattr(model, 'VIDEO_LLM', False)) for idx in indices]
+
+ packstr = 'pack' if getattr(dataset, 'pack', False) else 'nopack'
+ if dataset.nframe > 0:
+ out_file = f'{work_dir}/{model_name}_{dataset_name}_{dataset.nframe}frame_{packstr}_supp.pkl'
+ else:
+ out_file = f'{work_dir}/{model_name}_{dataset_name}_{dataset.fps}fps_{packstr}_supp.pkl'
+ res = load(out_file) if osp.exists(out_file) else {}
+
+ structs = [s for i, s in zip(indices, structs) if i not in res or res[i] == FAIL_MSG]
+ indices = [i for i in indices if i not in res or res[i] == FAIL_MSG]
+
+ gen_func = model.generate
+ structs = [dict(message=struct, dataset=dataset_name) for struct in structs]
+
+ if len(structs):
+ track_progress_rich(gen_func, structs, nproc=api_nproc, chunksize=api_nproc, save=out_file, keys=indices)
+
+ res = load(out_file)
+ return res
+
+
+def infer_data(model, model_name, work_dir, dataset, out_file, verbose=False, api_nproc=4):
+ res = load(out_file) if osp.exists(out_file) else {}
+ rank, world_size = get_rank_and_world_size()
+ dataset_name = dataset.dataset_name
+
+ sample_indices = list(dataset.videos) if getattr(dataset, 'pack', False) else list(dataset.data['index'])
+ samples = list(dataset.videos) if getattr(dataset, 'pack', False) else list(range(len(dataset.data)))
+ sample_map = {i: s for i, s in zip(sample_indices, samples)}
+
+ sample_indices_sub = sample_indices[rank::world_size]
+ if np.all([idx in res for idx in sample_indices_sub]):
+ return model
+ sample_indices_subrem = [x for x in sample_indices_sub if x not in res]
+
+ model = supported_VLM[model_name]() if isinstance(model, str) else model
+
+ is_api = getattr(model, 'is_api', False)
+ if is_api:
+ assert world_size == 1
+ supp = infer_data_api(
+ model=model,
+ work_dir=work_dir,
+ model_name=model_name,
+ dataset=dataset,
+ samples_dict={k: sample_map[k] for k in sample_indices_subrem},
+ api_nproc=api_nproc)
+ for k in sample_indices_subrem:
+ assert k in supp
+ res.update(supp)
+ dump(res, out_file)
+ return model
+
+ assert not getattr(dataset, 'pack', False), 'Current model not supported pack mode!'
+ for i, idx in tqdm(enumerate(sample_indices_subrem)):
+ if idx in res:
+ continue
+ if getattr(model, 'nframe', None) is not None and getattr(model, 'nframe', 0) > 0:
+ if dataset.nframe > 0:
+ if getattr(model, 'nframe', 0) != dataset.nframe:
+ print(f'{model_name} is a video-llm model, nframe is set to {dataset.nframe}, not using default')
+ setattr(model, 'nframe', dataset.nframe)
+ elif getattr(model, 'fps', 0) == 0:
+ raise ValueError(f'fps is not suitable for {model_name}')
+ else:
+ setattr(model, 'nframe', None)
+ if getattr(model, 'fps', None) is not None and getattr(model, 'fps', 0) > 0:
+ if dataset.fps > 0:
+ if getattr(model, 'fps', 0) != dataset.fps:
+ print(f'{model_name} is a video-llm model, fps is set to {dataset.fps}, not using default')
+ setattr(model, 'fps', dataset.fps)
+ elif getattr(model, 'nframe', 0) == 0:
+ raise ValueError(f'nframe is not suitable for {model_name}')
+ else:
+ setattr(model, 'fps', None)
+ if 'SUB_DATASET' in dataset.data.iloc[sample_map[idx]]:
+ dataset_name = dataset.data.iloc[sample_map[idx]]['SUB_DATASET']
+ if hasattr(model, 'use_custom_prompt') and model.use_custom_prompt(dataset_name):
+ if dataset.nframe == 0:
+ raise ValueError(f'nframe must be set for custom prompt, fps is not suitable for {model_name}')
+ struct = model.build_prompt(
+ dataset.data.iloc[sample_map[idx]], dataset=dataset, video_llm=getattr(model, 'VIDEO_LLM', False)
+ )
+ else:
+ struct = dataset.build_prompt(
+ sample_map[idx], video_llm=getattr(model, 'VIDEO_LLM', False)
+ )
+ response = model.generate(message=struct, dataset=dataset_name)
+ torch.cuda.empty_cache()
+
+ if verbose:
+ print(response, flush=True)
+
+ res[idx] = response
+ if (i + 1) % 20 == 0:
+ dump(res, out_file)
+
+ res = {k: res[k] for k in sample_indices_sub}
+ dump(res, out_file)
+ return model
+
+
+# A wrapper for infer_data, do the pre & post processing
+def infer_data_job_video(
+ model,
+ work_dir,
+ model_name,
+ dataset,
+ result_file_name,
+ verbose=False,
+ api_nproc=4):
+
+ dataset_name = dataset.dataset_name
+ rank, world_size = get_rank_and_world_size()
+ result_file = osp.join(work_dir, result_file_name)
+ # Dump Predictions to Prev File if result file exists
+ if osp.exists(result_file):
+ return model
+
+ tmpl = osp.join(work_dir, '{}' + f'{world_size}_{osp.splitext(result_file_name)[0]}.pkl')
+ out_file = tmpl.format(rank)
+
+ model = infer_data(
+ model=model,
+ model_name=model_name,
+ work_dir=work_dir,
+ dataset=dataset,
+ out_file=out_file,
+ verbose=verbose,
+ api_nproc=api_nproc)
+
+ if world_size > 1:
+ dist.barrier()
+
+ if rank == 0:
+ data_all = {}
+ for i in range(world_size):
+ data_all.update(load(tmpl.format(i)))
+
+ meta = dataset.data
+ if dataset_name == 'MMBench-Video' and getattr(dataset, 'pack', False):
+ meta, vstats = dataset.load_pack_answers(data_all)
+ print(f'Statitics of Pack Video Inference: {vstats}')
+ else:
+ for x in meta['index']:
+ assert x in data_all
+ meta['prediction'] = [str(data_all[x]) for x in meta['index']]
+ if 'image' in meta:
+ meta.pop('image')
+
+ dump(meta, result_file)
+ for i in range(world_size):
+ os.remove(tmpl.format(i))
+ return model
diff --git a/vlmeval/smp/__init__.py b/vlmeval/smp/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..46e89687d469b83ec7dd7e3205841d35087108c7
--- /dev/null
+++ b/vlmeval/smp/__init__.py
@@ -0,0 +1,4 @@
+from .file import *
+from .vlm import *
+from .misc import *
+from .log import *
diff --git a/vlmeval/smp/file.py b/vlmeval/smp/file.py
new file mode 100644
index 0000000000000000000000000000000000000000..611890da405d848622a5c1f4fbb9d7de33d20877
--- /dev/null
+++ b/vlmeval/smp/file.py
@@ -0,0 +1,381 @@
+import json
+import pickle
+import pandas as pd
+import os
+import csv
+import hashlib
+import os.path as osp
+import time
+import numpy as np
+import validators
+import mimetypes
+import multiprocessing as mp
+from .misc import toliststr
+from .vlm import decode_base64_to_image_file
+
+
+def decode_img_omni(tup):
+ root, im, p = tup
+ images = toliststr(im)
+ paths = toliststr(p)
+ if len(images) > 1 and len(paths) == 1:
+ paths = [osp.splitext(p)[0] + f'_{i}' + osp.splitext(p)[1] for i in range(len(images))]
+
+ assert len(images) == len(paths)
+ paths = [osp.join(root, p) for p in paths]
+ for p, im in zip(paths, images):
+ if osp.exists(p):
+ continue
+ if isinstance(im, str) and len(im) > 64:
+ decode_base64_to_image_file(im, p)
+ return paths
+
+
+def localize_df(data, dname, nproc=32):
+ assert 'image' in data
+ indices = list(data['index'])
+ indices_str = [str(x) for x in indices]
+ images = list(data['image'])
+ image_map = {x: y for x, y in zip(indices_str, images)}
+
+ root = LMUDataRoot()
+ root = osp.join(root, 'images', dname)
+ os.makedirs(root, exist_ok=True)
+
+ if 'image_path' in data:
+ img_paths = list(data['image_path'])
+ else:
+ img_paths = []
+ for i in indices_str:
+ if len(image_map[i]) <= 64 and isinstance(image_map[i], str):
+ idx = image_map[i]
+ assert idx in image_map and len(image_map[idx]) > 64
+ img_paths.append(f'{idx}.jpg')
+ else:
+ img_paths.append(f'{i}.jpg')
+
+ tups = [(root, im, p) for p, im in zip(img_paths, images)]
+
+ pool = mp.Pool(32)
+ ret = pool.map(decode_img_omni, tups)
+ pool.close()
+ data.pop('image')
+ if 'image_path' not in data:
+ data['image_path'] = [x[0] if len(x) == 1 else x for x in ret]
+ return data
+
+
+def LMUDataRoot():
+ if 'LMUData' in os.environ and osp.exists(os.environ['LMUData']):
+ return os.environ['LMUData']
+ home = osp.expanduser('~')
+ root = osp.join(home, 'LMUData')
+ os.makedirs(root, exist_ok=True)
+ return root
+
+
+def HFCacheRoot():
+ cache_list = ['HUGGINGFACE_HUB_CACHE', 'HF_HOME']
+ for cache_name in cache_list:
+ if cache_name in os.environ and osp.exists(os.environ[cache_name]):
+ if os.environ[cache_name].split('/')[-1] == 'hub':
+ return os.environ[cache_name]
+ else:
+ return osp.join(os.environ[cache_name], 'hub')
+ home = osp.expanduser('~')
+ root = osp.join(home, '.cache', 'huggingface', 'hub')
+ os.makedirs(root, exist_ok=True)
+ return root
+
+
+def MMBenchOfficialServer(dataset_name):
+ root = LMUDataRoot()
+
+ if dataset_name in ['MMBench', 'MMBench_V11', 'MMBench_CN', 'MMBench_CN_V11']:
+ ans_file = f'{root}/{dataset_name}.tsv'
+ if osp.exists(ans_file):
+ data = load(ans_file)
+ if 'answer' in data and sum([pd.isna(x) for x in data['answer']]) == 0:
+ return True
+
+ if dataset_name in ['MMBench_TEST_EN', 'MMBench_TEST_CN', 'MMBench_TEST_EN_V11', 'MMBench_TEST_CN_V11']:
+ ans_file1 = f'{root}/{dataset_name}.tsv'
+ mapp = {
+ 'MMBench_TEST_EN': 'MMBench', 'MMBench_TEST_CN': 'MMBench_CN',
+ 'MMBench_TEST_EN_V11': 'MMBench_V11', 'MMBench_TEST_CN_V11': 'MMBench_CN_V11',
+ }
+ ans_file2 = f'{root}/{mapp[dataset_name]}.tsv'
+ for f in [ans_file1, ans_file2]:
+ if osp.exists(f):
+ data = load(f)
+ if 'answer' in data and sum([pd.isna(x) for x in data['answer']]) == 0:
+ return True
+ return False
+
+
+class NumpyEncoder(json.JSONEncoder):
+ def default(self, obj):
+ if isinstance(obj, (np.int_, np.intc, np.intp, np.int8,
+ np.int16, np.int32, np.int64, np.uint8,
+ np.uint16, np.uint32, np.uint64)):
+ return int(obj)
+ elif isinstance(obj, (np.float_, np.float16, np.float32, np.float64)):
+ return float(obj)
+ elif isinstance(obj, (np.complex_, np.complex64, np.complex128)):
+ return {'real': obj.real, 'imag': obj.imag}
+ elif isinstance(obj, (np.ndarray,)):
+ return obj.tolist()
+ elif isinstance(obj, (np.bool_)):
+ return bool(obj)
+ elif isinstance(obj, (np.void)):
+ return None
+ return json.JSONEncoder.default(self, obj)
+
+
+# LOAD & DUMP
+def dump(data, f, **kwargs):
+ def dump_pkl(data, pth, **kwargs):
+ pickle.dump(data, open(pth, 'wb'))
+
+ def dump_json(data, pth, **kwargs):
+ json.dump(data, open(pth, 'w'), indent=4, ensure_ascii=False, cls=NumpyEncoder)
+
+ def dump_jsonl(data, f, **kwargs):
+ lines = [json.dumps(x, ensure_ascii=False, cls=NumpyEncoder) for x in data]
+ with open(f, 'w', encoding='utf8') as fout:
+ fout.write('\n'.join(lines))
+
+ def dump_xlsx(data, f, **kwargs):
+ data.to_excel(f, index=False, engine='xlsxwriter')
+
+ def dump_csv(data, f, quoting=csv.QUOTE_ALL):
+ data.to_csv(f, index=False, encoding='utf-8', quoting=quoting)
+
+ def dump_tsv(data, f, quoting=csv.QUOTE_ALL):
+ data.to_csv(f, sep='\t', index=False, encoding='utf-8', quoting=quoting)
+
+ handlers = dict(pkl=dump_pkl, json=dump_json, jsonl=dump_jsonl, xlsx=dump_xlsx, csv=dump_csv, tsv=dump_tsv)
+ suffix = f.split('.')[-1]
+ return handlers[suffix](data, f, **kwargs)
+
+
+def load(f, fmt=None):
+ def load_pkl(pth):
+ return pickle.load(open(pth, 'rb'))
+
+ def load_json(pth):
+ return json.load(open(pth, 'r', encoding='utf-8'))
+
+ def load_jsonl(f):
+ lines = open(f, encoding='utf-8').readlines()
+ lines = [x.strip() for x in lines]
+ if lines[-1] == '':
+ lines = lines[:-1]
+ data = [json.loads(x) for x in lines]
+ return data
+
+ def load_xlsx(f):
+ return pd.read_excel(f)
+
+ def load_csv(f):
+ return pd.read_csv(f)
+
+ def load_tsv(f):
+ return pd.read_csv(f, sep='\t')
+
+ import validators
+ if validators.url(f):
+ tgt = osp.join(LMUDataRoot(), 'files', osp.basename(f))
+ if not osp.exists(tgt):
+ download_file(f, tgt)
+ f = tgt
+
+ handlers = dict(pkl=load_pkl, json=load_json, jsonl=load_jsonl, xlsx=load_xlsx, csv=load_csv, tsv=load_tsv)
+ if fmt is not None:
+ return handlers[fmt](f)
+
+ suffix = f.split('.')[-1]
+ return handlers[suffix](f)
+
+
+def download_file(url, filename=None):
+ import urllib.request
+ from tqdm import tqdm
+
+ class DownloadProgressBar(tqdm):
+ def update_to(self, b=1, bsize=1, tsize=None):
+ if tsize is not None:
+ self.total = tsize
+ self.update(b * bsize - self.n)
+
+ if filename is None:
+ filename = url.split('/')[-1]
+
+ try:
+ with DownloadProgressBar(unit='B', unit_scale=True, miniters=1, desc=url.split('/')[-1]) as t:
+ urllib.request.urlretrieve(url, filename=filename, reporthook=t.update_to)
+ except Exception as e:
+ import logging
+ logging.warning(f'{type(e)}: {e}')
+ # Handle Failed Downloads from huggingface.co
+ if 'huggingface.co' in url:
+ url_new = url.replace('huggingface.co', 'hf-mirror.com')
+ try:
+ download_file(url_new, filename)
+ return filename
+ except Exception as e:
+ logging.warning(f'{type(e)}: {e}')
+ raise Exception(f'Failed to download {url}')
+ else:
+ raise Exception(f'Failed to download {url}')
+
+ return filename
+
+
+def ls(dirname='.', match=[], mode='all', level=1):
+ if isinstance(level, str):
+ assert '+' in level
+ level = int(level[:-1])
+ res = []
+ for i in range(1, level + 1):
+ res.extend(ls(dirname, match=match, mode='file', level=i))
+ return res
+
+ if dirname == '.':
+ ans = os.listdir(dirname)
+ else:
+ ans = [osp.join(dirname, x) for x in os.listdir(dirname)]
+ assert mode in ['all', 'dir', 'file']
+ assert level >= 1 and isinstance(level, int)
+ if level == 1:
+ if isinstance(match, str):
+ match = [match]
+ for m in match:
+ if len(m) == 0:
+ continue
+ if m[0] != '!':
+ ans = [x for x in ans if m in x]
+ else:
+ ans = [x for x in ans if m[1:] not in x]
+ if mode == 'dir':
+ ans = [x for x in ans if osp.isdir(x)]
+ elif mode == 'file':
+ ans = [x for x in ans if not osp.isdir(x)]
+ return ans
+ else:
+ dirs = [x for x in ans if osp.isdir(x)]
+ res = []
+ for d in dirs:
+ res.extend(ls(d, match=match, mode=mode, level=level - 1))
+ return res
+
+
+def mrlines(fname, sp='\n'):
+ f = open(fname).read().split(sp)
+ while f != [] and f[-1] == '':
+ f = f[:-1]
+ return f
+
+
+def mwlines(lines, fname):
+ with open(fname, 'w') as fout:
+ fout.write('\n'.join(lines))
+
+
+def md5(s):
+ hash = hashlib.new('md5')
+ if osp.exists(s):
+ with open(s, 'rb') as f:
+ for chunk in iter(lambda: f.read(2**20), b''):
+ hash.update(chunk)
+ else:
+ hash.update(s.encode('utf-8'))
+ return str(hash.hexdigest())
+
+
+def last_modified(pth):
+ stamp = osp.getmtime(pth)
+ m_ti = time.ctime(stamp)
+ t_obj = time.strptime(m_ti)
+ t = time.strftime('%Y%m%d%H%M%S', t_obj)[2:]
+ return t
+
+
+def parse_file(s):
+ if osp.exists(s) and s != '.':
+ assert osp.isfile(s)
+ suffix = osp.splitext(s)[1].lower()
+ # 添加对webp的支持
+ if suffix == '.webp':
+ return ('image/webp', s)
+ mime = mimetypes.types_map.get(suffix, 'unknown')
+ return (mime, s)
+ elif s.startswith('data:image/'):
+ # To be compatible with OPENAI base64 format
+ content = s[11:]
+ mime = content.split(';')[0]
+ content = ';'.join(content.split(';')[1:])
+ dname = osp.join(LMUDataRoot(), 'files')
+ assert content.startswith('base64,')
+ b64 = content[7:]
+ os.makedirs(dname, exist_ok=True)
+ tgt = osp.join(dname, md5(b64) + '.png')
+ decode_base64_to_image_file(b64, tgt)
+ return parse_file(tgt)
+ elif validators.url(s):
+ suffix = osp.splitext(s)[1].lower()
+ # 添加对webp的支持
+ if suffix == '.webp':
+ mime = 'image/webp'
+ elif suffix in mimetypes.types_map:
+ mime = mimetypes.types_map[suffix]
+ dname = osp.join(LMUDataRoot(), 'files')
+ os.makedirs(dname, exist_ok=True)
+ tgt = osp.join(dname, md5(s) + suffix)
+ download_file(s, tgt)
+ return (mime, tgt)
+ else:
+ return ('url', s)
+
+ else:
+ return (None, s)
+
+
+def file_size(f, unit='GB'):
+ stats = os.stat(f)
+ div_map = {
+ 'GB': 2 ** 30,
+ 'MB': 2 ** 20,
+ 'KB': 2 ** 10,
+ }
+ return stats.st_size / div_map[unit]
+
+
+def parquet_to_tsv(file_path):
+ data = pd.read_parquet(file_path)
+ pth = '/'.join(file_path.split('/')[:-1])
+ data_name = file_path.split('/')[-1].split('.')[0]
+ data.to_csv(osp.join(pth, f'{data_name}.tsv'), sep='\t', index=False)
+
+
+def fetch_aux_files(eval_file):
+ file_root = osp.dirname(eval_file)
+ file_name = osp.basename(eval_file)
+
+ eval_id = osp.basename(file_root)
+ if eval_id[:3] == 'T20' and eval_id[9:11] == '_G':
+ model_name = osp.basename(osp.dirname(file_root))
+ else:
+ model_name = eval_id
+
+ dataset_name = osp.splitext(file_name)[0][len(model_name) + 1:]
+ from vlmeval.dataset import SUPPORTED_DATASETS
+ to_handle = []
+ for d in SUPPORTED_DATASETS:
+ if d.startswith(dataset_name) and d != dataset_name:
+ to_handle.append(d)
+ fs = ls(file_root, match=f'{model_name}_{dataset_name}')
+ if len(to_handle):
+ for d in to_handle:
+ fs = [x for x in fs if d not in x]
+ return fs
diff --git a/vlmeval/smp/log.py b/vlmeval/smp/log.py
new file mode 100644
index 0000000000000000000000000000000000000000..26e00b19840ce667ffbddd7796d82ccac1cc6889
--- /dev/null
+++ b/vlmeval/smp/log.py
@@ -0,0 +1,47 @@
+import logging
+logging.basicConfig(
+ format='[%(asctime)s] %(levelname)s - %(filename)s: %(funcName)s - %(lineno)d: %(message)s',
+ datefmt='%Y-%m-%d %H:%M:%S')
+
+logger_initialized = {}
+
+
+def get_logger(name, log_file=None, log_level=logging.INFO, file_mode='w'):
+ logger = logging.getLogger(name)
+ if name in logger_initialized:
+ return logger
+
+ for logger_name in logger_initialized:
+ if name.startswith(logger_name):
+ return logger
+
+ stream_handler = logging.StreamHandler()
+ handlers = [stream_handler]
+
+ try:
+ import torch.distributed as dist
+ if dist.is_available() and dist.is_initialized():
+ rank = dist.get_rank()
+ else:
+ rank = 0
+ except ImportError:
+ rank = 0
+
+ if rank == 0 and log_file is not None:
+ file_handler = logging.FileHandler(log_file, file_mode)
+ handlers.append(file_handler)
+
+ formatter = logging.Formatter(
+ '[%(asctime)s] %(levelname)s - %(name)s - %(filename)s: %(funcName)s - %(lineno)d: %(message)s')
+ for handler in handlers:
+ handler.setFormatter(formatter)
+ handler.setLevel(log_level)
+ logger.addHandler(handler)
+
+ if rank == 0:
+ logger.setLevel(log_level)
+ else:
+ logger.setLevel(logging.ERROR)
+
+ logger_initialized[name] = True
+ return logger
diff --git a/vlmeval/smp/misc.py b/vlmeval/smp/misc.py
new file mode 100644
index 0000000000000000000000000000000000000000..d0d9e909f97ec93f6eebced17b46a794cea0d716
--- /dev/null
+++ b/vlmeval/smp/misc.py
@@ -0,0 +1,291 @@
+# flake8: noqa: F401, F403
+import abc
+import argparse
+import csv
+import multiprocessing as mp
+import os
+import os.path as osp
+from pathlib import Path
+import copy as cp
+import random as rd
+import requests
+import shutil
+import subprocess
+import warnings
+import pandas as pd
+from collections import OrderedDict, defaultdict
+from multiprocessing import Pool, current_process
+from tqdm import tqdm
+import datetime
+import matplotlib.pyplot as plt
+from tabulate import tabulate
+from json import JSONDecoder
+from huggingface_hub import scan_cache_dir
+from huggingface_hub.utils._cache_manager import _scan_cached_repo
+from sty import fg, bg, ef, rs
+
+
+def modelscope_flag_set():
+ return os.environ.get('VLMEVALKIT_USE_MODELSCOPE', None) in ['1', 'True']
+
+
+def process_punctuation(inText):
+ import re
+ outText = inText
+ punct = [
+ ';', r'/', '[', ']', '"', '{', '}', '(', ')', '=', '+', '\\', '_', '-',
+ '>', '<', '@', '`', ',', '?', '!'
+ ]
+ commaStrip = re.compile('(\d)(,)(\d)') # noqa: W605
+ periodStrip = re.compile('(?!<=\d)(\.)(?!\d)') # noqa: W605
+ for p in punct:
+ if (p + ' ' in inText or ' ' + p in inText) or (re.search(
+ commaStrip, inText) is not None):
+ outText = outText.replace(p, '')
+ else:
+ outText = outText.replace(p, ' ')
+ outText = periodStrip.sub('', outText, re.UNICODE)
+ return outText
+
+def h2r(value):
+ if value[0] == '#':
+ value = value[1:]
+ assert len(value) == 6
+ return tuple(int(value[i:i + 2], 16) for i in range(0, 6, 2))
+
+def r2h(rgb):
+ return '#%02x%02x%02x' % rgb
+
+def colored(s, color):
+ if isinstance(color, str):
+ if hasattr(fg, color):
+ return getattr(fg, color) + s + fg.rs
+ color = h2r(color)
+ return fg(*color) + s + fg.rs
+
+def istype(s, type):
+ if isinstance(s, type):
+ return True
+ try:
+ return isinstance(eval(s), type)
+ except Exception as _:
+ return False
+
+def bincount(lst):
+ bins = defaultdict(lambda: 0)
+ for item in lst:
+ bins[item] += 1
+ return bins
+
+def get_cache_path(repo_id, branch='main', repo_type='datasets'):
+ try:
+ if modelscope_flag_set():
+ from modelscope.hub.file_download import create_temporary_directory_and_cache
+ if repo_type == 'datasets':
+ repo_type = 'dataset'
+ _, cache = create_temporary_directory_and_cache(model_id=repo_id, repo_type=repo_type)
+ cache_path = cache.get_root_location()
+ return cache_path
+ else:
+ from .file import HFCacheRoot
+ cache_path = HFCacheRoot()
+ org, repo_name = repo_id.split('/')
+ repo_path = Path(osp.join(cache_path, f'{repo_type}--{org}--{repo_name}/'))
+ hf_cache_info = _scan_cached_repo(repo_path=repo_path)
+ revs = {r.refs: r for r in hf_cache_info.revisions}
+ if branch is not None:
+ revs = {refs: r for refs, r in revs.items() if branch in refs}
+ rev2keep = max(revs.values(), key=lambda r: r.last_modified)
+ return str(rev2keep.snapshot_path)
+ except Exception as e:
+ import logging
+ logging.warning(f'{type(e)}: {e}')
+ return None
+
+def proxy_set(s):
+ import os
+ for key in ['http_proxy', 'HTTP_PROXY', 'https_proxy', 'HTTPS_PROXY']:
+ os.environ[key] = s
+
+def get_rank_and_world_size():
+ rank = int(os.environ.get('RANK', 0))
+ world_size = int(os.environ.get('WORLD_SIZE', 1))
+ return rank, world_size
+
+def splitlen(s, sym='/'):
+ return len(s.split(sym))
+
+def listinstr(lst, s):
+ assert isinstance(lst, list)
+ for item in lst:
+ if item in s:
+ return True
+ return False
+
+def d2df(D):
+ return pd.DataFrame({x: [D[x]] for x in D})
+
+def cn_string(s):
+ import re
+ if re.search(u'[\u4e00-\u9fff]', s):
+ return True
+ return False
+
+try:
+ import decord
+except ImportError:
+ pass
+
+def timestr(granularity='second'):
+ s = datetime.datetime.now().strftime('%Y%m%d%H%M%S')
+ assert granularity in ['second', 'minute', 'hour', 'day']
+ if granularity == 'second':
+ return s
+ elif granularity == 'minute':
+ return s[:-2]
+ elif granularity == 'hour':
+ return s[:-4]
+ elif granularity == 'day':
+ return s[:-6]
+
+def _minimal_ext_cmd(cmd, cwd=None):
+ env = {}
+ for k in ['SYSTEMROOT', 'PATH', 'HOME']:
+ v = os.environ.get(k)
+ if v is not None:
+ env[k] = v
+ env['LANGUAGE'] = 'C'
+ env['LANG'] = 'C'
+ env['LC_ALL'] = 'C'
+ out = subprocess.Popen(cmd, stdout=subprocess.PIPE, env=env, cwd=cwd).communicate()[0]
+ return out
+
+def githash(fallback='unknown', digits=8):
+ if digits is not None and not isinstance(digits, int):
+ raise TypeError('digits must be None or an integer')
+ try:
+ import vlmeval
+ except ImportError as e:
+ import logging
+ logging.error(f'ImportError: {str(e)}')
+ return fallback
+ try:
+ out = _minimal_ext_cmd(['git', 'rev-parse', 'HEAD'], cwd=vlmeval.__path__[0])
+ sha = out.strip().decode('ascii')
+ if digits is not None:
+ sha = sha[:digits]
+ except OSError:
+ sha = fallback
+ return sha
+
+def dict_merge(dct, merge_dct):
+ for k, _ in merge_dct.items():
+ if (k in dct and isinstance(dct[k], dict) and isinstance(merge_dct[k], dict)): #noqa
+ dict_merge(dct[k], merge_dct[k])
+ else:
+ dct[k] = merge_dct[k]
+
+def youtube_dl(idx):
+ cmd = f'youtube-dl -f best -f mp4 "{idx}" -o {idx}.mp4'
+ os.system(cmd)
+
+def run_command(cmd):
+ if isinstance(cmd, str):
+ cmd = cmd.split()
+ return subprocess.check_output(cmd).decode()
+
+def load_env():
+ import logging
+ logging.basicConfig(
+ format='[%(asctime)s] %(levelname)s - %(filename)s: %(funcName)s - %(lineno)d: %(message)s',
+ datefmt='%Y-%m-%d %H:%M:%S')
+
+ try:
+ import vlmeval
+ except ImportError:
+ logging.error('VLMEval is not installed. Failed to import environment variables from .env file. ')
+ return
+ pth = osp.realpath(vlmeval.__path__[0])
+ pth = osp.join(pth, '../.env')
+ pth = osp.realpath(pth)
+ if not osp.exists(pth):
+ logging.error(f'Did not detect the .env file at {pth}, failed to load. ')
+ return
+
+ from dotenv import dotenv_values
+ values = dotenv_values(pth)
+ for k, v in values.items():
+ if v is not None and len(v):
+ os.environ[k] = v
+ logging.info(f'API Keys successfully loaded from {pth}')
+
+def pip_install_robust(package):
+ import sys
+ retry = 3
+ while retry > 0:
+ try:
+ package_base = package.split('=')[0]
+ module = __import__(package)
+ return True
+ except ImportError:
+ subprocess.check_call([sys.executable, '-m', 'pip', 'install', package])
+ retry -= 1
+ return False
+
+
+def version_cmp(v1, v2, op='eq'):
+ from packaging import version
+ import operator
+ op_func = getattr(operator, op)
+ return op_func(version.parse(v1), version.parse(v2))
+
+
+def toliststr(s):
+ if isinstance(s, str) and (s[0] == '[') and (s[-1] == ']'):
+ return [str(x) for x in eval(s)]
+ elif isinstance(s, str):
+ return [s]
+ elif isinstance(s, list):
+ return [str(x) for x in s]
+ raise NotImplementedError
+
+
+def extract_json_objects(text, decoder=JSONDecoder()):
+ pos = 0
+ while True:
+ match = text.find('{', pos)
+ if match == -1: break
+ try:
+ result, index = decoder.raw_decode(text[match:])
+ yield result
+ pos = match + index
+ except ValueError:
+ pos = match + 1
+
+
+def get_gpu_memory():
+ import subprocess
+ try:
+ command = "nvidia-smi --query-gpu=memory.free --format=csv"
+ memory_free_info = subprocess.check_output(command.split()).decode('ascii').split('\n')[:-1][1:]
+ memory_free_values = [int(x.split()[0]) for i, x in enumerate(memory_free_info)]
+ return memory_free_values
+ except Exception as e:
+ print(f'{type(e)}: {str(e)}')
+ return []
+
+
+def auto_split_flag():
+ flag = os.environ.get('AUTO_SPLIT', '0')
+ if flag == '1':
+ return True
+ _, world_size = get_rank_and_world_size()
+ try:
+ import torch
+ device_count = torch.cuda.device_count()
+ if device_count > world_size and device_count % world_size == 0:
+ return True
+ else:
+ return False
+ except:
+ return False
diff --git a/vlmeval/smp/vlm.py b/vlmeval/smp/vlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..04447edad97e233bdd7d9208ef336a51429f3bed
--- /dev/null
+++ b/vlmeval/smp/vlm.py
@@ -0,0 +1,157 @@
+import os
+import io
+import pandas as pd
+import numpy as np
+import string
+from uuid import uuid4
+import os.path as osp
+import base64
+from PIL import Image
+import sys
+
+Image.MAX_IMAGE_PIXELS = 1e9
+
+
+def rescale_img(img, tgt=None):
+ assert isinstance(tgt, tuple) and -1 in tgt
+ w, h = img.size
+ if tgt[0] != -1:
+ new_w, new_h = tgt[0], int(tgt[0] / w * h)
+ elif tgt[1] != -1:
+ new_w, new_h = int(tgt[1] / h * w), tgt[1]
+ img = img.resize((new_w, new_h))
+ return img
+
+
+def concat_images_vlmeval(images, target_size=-1, mode='h', return_image=False):
+ from .file import md5
+
+ ims = [Image.open(im) for im in images]
+ if target_size != -1:
+ ims = [
+ rescale_img(im, (-1, target_size) if mode == 'h' else (target_size, -1))
+ for im in ims
+ ]
+
+ ws, hs = [x.width for x in ims], [x.height for x in ims]
+ if mode == 'h':
+ new_w, new_h = sum(ws), max(hs)
+ dst = Image.new('RGB', (new_w, new_h))
+ for i, im in enumerate(ims):
+ dst.paste(im, (sum(ws[:i]), 0))
+ elif mode == 'v':
+ new_w, new_h = max(ws), sum(hs)
+ dst = Image.new('RGB', (new_w, new_h))
+ for i, im in enumerate(ims):
+ dst.paste(im, (sum(ws[:i], 0)))
+ if return_image:
+ return dst
+ else:
+ _str = '\n'.join(images)
+ str_md5 = md5(_str)
+ tgt = osp.join('/tmp', str_md5 + '.jpg')
+ dst.save(tgt)
+ return tgt
+
+
+def mmqa_display(question, target_size=-1):
+ question = {k.lower(): v for k, v in question.items()}
+ keys = list(question.keys())
+ keys = [k for k in keys if k not in ['index', 'image']]
+
+ if 'image' in question:
+ images = question.pop('image')
+ if images[0] == '[' and images[-1] == ']':
+ images = eval(images)
+ else:
+ images = [images]
+ else:
+ images = question.pop('image_path')
+ if images[0] == '[' and images[-1] == ']':
+ images = eval(images)
+ else:
+ images = [images]
+ images = [encode_image_file_to_base64(x) for x in images]
+
+ idx = question.pop('index', 'XXX')
+ print(f'INDEX: {idx}')
+
+ for im in images:
+ image = decode_base64_to_image(im, target_size=target_size)
+ display(image) # noqa: F821
+
+ for k in keys:
+ try:
+ if not pd.isna(question[k]):
+ print(f'{k.upper()}. {question[k]}')
+ except ValueError:
+ if False in pd.isna(question[k]):
+ print(f'{k.upper()}. {question[k]}')
+
+
+def encode_image_to_base64(img, target_size=-1, fmt='JPEG'):
+ # if target_size == -1, will not do resizing
+ # else, will set the max_size ot (target_size, target_size)
+ if img.mode in ('RGBA', 'P'):
+ img = img.convert('RGB')
+ if target_size > 0:
+ img.thumbnail((target_size, target_size))
+ img_buffer = io.BytesIO()
+ img.save(img_buffer, format=fmt)
+ image_data = img_buffer.getvalue()
+ ret = base64.b64encode(image_data).decode('utf-8')
+ return ret
+
+
+def encode_image_file_to_base64(image_path, target_size=-1):
+ image = Image.open(image_path)
+ return encode_image_to_base64(image, target_size=target_size)
+
+
+def decode_base64_to_image(base64_string, target_size=-1):
+ image_data = base64.b64decode(base64_string)
+ image = Image.open(io.BytesIO(image_data))
+ if image.mode in ('RGBA', 'P'):
+ image = image.convert('RGB')
+ if target_size > 0:
+ image.thumbnail((target_size, target_size))
+ return image
+
+
+def decode_base64_to_image_file(base64_string, image_path, target_size=-1):
+ image = decode_base64_to_image(base64_string, target_size=target_size)
+ image.save(image_path)
+
+
+def build_option_str(option_dict):
+ s = 'There are several options: \n'
+ for c, content in option_dict.items():
+ if not pd.isna(content):
+ s += f'{c}. {content}\n'
+ return s
+
+
+def isimg(s):
+ return osp.exists(s) or s.startswith('http')
+
+
+def read_ok(img_path):
+ if not osp.exists(img_path):
+ return False
+ try:
+ im = Image.open(img_path)
+ assert im.size[0] > 0 and im.size[1] > 0
+ return True
+ except:
+ return False
+
+
+def gpt_key_set():
+ return True
+ # openai_key = os.environ.get('OPENAI_API_KEY', None)
+ # return isinstance(openai_key, str) and openai_key.startswith('sk-')
+
+
+def apiok(wrapper):
+ s = wrapper.generate('Hello!')
+ return wrapper.fail_msg not in s
diff --git a/vlmeval/tools.py b/vlmeval/tools.py
new file mode 100644
index 0000000000000000000000000000000000000000..de6646c06b82b14c228529ae4ea5b75eb9aa8aed
--- /dev/null
+++ b/vlmeval/tools.py
@@ -0,0 +1,623 @@
+import sys
+from collections import deque
+from vlmeval.dataset import SUPPORTED_DATASETS
+from vlmeval.config import *
+from vlmeval.smp import *
+
+# Define valid modes
+MODES = ('dlist', 'mlist', 'missing', 'circular', 'localize', 'check', 'run', 'eval', 'merge_pkl', 'scan')
+
+CLI_HELP_MSG = \
+ f"""
+ Arguments received: {str(['vlmutil'] + sys.argv[1:])}. vlmutil commands use the following syntax:
+
+ vlmutil MODE MODE_ARGS
+
+ Where MODE (required) is one of {MODES}
+ MODE_ARG (optional) is the argument for specific mode
+
+ Some usages for xtuner commands: (See more by using -h for specific command!)
+
+ 1. List all the dataset by levels: l1, l2, l3, etc.:
+ vlmutil dlist [l1/l2/l3/...]
+ 2. List all the models by categories: 4.33.0, 4.37.0, api, etc.:
+ vlmutil mlist 4.33.0 [all/small/large]
+ 3. Report missing results:
+ vlmutil missing [l1/l2/l3/...]
+ 4. Create circular questions (only for multiple-choice questions with no more than 4 choices):
+ vlmutil circular input.tsv
+ 5. Create a localized version of the dataset (for very large tsv files):
+ vlmutil localize input.tsv
+ 6. Check the validity of a model:
+ vlmutil check [model_name/model_series]
+ 7. Run evaluation for missing results:
+ vlmutil run l2 hf
+ 8. Evaluate data file:
+ vlmutil eval [dataset_name] [prediction_file]
+ 9. Merge pkl files:
+ vlmutil merge_pkl [pkl_dir] [world_size]
+ 10. Scan evaluation results and detect api failure
+ vlmutil scan --model [model_list.txt or model_names] --data [dataset_names] --root [root_dir]
+ GitHub: https://github.com/open-compass/VLMEvalKit
+ """ # noqa: E501
+
+
+dataset_levels = {
+ 'l1': [
+ ('MMVet', 'gpt-4-turbo_score.csv'), ('MMMU_DEV_VAL', 'acc.csv'),
+ ('MathVista_MINI', 'gpt-4-turbo_score.csv'), ('HallusionBench', 'score.csv'),
+ ('OCRBench', 'score.json'), ('AI2D_TEST', 'acc.csv'), ('MMStar', 'acc.csv'),
+ ('MMBench_V11', 'acc.csv'), ('MMBench_CN_V11', 'acc.csv')
+ ],
+ 'l2': [
+ ('MME', 'score.csv'), ('LLaVABench', 'score.csv'), ('RealWorldQA', 'acc.csv'),
+ ('MMBench', 'acc.csv'), ('MMBench_CN', 'acc.csv'), ('CCBench', 'acc.csv'),
+ ('SEEDBench_IMG', 'acc.csv'), ('COCO_VAL', 'score.json'), ('POPE', 'score.csv'),
+ ('ScienceQA_VAL', 'acc.csv'), ('ScienceQA_TEST', 'acc.csv'), ('MMT-Bench_VAL', 'acc.csv'),
+ ('SEEDBench2_Plus', 'acc.csv'), ('BLINK', 'acc.csv'), ('MTVQA_TEST', 'acc.json'),
+ ('Q-Bench1_VAL', 'acc.csv'), ('A-Bench_VAL', 'acc.csv'), ('R-Bench-Dis', 'acc.csv'),
+ ],
+ 'l3': [
+ ('OCRVQA_TESTCORE', 'acc.csv'), ('TextVQA_VAL', 'acc.csv'),
+ ('ChartQA_TEST', 'acc.csv'), ('DocVQA_VAL', 'acc.csv'), ('InfoVQA_VAL', 'acc.csv'),
+ ('SEEDBench2', 'acc.csv')
+ ],
+ 'live': [
+ ('LiveMMBench_VQ_circular', 'acc.csv'), ('LiveMMBench_Spatial_circular', 'acc.csv'),
+ ('LiveMMBench_Reasoning_circular', 'acc.csv'), ('LiveMMBench_Infographic', 'acc.csv'),
+ ('LiveMMBench_Perception', 'acc.csv'), ('LiveMMBench_Creation', 'merged_score.json'),
+ ],
+ 'math': [
+ ('MathVision', 'score.csv'), ('MathVerse_MINI_Vision_Only', 'score.csv'),
+ ('DynaMath', 'score.csv'), ('WeMath', 'score.csv'), ('LogicVista', 'score.csv'),
+ ('MathVista_MINI', 'gpt-4-turbo_score.csv'),
+ ]
+}
+
+dataset_levels['l12'] = dataset_levels['l1'] + dataset_levels['l2']
+dataset_levels['l23'] = dataset_levels['l2'] + dataset_levels['l3']
+dataset_levels['l123'] = dataset_levels['l12'] + dataset_levels['l3']
+
+models = {
+ '4.33.0': list(qwen_series) + list(xcomposer_series) + [
+ 'mPLUG-Owl2', 'flamingov2', 'VisualGLM_6b', 'MMAlaya', 'PandaGPT_13B', 'VXVERSE'
+ ] + list(idefics_series) + list(minigpt4_series) + list(instructblip_series),
+ '4.37.0': [x for x in llava_series if 'next' not in x] + list(internvl_series) + [
+ 'TransCore_M', 'emu2_chat', 'MiniCPM-V', 'MiniCPM-V-2', 'OmniLMM_12B',
+ 'cogvlm-grounding-generalist', 'cogvlm-chat', 'cogvlm2-llama3-chat-19B',
+ 'mPLUG-Owl3'
+ ] + list(xtuner_series) + list(yivl_series) + list(deepseekvl_series) + list(janus_series) + list(cambrian_series),
+ '4.36.2': ['Moondream1'],
+ '4.40.0': [
+ 'idefics2_8b', 'Bunny-llama3-8B', 'MiniCPM-Llama3-V-2_5', '360VL-70B', 'Phi-3-Vision',
+ ] + list(wemm_series),
+ '4.44.0': ['Moondream2'],
+ '4.45.0': ['Aria'],
+ 'latest': ['paligemma-3b-mix-448', 'MiniCPM-V-2_6', 'glm-4v-9b'] + [x for x in llava_series if 'next' in x]
+ + list(chameleon_series) + list(ovis_series) + list(mantis_series),
+ 'api': list(api_models)
+}
+
+# SKIP_MODELS will be skipped in report_missing and run APIs
+SKIP_MODELS = [
+ 'MGM_7B', 'GPT4V_HIGH', 'GPT4V', 'flamingov2', 'PandaGPT_13B',
+ 'GeminiProVision', 'Step1V-0701', 'SenseChat-5-Vision',
+ 'llava_v1_7b', 'sharegpt4v_7b', 'sharegpt4v_13b',
+ 'llava-v1.5-7b-xtuner', 'llava-v1.5-13b-xtuner',
+ 'cogvlm-grounding-generalist', 'InternVL-Chat-V1-1',
+ 'InternVL-Chat-V1-2', 'InternVL-Chat-V1-2-Plus', 'RekaCore',
+ 'llava_next_72b', 'llava_next_110b', 'MiniCPM-V', 'sharecaptioner', 'XComposer',
+ 'VisualGLM_6b', 'idefics_9b_instruct', 'idefics_80b_instruct',
+ 'mPLUG-Owl2', 'MMAlaya', 'OmniLMM_12B', 'emu2_chat', 'VXVERSE'
+] + list(minigpt4_series) + list(instructblip_series) + list(xtuner_series) + list(chameleon_series) + list(vila_series)
+
+LARGE_MODELS = [
+ 'idefics_80b_instruct', '360VL-70B', 'emu2_chat', 'InternVL2-76B',
+]
+
+
+def completed(m, d, suf):
+ score_file = f'outputs/{m}/{m}_{d}_{suf}'
+ if osp.exists(score_file):
+ return True
+ if d == 'MMBench':
+ s1, s2 = f'outputs/{m}/{m}_MMBench_DEV_EN_{suf}', f'outputs/{m}/{m}_MMBench_TEST_EN_{suf}'
+ return osp.exists(s1) and osp.exists(s2)
+ elif d == 'MMBench_CN':
+ s1, s2 = f'outputs/{m}/{m}_MMBench_DEV_CN_{suf}', f'outputs/{m}/{m}_MMBench_TEST_CN_{suf}'
+ return osp.exists(s1) and osp.exists(s2)
+ return False
+
+
+def DLIST(lvl):
+ if lvl in dataset_levels.keys():
+ return [x[0] for x in dataset_levels[lvl]]
+ else:
+ from vlmeval.dataset import SUPPORTED_DATASETS
+ return SUPPORTED_DATASETS
+
+
+def MLIST(lvl, size='all'):
+ if lvl == 'all':
+ from vlmeval.config import supported_VLM
+ return [x for x in supported_VLM]
+
+ model_list = models[lvl]
+ if size == 'small':
+ model_list = [m for m in model_list if m not in LARGE_MODELS]
+ elif size == 'large':
+ model_list = [m for m in model_list if m in LARGE_MODELS]
+ return [x[0] for x in model_list]
+
+
+def MISSING(lvl):
+ from vlmeval.config import supported_VLM
+ models = list(supported_VLM)
+ models = [m for m in models if m not in SKIP_MODELS and osp.exists(osp.join('outputs', m))]
+ if lvl in dataset_levels.keys():
+ data_list = dataset_levels[lvl]
+ else:
+ data_list = [(D, suff) for (D, suff) in dataset_levels['l123'] if D == lvl]
+ missing_list = []
+ for f in models:
+ for D, suff in data_list:
+ if not completed(f, D, suff):
+ missing_list.append((f, D))
+ return missing_list
+
+
+def CIRCULAR(inp):
+ def proc_str(s):
+ chs = set(s)
+ chs = [x for x in chs if x not in string.ascii_letters and x != ' ']
+ for ch in chs:
+ s = s.replace(ch, ' ')
+ return s
+
+ def abnormal_entry(line):
+ choices = {k: line[k] for k in string.ascii_uppercase if k in line and not pd.isna(line[k])}
+ has_label = False
+ for k in choices:
+ s = proc_str(choices[k]).split()
+ hit_words = [x for x in s if x in choices]
+ hit_words = set(hit_words)
+ if len(hit_words) > 1:
+ return True
+ if choices[k] in string.ascii_uppercase:
+ has_label = True
+ return has_label
+
+ assert inp.endswith('.tsv')
+ data = load(inp)
+ OFFSET = 1e6
+ while max(data['index']) >= OFFSET:
+ OFFSET *= 10
+ n_opt = 2
+ for i, ch in enumerate(string.ascii_uppercase):
+ if ch in data:
+ n_opt = ord(ch) - ord('A') + 1
+ else:
+ for j in range(i + 1, 26):
+ assert string.ascii_uppercase[j] not in data
+ groups = defaultdict(list)
+ for i in range(len(data)):
+ item = data.iloc[i]
+ this_n_opt = 0
+ for j, ch in enumerate(string.ascii_uppercase[:n_opt]):
+ if not pd.isna(item[ch]):
+ this_n_opt = j + 1
+ else:
+ for k in range(j + 1, n_opt):
+ assert pd.isna(item[string.ascii_uppercase[k]]), (k, item)
+ assert this_n_opt >= 2 or this_n_opt == 0
+ flag = abnormal_entry(item)
+ if flag or this_n_opt == 0:
+ groups['abnormal'].append(item)
+ elif len(item['answer']) > 1 or item['answer'] not in string.ascii_uppercase[:this_n_opt]:
+ groups['abnormal'].append(item)
+ else:
+ groups[this_n_opt].append(item)
+ for k in groups:
+ groups[k] = pd.concat(groups[k], axis=1).T
+ print(f'{k if k == "abnormal" else str(k) + "-choice"} records: {len(groups[k])}')
+
+ data_all = []
+
+ for k in groups:
+ if k == 'abnormal':
+ warnings.warn(
+ f"{len(groups['abnormal'])} abnormal entries detected. The problems can be: "
+ "1. Choice labels found in some choice contents; 2. No choices found for this question; "
+ "3. The answer is not a valid choice. Will not apply circular to those samples."
+ )
+ abdata = groups['abnormal']
+ abdata['g_index'] = abdata['index']
+ data_all.append(abdata)
+ else:
+ cir_data = []
+ assert isinstance(k, int) and k >= 2
+ labels = string.ascii_uppercase[:k]
+ rotates = [labels]
+ dq = deque(labels)
+ for i in range(k - 1):
+ dq.rotate(1)
+ rotates.append(list(dq))
+ for i, rot in enumerate(rotates):
+ if i == 0:
+ data = groups[k].copy()
+ data['g_index'] = data['index']
+ cir_data.append(data)
+ else:
+ try:
+ data = groups[k].copy()
+ data['index'] = [x + OFFSET * i for x in data['index']]
+ data['g_index'] = [x % OFFSET for x in data['index']]
+ c_map = {k: v for k, v in zip(rotates[0], rot)}
+ data['answer'] = [c_map[x] for x in data['answer']]
+ for s, t in c_map.items():
+ data[t] = groups[k][s]
+ cir_data.append(data)
+ except:
+ print(set(data['answer']))
+ raise NotImplementedError
+ data_all.append(pd.concat(cir_data))
+ data_all = pd.concat(data_all)
+ data_all['index'] = [int(x) for x in data_all['index']]
+ data_all['g_index'] = [int(x) for x in data_all['g_index']]
+
+ tgt_file = inp.replace('.tsv', '_circular.tsv')
+ dump(data_all, tgt_file)
+ print(f'Processed data are saved to {tgt_file}: {len(load(inp))} raw records, {len(data_all)} circularized records.')
+ assert osp.exists(tgt_file)
+ print(f'The MD5 for the circularized data is {md5(tgt_file)}')
+
+
+PTH = osp.realpath(__file__)
+IMAGE_PTH = osp.join(osp.dirname(PTH), '../assets/apple.jpg')
+
+msg1 = [
+ IMAGE_PTH,
+ 'What is in this image?'
+]
+msg2 = [
+ dict(type='image', value=IMAGE_PTH),
+ dict(type='text', value='What is in this image?')
+]
+msg3 = [
+ IMAGE_PTH,
+ IMAGE_PTH,
+ 'How many apples are there in these images?'
+]
+msg4 = [
+ dict(type='image', value=IMAGE_PTH),
+ dict(type='image', value=IMAGE_PTH),
+ dict(type='text', value='How many apples are there in these images?')
+]
+
+
+def CHECK(val):
+ if val in supported_VLM:
+ model = supported_VLM[val]()
+ print(f'Model: {val}')
+ for i, msg in enumerate([msg1, msg2, msg3, msg4]):
+ if i > 1 and not model.INTERLEAVE:
+ continue
+ res = model.generate(msg)
+ print(f'Test {i + 1}: {res}')
+ elif val in models:
+ model_list = models[val]
+ for m in model_list:
+ CHECK(m)
+
+
+def LOCALIZE(fname, new_fname=None):
+ if new_fname is None:
+ new_fname = fname.replace('.tsv', '_local.tsv')
+
+ base_name = osp.basename(fname)
+ dname = osp.splitext(base_name)[0]
+
+ data = load(fname)
+ data_new = localize_df(data, dname)
+ dump(data_new, new_fname)
+ print(f'The localized version of data file is {new_fname}')
+ return new_fname
+
+
+def RUN(lvl, model):
+ import torch
+ NGPU = torch.cuda.device_count()
+ SCRIPT = osp.join(osp.dirname(__file__), '../run.py')
+ logger = get_logger('Run Missing')
+
+ def get_env(name):
+ assert name in ['433', '437', '440', 'latest']
+ load_env()
+ env_key = f'ENV_{name}'
+ return os.environ.get(env_key, None)
+
+ missing = MISSING(lvl)
+ if model == 'all':
+ pass
+ elif model == 'api':
+ missing = [x for x in missing if x[0] in models['api']]
+ elif model == 'hf':
+ missing = [x for x in missing if x[0] not in models['api']]
+ elif model in models:
+ missing = [x for x in missing if x[0] in models[missing]]
+ elif model in supported_VLM:
+ missing = [x for x in missing if x[0] == model]
+ else:
+ warnings.warn(f'Invalid model {model}.')
+
+ missing.sort(key=lambda x: x[0])
+ groups = defaultdict(list)
+ for m, D in missing:
+ groups[m].append(D)
+ for m in groups:
+ if m in SKIP_MODELS:
+ continue
+ for dataset in groups[m]:
+ logger.info(f'Running {m} on {dataset}')
+ exe = 'python' if m in LARGE_MODELS or m in models['api'] else 'torchrun'
+ if m not in models['api']:
+ env = None
+ env = 'latest' if m in models['latest'] else env
+ env = '433' if m in models['4.33.0'] else env
+ env = '437' if m in models['4.37.0'] else env
+ env = '440' if m in models['4.40.0'] else env
+ if env is None:
+ # Not found, default to latest
+ env = 'latest'
+ logger.warning(
+ f"Model {m} does not have a specific environment configuration. Defaulting to 'latest'.")
+ pth = get_env(env)
+ if pth is not None:
+ exe = osp.join(pth, 'bin', exe)
+ else:
+ logger.warning(f'Cannot find the env path {env} for model {m}')
+ if exe.endswith('torchrun'):
+ cmd = f'{exe} --nproc-per-node={NGPU} {SCRIPT} --model {m} --data {dataset}'
+ elif exe.endswith('python'):
+ cmd = f'{exe} {SCRIPT} --model {m} --data {dataset}'
+ os.system(cmd)
+
+
+def EVAL(dataset_name, data_file, **kwargs):
+ from vlmeval.dataset import build_dataset
+ logger = get_logger('VLMEvalKit Tool-Eval')
+ dataset = build_dataset(dataset_name)
+ # Set the judge kwargs first before evaluation or dumping
+ judge_kwargs = {'nproc': 4, 'verbose': True}
+ if 'model' not in kwargs:
+ if dataset.TYPE in ['MCQ', 'Y/N', 'MCQ_MMMU_Pro']:
+ judge_kwargs['model'] = 'chatgpt-0125'
+ elif listinstr(['MMVet', 'LLaVABench', 'MMBench-Video'], dataset_name):
+ judge_kwargs['model'] = 'gpt-4-turbo'
+ elif listinstr(['MMLongBench', 'MMDU'], dataset_name):
+ judge_kwargs['model'] = 'gpt-4o'
+ elif listinstr(['DynaMath', 'MathVerse', 'MathVista', 'MathVision'], dataset_name):
+ judge_kwargs['model'] = 'gpt-4o-mini'
+ else:
+ judge_kwargs['model'] = kwargs['model']
+ judge_kwargs['nproc'] = kwargs.get('nproc', 4)
+ eval_results = dataset.evaluate(data_file, **judge_kwargs)
+ if eval_results is not None:
+ assert isinstance(eval_results, dict) or isinstance(eval_results, pd.DataFrame)
+ logger.info('Evaluation Results:')
+ if isinstance(eval_results, dict):
+ logger.info('\n' + json.dumps(eval_results, indent=4))
+ elif isinstance(eval_results, pd.DataFrame):
+ logger.info('\n')
+ logger.info(tabulate(eval_results.T) if len(eval_results) < len(eval_results.columns) else eval_results)
+ return eval_results
+
+
+def parse_args_eval():
+ parser = argparse.ArgumentParser()
+ # Essential Args, Setting the Names of Datasets and Models
+ parser.add_argument('cmd', type=str)
+ parser.add_argument('data_file', type=str)
+ parser.add_argument('--judge', type=str, default=None)
+ parser.add_argument('--api-nproc', type=int, default=4)
+ parser.add_argument('--retry', type=int, default=None)
+ args = parser.parse_args()
+ return args
+
+
+def parse_args_scan():
+ parser = argparse.ArgumentParser()
+ parser.add_argument('--model', type=str, nargs='+')
+ parser.add_argument('--data', type=str, nargs='+')
+ parser.add_argument('--root', type=str, default=None)
+ args, unknownargs = parser.parse_known_args()
+ return args, unknownargs
+
+
+def parse_args_sync():
+ parser = argparse.ArgumentParser()
+ parser.add_argument('--src', type=str, default='/home/kenny/mmeval')
+ parser.add_argument('--tgt', type=str, default='/home/kenny/volc/mmeval')
+ parser.add_argument('--data', type=str, nargs='+')
+ args, unknownargs = parser.parse_known_args()
+ return args, unknownargs
+
+
+def MERGE_PKL(pkl_dir, world_size=1):
+ prefs = []
+ for ws in list(range(1, 9)):
+ prefs.extend([f'{i}{ws}_' for i in range(ws)])
+ prefs = set(prefs)
+ files = os.listdir(pkl_dir)
+ files = [x for x in files if x[:3] in prefs]
+ # Merge the files
+ res_all = defaultdict(dict)
+ for f in files:
+ full_path = osp.join(pkl_dir, f)
+ key = f[3:]
+ res_all[key].update(load(full_path))
+ os.remove(full_path)
+
+ dump_prefs = [f'{i}{world_size}_' for i in range(world_size)]
+ for k in res_all:
+ for pf in dump_prefs:
+ dump(res_all[k], f'{pkl_dir}/{pf}{k}')
+ print(f'Merged {len(res_all[k])} records into {pkl_dir}/{dump_prefs[0]}{k}')
+
+
+def SCAN_ONE(root, model, dataset):
+ from termcolor import colored
+ FAIL_MSG = 'Failed to obtain answer via API.'
+ root = osp.join(root, model)
+ fname = f'{model}_{dataset}.xlsx'
+ pth = osp.join(root, fname)
+ if osp.exists(pth):
+ data = load(pth)
+ # Detect Failure
+ assert 'prediction' in data
+ data['prediction'] = [str(x) for x in data['prediction']]
+ fail = [FAIL_MSG in x for x in data['prediction']]
+ if sum(fail):
+ nfail = sum(fail)
+ ntot = len(fail)
+ print(colored(f'Model {model} x Dataset {dataset} Inference: {nfail} out of {ntot} failed. {nfail / ntot * 100: .2f}%. ', 'light_red'))
+
+ eval_files = ls(root, match=f'{model}_{dataset}_')
+ eval_files = [x for x in eval_files if listinstr([f'{dataset}_openai', f'{dataset}_gpt'], x) and x.endswith('.xlsx')]
+
+ if len(eval_files) == 0:
+ return
+
+ for eval_file in eval_files:
+ data = load(eval_file)
+
+ if 'MMVet' in dataset:
+ bad = [x for x in data['log'] if 'All 5 retries failed.' in str(x)]
+ if len(bad):
+ print(f'Evaluation ({eval_file}): {len(bad)} out of {len(data)} failed.')
+ elif 'MathVista' in dataset:
+ bad = [x for x in data['res'] if FAIL_MSG in str(x)]
+ if len(bad):
+ print(f'Evaluation ({eval_file}): {len(bad)} out of {len(data)} failed.')
+ elif dataset == 'LLaVABench':
+ sub = data[data['gpt4_score'] == -1]
+ sub = sub[sub['gpt4_score'] == -1]
+ if len(sub):
+ print(f'Evaluation ({eval_file}): {len(sub)} out of {len(data)} failed.')
+ else:
+ if 'log' in data:
+ bad = [x for x in data['log'] if FAIL_MSG in str(x)]
+ if len(bad):
+ print(f'Evaluation ({eval_file}): {len(bad)} out of {len(data)} failed.')
+ else:
+ print(colored(f'Model {model} x Dataset {dataset} Inference Result Missing! ', 'red'))
+
+
+def SCAN(root, models, datasets):
+ for m in models:
+ if not osp.exists(osp.join(root, m)):
+ warnings.warn(f'Model {m} not found in {root}')
+ continue
+ cur_datasets = []
+ if len(datasets) == 0:
+ for d in SUPPORTED_DATASETS:
+ if osp.exists(osp.join(root, m, f'{m}_{d}.xlsx')):
+ cur_datasets.append(d)
+ else:
+ cur_datasets = datasets
+ for d in cur_datasets:
+ SCAN_ONE(root, m, d)
+
+
+def cli():
+ logger = get_logger('VLMEvalKit Tools')
+ args = sys.argv[1:]
+ if not args: # no arguments passed
+ logger.info(CLI_HELP_MSG)
+ return
+
+ if args[0].lower() == 'dlist':
+ assert len(args) >= 2
+ lst = DLIST(args[1])
+ print(' '.join(lst))
+ elif args[0].lower() == 'mlist':
+ assert len(args) >= 2
+ size = 'all'
+ if len(args) > 2:
+ size = args[2].lower()
+ lst = MLIST(args[1], size)
+ print('\n'.join(lst))
+ elif args[0].lower() == 'missing':
+ assert len(args) >= 2
+ missing_list = MISSING(args[1])
+ logger = get_logger('Find Missing')
+ logger.info(colored(f'Level {args[1]} Missing Results: ', 'red'))
+ lines = []
+ for m, D in missing_list:
+ line = f'Model {m}, Dataset {D}'
+ logger.info(colored(line, 'red'))
+ lines.append(line)
+ mwlines(lines, f'{args[1]}_missing.txt')
+ elif args[0].lower() == 'circular':
+ assert len(args) >= 2
+ CIRCULAR(args[1])
+ elif args[0].lower() == 'localize':
+ assert len(args) >= 2
+ LOCALIZE(args[1])
+ elif args[0].lower() == 'check':
+ assert len(args) >= 2
+ model_list = args[1:]
+ for m in model_list:
+ CHECK(m)
+ elif args[0].lower() == 'run':
+ assert len(args) >= 2
+ lvl = args[1]
+ if len(args) == 2:
+ model = 'all'
+ RUN(lvl, model)
+ else:
+ for model in args[2:]:
+ RUN(lvl, model)
+ elif args[0].lower() == 'eval':
+ args = parse_args_eval()
+ data_file = args.data_file
+
+ def extract_dataset(file_name):
+ fname = osp.splitext(file_name)[0].split('/')[-1]
+ parts = fname.split('_')
+ for i in range(len(parts)):
+ if '_'.join(parts[i:]) in SUPPORTED_DATASETS:
+ return '_'.join(parts[i:])
+ return None
+
+ dataset = extract_dataset(data_file)
+ assert dataset is not None, f'Cannot infer dataset name from {data_file}'
+ kwargs = {'nproc': args.api_nproc}
+ if args.judge is not None:
+ kwargs['model'] = args.judge
+ if args.retry is not None:
+ kwargs['retry'] = args.retry
+ EVAL(dataset_name=dataset, data_file=data_file, **kwargs)
+ elif args[0].lower() == 'merge_pkl':
+ assert len(args) == 3
+ args[2] = int(args[2])
+ assert args[2] in [1, 2, 4, 8]
+ MERGE_PKL(args[1], args[2])
+ elif args[0].lower() == 'scan':
+ args, unknownargs = parse_args_scan()
+ # The default value is only for the maintainer usage
+ root = args.root if args.root is not None else osp.join(osp.expanduser('~'), 'mmeval')
+ models = []
+ for m in args.model:
+ if osp.exists(m) and m.endswith('.txt'):
+ lines = mrlines(m)
+ models.extend([x.split()[0] for x in lines if len(x.split()) >= 1])
+ else:
+ models.append(m)
+ assert len(models)
+ datasets = args.data
+ SCAN(root, models, datasets if datasets is not None else [])
+ else:
+ logger.error('WARNING: command error!')
+ logger.info(CLI_HELP_MSG)
+ return
diff --git a/vlmeval/utils/__init__.py b/vlmeval/utils/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..cab50b6d5322433d8c109ea297ac7f2abc97f0f2
--- /dev/null
+++ b/vlmeval/utils/__init__.py
@@ -0,0 +1,7 @@
+from .matching_util import can_infer, can_infer_option, can_infer_text
+from .mp_util import track_progress_rich
+
+
+__all__ = [
+ 'can_infer', 'can_infer_option', 'can_infer_text', 'track_progress_rich',
+]
diff --git a/vlmeval/utils/matching_util.py b/vlmeval/utils/matching_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..ccdf1b7d563125a4763724b81cf0164b06b94185
--- /dev/null
+++ b/vlmeval/utils/matching_util.py
@@ -0,0 +1,69 @@
+import string
+import copy as cp
+import os
+from ..smp import *
+
+
+def can_infer_option(answer, choices):
+ verbose = os.environ.get('VERBOSE', 0)
+ # Choices is a dictionary
+ if 'Failed to obtain answer via API' in answer:
+ return False
+
+ reject_to_answer = [
+ "Sorry, I can't help with images of people yet.",
+ "I can't process this file.",
+ "I'm sorry, but without the image provided",
+ 'Cannot determine the answer'
+ ]
+ for err in reject_to_answer:
+ if err in answer:
+ return 'Z'
+
+ def count_choice(splits, choices, prefix='', suffix=''):
+ cnt = 0
+ for c in choices:
+ if prefix + c + suffix in splits:
+ cnt += 1
+ return cnt
+
+ answer_mod = cp.copy(answer)
+ chars = '.()[],:;!*#{}'
+ for c in chars:
+ answer_mod = answer_mod.replace(c, ' ')
+
+ splits = [x.strip() for x in answer_mod.split()]
+ count = count_choice(splits, choices)
+
+ if count == 1:
+ for ch in choices:
+ if 'A' in splits and len(splits) > 3 and verbose:
+ logger = get_logger('Evaluation')
+ logger.info(f'A might be a quantifier in the string: {answer}.')
+ return False
+ if ch in splits:
+ return ch
+ elif count == 0 and count_choice(splits, {'Z', ''}) == 1:
+ return 'Z'
+ return False
+
+
+def can_infer_text(answer, choices):
+ answer = answer.lower()
+ assert isinstance(choices, dict)
+ for k in choices:
+ assert k in string.ascii_uppercase
+ choices[k] = str(choices[k]).lower()
+ cands = []
+ for k in choices:
+ if choices[k] in answer:
+ cands.append(k)
+ if len(cands) == 1:
+ return cands[0]
+ return False
+
+
+def can_infer(answer, choices):
+ answer = str(answer)
+ copt = can_infer_option(answer, choices)
+ return copt if copt else can_infer_text(answer, choices)
diff --git a/vlmeval/utils/mp_util.py b/vlmeval/utils/mp_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..27e31ebe425b57c0edb2093f84dd7ae1573e52a5
--- /dev/null
+++ b/vlmeval/utils/mp_util.py
@@ -0,0 +1,72 @@
+from multiprocessing import Pool
+import os
+from typing import Callable, Iterable, Sized
+
+from rich.progress import (BarColumn, MofNCompleteColumn, Progress, Task,
+ TaskProgressColumn, TextColumn, TimeRemainingColumn)
+from rich.text import Text
+import os.path as osp
+import time
+import portalocker
+from ..smp import load, dump
+
+
+def track_progress_rich(
+ func: Callable,
+ tasks: Iterable = tuple(),
+ nproc: int = 1,
+ save=None,
+ keys=None,
+ **kwargs) -> list:
+
+ from concurrent.futures import ThreadPoolExecutor
+ from tqdm import tqdm
+ if save is not None:
+ assert osp.exists(osp.dirname(save)) or osp.dirname(save) == ''
+ if not osp.exists(save):
+ dump({}, save)
+ if keys is not None:
+ assert len(keys) == len(tasks)
+ if not callable(func):
+ raise TypeError('func must be a callable object')
+ if not isinstance(tasks, Iterable):
+ raise TypeError(
+ f'tasks must be an iterable object, but got {type(tasks)}')
+ assert nproc > 0, 'nproc must be a positive number'
+ res = load(save) if save is not None else {}
+ results = [None for _ in range(len(tasks))]
+
+ with ThreadPoolExecutor(max_workers=nproc) as executor:
+ futures = []
+
+ for inputs in tasks:
+ if not isinstance(inputs, (tuple, list, dict)):
+ inputs = (inputs, )
+ if isinstance(inputs, dict):
+ future = executor.submit(func, **inputs)
+ else:
+ future = executor.submit(func, *inputs)
+ futures.append(future)
+
+ unfinished = set(range(len(tasks)))
+ pbar = tqdm(total=len(unfinished))
+ while len(unfinished):
+ new_finished = set()
+ for idx in unfinished:
+ if futures[idx].done():
+ results[idx] = futures[idx].result()
+ new_finished.add(idx)
+ if keys is not None:
+ res[keys[idx]] = results[idx]
+ if len(new_finished):
+ if save is not None:
+ dump(res, save)
+ pbar.update(len(new_finished))
+ for k in new_finished:
+ unfinished.remove(k)
+ time.sleep(0.1)
+ pbar.close()
+
+ if save is not None:
+ dump(res, save)
+ return results
diff --git a/vlmeval/utils/result_transfer.py b/vlmeval/utils/result_transfer.py
new file mode 100644
index 0000000000000000000000000000000000000000..649426b87f40cfd67c9308e5c5f4de2f9906660c
--- /dev/null
+++ b/vlmeval/utils/result_transfer.py
@@ -0,0 +1,97 @@
+from ..smp import *
+from ..dataset.utils.judge_util import build_judge
+from ..dataset.utils.multiple_choice import extract_answer_from_item
+from .matching_util import can_infer
+from .mp_util import track_progress_rich
+
+
+def MMMU_result_transfer(result_path):
+ res = {}
+ result_data = load(result_path)
+ mcq = result_data['A'].notna()
+ lt = len(result_data)
+ for i in range(lt):
+ line = result_data.iloc[i]
+ if mcq[i]:
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ prediction = line['prediction']
+ infer_prediction = can_infer(prediction, options)
+ res[line['id']] = infer_prediction
+ else:
+ res[line['id']] = line['prediction']
+ result_json = result_path.replace('.xlsx', '.json')
+ dump(res, result_json)
+ return result_json
+
+
+def MMTBench_result_transfer(eval_file, dataset='default', **judge_kwargs):
+ logger = get_logger('Evaluation')
+ nproc = judge_kwargs.pop('nproc', 4)
+
+ rd.seed(2680)
+ suffix = eval_file.split('.')[-1]
+ model = judge_kwargs['model']
+ assert model in ['chatgpt-0125', 'exact_matching', 'gpt-4-0125']
+ name_str_map = {
+ 'chatgpt-0125': 'openai',
+ 'gpt-4-0125': 'gpt4'
+ }
+ name_str = name_str_map[model] if model in name_str_map else model
+
+ if model == 'exact_matching':
+ model = None
+ elif gpt_key_set():
+ model = build_judge(**judge_kwargs)
+ if not model.working():
+ logger.error('The OPENAI API is not working properly, will use exact matching for evaluation')
+ model = None
+ else:
+ logger.error('OPENAI_API_KEY is not set properly, will use exact matching for evaluation')
+ model = None
+
+ logger.info(f'Evaluating {eval_file}')
+ result_file = eval_file.replace(f'.{suffix}', f'_{name_str}_option.pkl')
+ result = {}
+ if osp.exists(result_file):
+ result = load(result_file)
+
+ data = load(eval_file)
+ assert 'index' in data, 'Essentail columns missing in the eval_file.'
+
+ data = data.sort_values(by='index')
+ data['prediction'] = [str(x) for x in data['prediction']]
+ for k in data.keys():
+ data[k.lower() if k not in list(string.ascii_uppercase) else k] = data.pop(k)
+
+ idx2lines = {data.iloc[i]['index']: data.iloc[i] for i in range(len(data))}
+ idx2lines = {k: v for k, v in idx2lines.items() if k not in result}
+
+ indices = list(idx2lines.keys())
+ lines = [idx2lines[i] for i in indices]
+ tups = [(model, line) for line in lines]
+ res = track_progress_rich(
+ extract_answer_from_item,
+ tups,
+ nproc=nproc,
+ chunksize=nproc,
+ save=result_file,
+ keys=indices)
+
+ for i, r in zip(indices, res):
+ if i in result:
+ assert result[i]['opt'] == r['opt'] and result[i]['log'] == r['log']
+ else:
+ result[i] = r
+
+ indices = list(data['index'])
+ data['opt'] = [result[i]['opt'] for i in data['index']]
+ data['log'] = [result[i]['log'] for i in data['index']]
+
+ # load split
+ output_path = eval_file.replace(f'.{suffix}', f'_{name_str}_submission.tsv')
+ dump(data, eval_file.replace(f'.{suffix}', f'_{name_str}_submission.tsv'))
+ return output_path
diff --git a/vlmeval/vlm/__init__.py b/vlmeval/vlm/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4e53c24a7244c5dadab1fcaf71d384dfca75a27e
--- /dev/null
+++ b/vlmeval/vlm/__init__.py
@@ -0,0 +1,93 @@
+import torch
+
+torch.set_grad_enabled(False)
+torch.manual_seed(1234)
+from .aria import Aria
+from .base import BaseModel
+from .cogvlm import CogVlm, GLM4v
+from .emu import Emu, Emu3_chat, Emu3_gen
+from .eagle_x import Eagle
+from .idefics import IDEFICS, IDEFICS2
+from .instructblip import InstructBLIP
+from .kosmos import Kosmos2
+from .llava import (
+ LLaVA,
+ LLaVA_Next,
+ LLaVA_XTuner,
+ LLaVA_Next2,
+ LLaVA_OneVision,
+ LLaVA_OneVision_HF,
+)
+from .vita import VITA, VITAQwen2
+from .long_vita import LongVITA
+from .minicpm_v import MiniCPM_V, MiniCPM_Llama3_V, MiniCPM_V_2_6, MiniCPM_o_2_6
+from .minigpt4 import MiniGPT4
+from .mmalaya import MMAlaya, MMAlaya2
+from .monkey import Monkey, MonkeyChat
+from .moondream import Moondream1, Moondream2
+from .minimonkey import MiniMonkey
+from .mplug_owl2 import mPLUG_Owl2
+from .omnilmm import OmniLMM12B
+from .open_flamingo import OpenFlamingo
+from .pandagpt import PandaGPT
+from .qwen_vl import QwenVL, QwenVLChat
+from .qwen2_vl import Qwen2VLChat
+from .transcore_m import TransCoreM
+from .visualglm import VisualGLM
+from .xcomposer import (
+ ShareCaptioner,
+ XComposer,
+ XComposer2,
+ XComposer2_4KHD,
+ XComposer2d5,
+)
+from .yi_vl import Yi_VL
+from .internvl import InternVLChat
+from .deepseek_vl import DeepSeekVL
+from .deepseek_vl2 import DeepSeekVL2
+from .janus import Janus
+from .mgm import Mini_Gemini
+from .bunnyllama3 import BunnyLLama3
+from .vxverse import VXVERSE
+from .gemma import PaliGemma, Gemma3
+from .qh_360vl import QH_360VL
+from .phi3_vision import Phi3Vision, Phi3_5Vision
+from .phi4_multimodal import Phi4Multimodal
+from .wemm import WeMM
+from .cambrian import Cambrian
+from .chameleon import Chameleon
+from .video_llm import (
+ VideoLLaVA,
+ VideoLLaVA_HF,
+ Chatunivi,
+ VideoChatGPT,
+ LLaMAVID,
+ VideoChat2_HD,
+ PLLaVA,
+)
+from .vila import VILA
+from .ovis import Ovis, Ovis1_6, Ovis1_6_Plus, Ovis2
+from .mantis import Mantis
+from .mixsense import LLama3Mixsense
+from .parrot import Parrot
+from .omchat import OmChat
+from .rbdash import RBDash
+from .xgen_mm import XGenMM
+from .slime import SliME
+from .mplug_owl3 import mPLUG_Owl3
+from .pixtral import Pixtral
+from .llama_vision import llama_vision
+from .molmo import molmo
+from .points import POINTS, POINTSV15
+from .nvlm import NVLM
+from .vintern_chat import VinternChat
+from .h2ovl_mississippi import H2OVLChat
+from .falcon_vlm import Falcon2VLM
+from .smolvlm import SmolVLM, SmolVLM2
+from .sail_vl import SailVL
+from .valley import ValleyEagleChat
+from .ross import Ross
+from .ola import Ola
+from .ursa import UrsaChat
+from .vlm_r1 import VLMR1Chat
+from .aki import AKI
diff --git a/vlmeval/vlm/aki.py b/vlmeval/vlm/aki.py
new file mode 100644
index 0000000000000000000000000000000000000000..dabf921a22ae98be24b0d4555043ed65771e815b
--- /dev/null
+++ b/vlmeval/vlm/aki.py
@@ -0,0 +1,104 @@
+import torch
+from PIL import Image
+import warnings
+from .base import BaseModel
+from ..smp import splitlen, get_cache_path
+from transformers import AutoTokenizer, AutoConfig
+from torchvision.transforms import Compose, Resize, Lambda, ToTensor, Normalize
+try:
+ from torchvision.transforms import InterpolationMode
+ BICUBIC = InterpolationMode.BICUBIC
+except ImportError:
+ BICUBIC = Image.BICUBIC
+
+
+class AKI(BaseModel):
+ INSTALL_REQ = True
+ INTERLEAVE = False
+
+ def __init__(self,
+ name,
+ ckpt_pth=None,
+ **kwargs):
+
+ self.name = name
+ try:
+ from open_flamingo.src.modeling_aki import AKI
+ except:
+ raise ImportError('Please first install AKIVLM from https://github.com/sony/aki')
+
+ # replace GenerationMixin to modify attention mask handling
+ from transformers.generation.utils import GenerationMixin
+ from open_flamingo import _aki_update_model_kwargs_for_generation
+ GenerationMixin._update_model_kwargs_for_generation = _aki_update_model_kwargs_for_generation
+
+ config = AutoConfig.from_pretrained(ckpt_pth)
+ tokenizer = AutoTokenizer.from_pretrained(ckpt_pth)
+ model = AKI.from_pretrained(ckpt_pth, tokenizer=tokenizer)
+
+ n_px = getattr(config, "n_px", 384)
+ norm_mean = getattr(config, "norm_mean", 0.5)
+ norm_std = getattr(config, "norm_std", 0.5)
+
+ image_processor = Compose([
+ Resize((n_px, n_px), interpolation=InterpolationMode.BICUBIC, antialias=True),
+ Lambda(lambda x: x.convert('RGB')),
+ ToTensor(),
+ Normalize(mean=(norm_mean, norm_mean, norm_mean), std=(norm_std, norm_std, norm_std))
+ ])
+ self.model = model.eval().cuda()
+
+ tokenizer.padding_side = 'left'
+ tokenizer.add_eos_token = False
+ self.tokenizer = tokenizer
+ self.image_proc = image_processor
+
+ kwargs_default = {
+ 'max_new_tokens': 512,
+ 'temperature': 0.0,
+ 'do_sample': False,
+ 'eos_token_id': tokenizer.eos_token_id,
+ }
+ kwargs_default.update(kwargs)
+ self.kwargs = kwargs_default
+
+ def apply_prompt_template(self, query):
+ SYSTEM_BASE = "A chat between a curious user and an artificial intelligence assistant."
+ SYSTEM_DETAIL = "The assistant gives helpful, detailed, and polite answers to the user's questions."
+ SYSTEM_MESSAGE = SYSTEM_BASE + " " + SYSTEM_DETAIL
+ SYSTEM_MESSAGE_ROLE = '<|system|>' + '\n' + SYSTEM_MESSAGE + '<|end|>\n'
+
+ s = (
+ f'{SYSTEM_MESSAGE_ROLE}'
+ f'<|user|>\n{query}<|end|>\n<|assistant|>\n'
+ )
+ return s
+
+ def generate_inner(self, message, dataset=None):
+ vision_x, prompt = [], ''
+ for msg in message:
+ if msg['type'] == 'image':
+ img = Image.open(msg['value']).convert('RGB')
+
+ ## [NOTE]: only use the first image in this work if including multiple images in a sample
+ if len(vision_x) == 0:
+ vision_x.append(self.image_proc(img).unsqueeze(0))
+ prompt += ''
+ else:
+ warnings.warn('======Only the first image is used in the input.')
+ elif msg['type'] == 'text':
+ prompt += msg['value']
+ # prompt += f"\nAnswer the question using a single word or phrase. {msg['value']}" # for YorN
+
+ vision_x = torch.cat(vision_x, dim=0) if len(vision_x) > 1 else vision_x[0]
+ vision_x = vision_x.unsqueeze(1).unsqueeze(0)
+ prompt = self.apply_prompt_template(prompt)
+ lang_x = self.tokenizer([prompt], return_tensors='pt')
+
+ generated_text = self.model.generate(
+ vision_x=vision_x.cuda(),
+ lang_x=lang_x['input_ids'].cuda(),
+ attention_mask=lang_x['attention_mask'].cuda(),
+ **self.kwargs)
+ generated_text = self.tokenizer.decode(generated_text[0], skip_special_tokens=True)
+ return generated_text
diff --git a/vlmeval/vlm/aria.py b/vlmeval/vlm/aria.py
new file mode 100644
index 0000000000000000000000000000000000000000..c2d9c52e36c2627cf0cabd0e80b17fb5df25c6eb
--- /dev/null
+++ b/vlmeval/vlm/aria.py
@@ -0,0 +1,206 @@
+import torch
+import warnings
+import copy as cp
+from PIL import Image
+import pandas as pd
+import string
+import re
+from .base import BaseModel
+from ..smp import isimg, listinstr, cn_string
+from ..dataset import DATASET_TYPE, DATASET_MODALITY
+
+
+class Aria(BaseModel):
+
+ INSTALL_REQ = False
+ INTERLEAVE = True
+
+ def __init__(self, model_path='rhymes-ai/Aria', **kwargs):
+ from transformers import AutoModelForCausalLM, AutoProcessor
+ assert model_path is not None
+ self.model_path = model_path
+ processor = AutoProcessor.from_pretrained(model_path, trust_remote_code=True)
+ tokenizer = processor.tokenizer
+ tokenizer.padding_side = 'left'
+ tokenizer.pad_token_id = tokenizer.unk_token_id
+ self.processor = processor
+ self.tokenizer = tokenizer
+ self.model = AutoModelForCausalLM.from_pretrained(
+ model_path,
+ device_map='cuda',
+ torch_dtype=torch.bfloat16,
+ trust_remote_code=True
+ ).eval()
+ default_kwargs = dict(
+ do_sample=False,
+ num_beams=1,
+ max_new_tokens=512,
+ min_new_tokens=1,
+ num_return_sequences=1,
+ use_cache=True,
+ output_hidden_states=True,
+ pad_token_id=tokenizer.unk_token_id,
+ stop_strings=["<|im_end|>"],
+ tokenizer=processor.tokenizer,
+ )
+ default_kwargs.update(kwargs)
+ self.kwargs = default_kwargs
+ warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ')
+ torch.cuda.empty_cache()
+
+ def use_custom_prompt(self, dataset):
+ assert dataset is not None
+ if listinstr(['MMDU', 'MME-RealWorld', 'MME-RealWorld-CN'], dataset):
+ # For Multi-Turn we don't have custom prompt
+ return False
+ if DATASET_MODALITY(dataset) == 'VIDEO':
+ # For Video benchmarks we don't have custom prompt at here
+ return False
+ else:
+ return True
+
+ def build_prompt(self, line, dataset=None):
+ assert self.use_custom_prompt(dataset)
+ assert dataset is None or isinstance(dataset, str)
+ tgt_path = self.dump_image(line, dataset)
+
+ question = line['question']
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ if hint is not None:
+ question = hint + '\n' + question
+
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ for key, item in options.items():
+ question += f'\n{key}. {item}'
+ prompt = question
+
+ if len(options):
+ prompt += (
+ "\nAnswer with the option's letter from the given choices directly."
+ )
+ else:
+ if listinstr(['MathVista', 'MathVision', 'VCR', 'MTVQA', 'MMVet', 'MathVerse'], dataset):
+ prompt = prompt
+ elif listinstr(['LLaVABench', 'MMBench-Video'], dataset):
+ prompt += '\nAnswer this question in detail.'
+ elif listinstr(['DocVQA'], dataset):
+ prompt += '\nAnswer briefly and directly.'
+ else:
+ prompt += '\nAnswer the question using a single word or phrase.'
+
+ message = [dict(type='image', value=s) for s in tgt_path]
+ message.append(dict(type='text', value=prompt))
+ return message
+
+ def build_video_prompt(self, prompt, dataset=None):
+ if listinstr(['MMBench-Video'], dataset):
+ prompt = prompt.replace('\nAnswer:', '')
+ prompt = prompt.replace(
+ 'Question: ',
+ 'Please carefully check the video and then answer the following question with details:'
+ )
+ elif listinstr(['Video-MME'], dataset):
+ prompt = prompt.replace('\nAnswer:', '')
+ prompt += "\nAnswer with the option's letter from the given choices directly."
+ elif listinstr(['MVBench'], dataset):
+ prompt = prompt.replace('Best option:(', '')
+ system_prompt = 'Carefully watch the video and pay attention to the cause and sequence of events, the detail and movement of objects, and the action and pose of persons. Based on your observations, select the best option that accurately addresses the question.\n' # noqa: E501
+ prompt = prompt.replace(system_prompt, '')
+
+ return prompt
+
+ def adjust_kwargs(self, dataset):
+ kwargs = cp.deepcopy(self.kwargs)
+ kwargs["temperature"] = 0.0
+ kwargs["do_sample"] = False
+
+ if DATASET_MODALITY(dataset) == "VIDEO":
+ kwargs["max_image_size"] = 490
+ else:
+ kwargs["max_image_size"] = 980
+
+ kwargs["split_image"] = False
+
+ if listinstr(['MMMU', 'MMStar', 'Math'], dataset):
+ # These datasets may lead the model to work as a CoT-alike behaviour.
+ # Allow to output longer.
+ kwargs['max_new_tokens'] = 512
+ return kwargs
+ if DATASET_TYPE(dataset) in ['MCQ', 'Y/N']:
+ kwargs['max_new_tokens'] = 64
+ elif DATASET_TYPE(dataset) == 'Caption' and 'COCO' in dataset:
+ kwargs['max_new_tokens'] = 64
+ elif DATASET_TYPE(dataset) == 'VQA':
+ if listinstr(['OCRVQA', 'ChartQA', 'DocVQA'], dataset):
+ kwargs['max_new_tokens'] = 128
+ elif listinstr(['TextVQA'], dataset):
+ kwargs['max_new_tokens'] = 32
+
+ if listinstr(['OCR', 'ChartQA', 'DocVQA', 'InfoVQA', 'TextVQA'], dataset):
+ # OCR-related datasets that need to split image
+ kwargs["split_image"] = True
+
+ return kwargs
+
+ def generate_inner(self, message, dataset=None):
+ if dataset is not None:
+ kwargs = self.adjust_kwargs(dataset)
+ else:
+ kwargs = self.kwargs
+
+ max_image_size = kwargs.pop("max_image_size")
+ split_image = kwargs.pop("split_image")
+
+ prompt = '<|im_start|>user\n'
+ images = []
+ last_message_modality = "text"
+
+ if listinstr(['MLVU', 'TempCompass', 'MVBench'], dataset): # re-arrange the data
+ new_message = []
+ for s in message:
+ if s['type'] == 'image':
+ new_message.append(s)
+ for s in message:
+ if s['type'] == 'text':
+ new_message.append(s)
+ message = new_message
+
+ for s in message:
+ if s['type'] == 'image':
+ prompt += '<|img|>'
+ images.append(s['value'])
+ last_message_modality = "image"
+ elif s['type'] == 'text':
+ text = re.sub(r"", "", s["value"])
+ if last_message_modality == "image":
+ prompt += "\n"
+ last_message_modality = "text"
+ prompt += text
+
+ if DATASET_MODALITY(dataset) == 'VIDEO':
+ prompt = self.build_video_prompt(prompt, dataset)
+
+ prompt += '<|im_end|>\n<|im_start|>assistant\n'
+ if images:
+ images = [Image.open(s).convert('RGB') for s in images]
+ encoded = self.processor(
+ text=prompt,
+ images=images,
+ return_tensors='pt',
+ padding='longest',
+ max_image_size=max_image_size,
+ split_image=split_image,
+ )
+ else:
+ encoded = self.processor(text=prompt, return_tensors='pt', padding='longest')
+ encoded["pixel_values"] = encoded["pixel_values"].to(self.model.dtype)
+ encoded = {k: v.to(self.model.device) for k, v in encoded.items()}
+
+ pred = self.model.generate(**encoded, **kwargs)
+ answer = self.tokenizer.decode(pred[0][encoded['input_ids'].size(1):].cpu(), skip_special_tokens=True).strip()
+ answer = answer.replace('<|im_end|>', '')
+ return answer
diff --git a/vlmeval/vlm/base.py b/vlmeval/vlm/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..655296a44793242cef1ebd2e3dc7539319e49e9d
--- /dev/null
+++ b/vlmeval/vlm/base.py
@@ -0,0 +1,198 @@
+from ..smp import *
+from ..dataset import img_root_map, DATASET_TYPE
+from abc import abstractmethod
+
+
+class BaseModel:
+
+ INTERLEAVE = False
+ allowed_types = ['text', 'image', 'video']
+
+ def __init__(self):
+ self.dump_image_func = None
+
+ def use_custom_prompt(self, dataset):
+ """Whether to use custom prompt for the given dataset.
+
+ Args:
+ dataset (str): The name of the dataset.
+
+ Returns:
+ bool: Whether to use custom prompt. If True, will call `build_prompt` of the VLM to build the prompt.
+ Default to False.
+ """
+ return False
+
+ @abstractmethod
+ def build_prompt(self, line, dataset):
+ """Build custom prompts for a specific dataset. Called only if `use_custom_prompt` returns True.
+
+ Args:
+ line (line of pd.DataFrame): The raw input line.
+ dataset (str): The name of the dataset.
+
+ Returns:
+ str: The built message.
+ """
+ raise NotImplementedError
+
+ def set_dump_image(self, dump_image_func):
+ self.dump_image_func = dump_image_func
+
+ def dump_image(self, line, dataset):
+ return self.dump_image_func(line)
+
+ @abstractmethod
+ def generate_inner(self, message, dataset=None):
+ raise NotImplementedError
+
+ def check_content(self, msgs):
+ """Check the content type of the input. Four types are allowed: str, dict, liststr, listdict.
+ """
+ if isinstance(msgs, str):
+ return 'str'
+ if isinstance(msgs, dict):
+ return 'dict'
+ if isinstance(msgs, list):
+ types = [self.check_content(m) for m in msgs]
+ if all(t == 'str' for t in types):
+ return 'liststr'
+ if all(t == 'dict' for t in types):
+ return 'listdict'
+ return 'unknown'
+
+ def preproc_content(self, inputs):
+ """Convert the raw input messages to a list of dicts.
+
+ Args:
+ inputs: raw input messages.
+
+ Returns:
+ list(dict): The preprocessed input messages. Will return None if failed to preprocess the input.
+ """
+ if self.check_content(inputs) == 'str':
+ return [dict(type='text', value=inputs)]
+ elif self.check_content(inputs) == 'dict':
+ assert 'type' in inputs and 'value' in inputs
+ return [inputs]
+ elif self.check_content(inputs) == 'liststr':
+ res = []
+ for s in inputs:
+ mime, pth = parse_file(s)
+ if mime is None or mime == 'unknown':
+ res.append(dict(type='text', value=s))
+ else:
+ res.append(dict(type=mime.split('/')[0], value=pth))
+ return res
+ elif self.check_content(inputs) == 'listdict':
+ for item in inputs:
+ assert 'type' in item and 'value' in item
+ mime, s = parse_file(item['value'])
+ if mime is None:
+ assert item['type'] == 'text'
+ else:
+ assert mime.split('/')[0] == item['type']
+ item['value'] = s
+ return inputs
+ else:
+ return None
+
+ def generate(self, message, dataset=None):
+ """Generate the output message.
+
+ Args:
+ message (list[dict]): The input message.
+ dataset (str, optional): The name of the dataset. Defaults to None.
+
+ Returns:
+ str: The generated message.
+ """
+ assert self.check_content(message) in ['str', 'dict', 'liststr', 'listdict'], f'Invalid input type: {message}'
+ message = self.preproc_content(message)
+ assert message is not None and self.check_content(message) == 'listdict'
+ for item in message:
+ assert item['type'] in self.allowed_types, f'Invalid input type: {item["type"]}'
+ return self.generate_inner(message, dataset)
+
+ def chat(self, messages, dataset=None):
+ """The main function for multi-turn chatting. Will call `chat_inner` with the preprocessed input messages."""
+ assert hasattr(self, 'chat_inner'), 'The API model should has the `chat_inner` method. '
+ for msg in messages:
+ assert isinstance(msg, dict) and 'role' in msg and 'content' in msg, msg
+ assert self.check_content(msg['content']) in ['str', 'dict', 'liststr', 'listdict'], msg
+ msg['content'] = self.preproc_content(msg['content'])
+
+ while len(messages):
+ try:
+ return self.chat_inner(messages, dataset=dataset)
+ except Exception as e:
+ logging.info(f'{type(e)}: {e}')
+ messages = messages[1:]
+ while len(messages) and messages[0]['role'] != 'user':
+ messages = messages[1:]
+ continue
+ return 'Chat Mode: Failed with all possible conversation turns.'
+
+ def message_to_promptimg(self, message, dataset=None):
+ assert not self.INTERLEAVE
+ model_name = self.__class__.__name__
+ warnings.warn(
+ f'Model {model_name} does not support interleaved input. '
+ 'Will use the first image and aggregated texts as prompt. ')
+ num_images = len([x for x in message if x['type'] == 'image'])
+ if num_images == 0:
+ prompt = '\n'.join([x['value'] for x in message if x['type'] == 'text'])
+ image = None
+ else:
+ prompt = '\n'.join([x['value'] for x in message if x['type'] == 'text'])
+ images = [x['value'] for x in message if x['type'] == 'image']
+ if 'BLINK' == dataset:
+ image = concat_images_vlmeval(images, target_size=512)
+ else:
+ image = images[0]
+ return prompt, image
+
+ def message_to_promptvideo(self, message):
+ if self.VIDEO_LLM:
+ num_videos = len([x for x in message if x['type'] == 'video'])
+ if num_videos == 0:
+ prompt = '\n'.join([x['value'] for x in message if x['type'] == 'text'])
+ video = None
+ else:
+ prompt = '\n'.join([x['value'] for x in message if x['type'] == 'text'])
+ video = [x['value'] for x in message if x['type'] == 'video'][0]
+ return prompt, video
+ else:
+ logging.critical('Model does not support video input.')
+ raise NotImplementedError
+
+ def message_to_promptvideo_withrole(self, message, dataset=None):
+ if self.VIDEO_LLM:
+ system, user, assistant, video_list = '', '', '', []
+ for msg in message:
+ if msg['type'] == 'text':
+ if 'role' in msg and msg['role'] == 'system':
+ system += msg['value']
+ elif 'role' in msg and msg['role'] == 'assistant':
+ assistant += msg['value']
+ else:
+ user += msg['value']
+ elif msg['type'] == 'video':
+ video_list.append(msg['value'])
+ question = {
+ 'system': system,
+ 'user': user,
+ 'assistant': assistant
+ }
+ if assistant == '':
+ if listinstr(['MCQ'], DATASET_TYPE(dataset)):
+ question['assistant'] = 'Best Option: ('
+ else:
+ del question['assistant']
+ if len(video_list) > 1:
+ print('VLMEvalKit only support single video as input, take first video as input')
+ video = video_list[0]
+ return question, video
+ else:
+ logging.critical('Model does not support video input.')
+ raise NotImplementedError
diff --git a/vlmeval/vlm/bunnyllama3.py b/vlmeval/vlm/bunnyllama3.py
new file mode 100644
index 0000000000000000000000000000000000000000..848e5b5919d6ca50c02580aa72a886931fc2ff49
--- /dev/null
+++ b/vlmeval/vlm/bunnyllama3.py
@@ -0,0 +1,133 @@
+import torch
+import transformers
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from PIL import Image
+import warnings
+import re
+
+from .base import BaseModel
+from ..smp import *
+from ..dataset import DATASET_TYPE
+
+
+class BunnyLLama3(BaseModel):
+ INSTALL_REQ = False
+ INTERLEAVE = False
+
+ def __init__(self, model_path='BAAI/Bunny-v1_1-Llama-3-8B-V', **kwargs):
+ assert model_path is not None
+ transformers.logging.set_verbosity_error()
+ transformers.logging.disable_progress_bar()
+ warnings.filterwarnings('ignore')
+ self.tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
+ self.model = AutoModelForCausalLM.from_pretrained(model_path, device_map='auto', trust_remote_code=True)
+ self.kwargs = kwargs
+
+ def use_custom_prompt(self, dataset):
+ if listinstr(['MCQ', 'Y/N'], DATASET_TYPE(dataset)) or listinstr(['mathvista'], dataset.lower()):
+ return True
+ else:
+ return False
+
+ def build_prompt(self, line, dataset):
+ if dataset is None:
+ dataset = self.dataset
+
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ tgt_path = self.dump_image(line, dataset)
+
+ prompt = line['question']
+
+ if DATASET_TYPE(dataset) == 'MCQ':
+ if listinstr(['mmmu'], dataset.lower()):
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ assert hint is None
+
+ question = line['question']
+ question = re.sub(r'', lambda x: x.group(0)[1:-1], question)
+
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ options_prompt = '\n'
+ for key, item in options.items():
+ options_prompt += f'({key}) {item}\n'
+
+ prompt = question
+ if len(options):
+ prompt += options_prompt
+ prompt += "\nAnswer with the option's letter from the given choices directly."
+ else:
+ prompt += '\nAnswer the question using a single word or phrase.'
+ else:
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ prompt = ''
+ if hint is not None:
+ prompt += f'{hint}\n'
+
+ question = line['question']
+
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ options_prompt = '\n'
+ for key, item in options.items():
+ options_prompt += f'{key}. {item}\n'
+
+ prompt += question + options_prompt
+ if listinstr(['cn', 'ccbench'], dataset.lower()):
+ prompt += '请直接回答选项字母。'
+ else:
+ prompt += "Answer with the option's letter from the given choices directly."
+ elif DATASET_TYPE(dataset) == 'Y/N':
+ if listinstr(['mme'], dataset.lower()):
+ if not listinstr(
+ ['code_reasoning', 'commonsense_reasoning', 'numerical_calculation', 'text_translation'],
+ line['category']):
+ prompt = prompt.replace(' Please answer yes or no.',
+ '\nAnswer the question using a single word or phrase.')
+ elif listinstr(['pope'], dataset.lower()):
+ prompt = prompt.replace(' Please answer yes or no.',
+ '\nAnswer the question using a single word or phrase.')
+ elif listinstr(['mathvista'], dataset.lower()):
+ match = re.search(r'Hint: (.*?)\nQuestion: (.*?)\n(Choices:\n(.*))?', prompt + '\n', re.DOTALL)
+
+ prompt = match.group(2)
+ if match.group(4) is not None:
+ prompt += '\n' + match.group(4).rstrip('\n')
+ prompt += '\n' + match.group(1)
+ else:
+ raise ValueError(
+ f"Bunny doesn't implement a custom prompt for {dataset}. It should use the default prompt, but didn't.")
+
+ msgs = []
+ if isinstance(tgt_path, list):
+ msgs.extend([dict(type='image', value=p) for p in tgt_path])
+ else:
+ msgs = [dict(type='image', value=tgt_path)]
+ msgs.append(dict(type='text', value=prompt))
+
+ return msgs
+
+ def generate_inner(self, message, dataset=None):
+
+ prompt, image_path = self.message_to_promptimg(message, dataset=dataset)
+
+ text = (f'A chat between a curious user and an artificial intelligence assistant. '
+ f"The assistant gives helpful, detailed, and polite answers to the user's questions. "
+ f'USER: \n{prompt} ASSISTANT:')
+
+ text_chunks = [self.tokenizer(chunk).input_ids for chunk in text.split('')]
+ input_ids = torch.tensor(text_chunks[0] + [-200] + text_chunks[1][1:], dtype=torch.long).unsqueeze(0)
+ image = Image.open(image_path).convert('RGB')
+ image_tensor = self.model.process_images([image], self.model.config).to(dtype=self.model.dtype)
+
+ output_ids = self.model.generate(input_ids, images=image_tensor, max_new_tokens=128, use_cache=True)[0]
+ response = self.tokenizer.decode(output_ids[input_ids.shape[1]:], skip_special_tokens=True)
+ return response
diff --git a/vlmeval/vlm/cambrian.py b/vlmeval/vlm/cambrian.py
new file mode 100644
index 0000000000000000000000000000000000000000..4fa57acb55ff263a43abf033c213382fc5c3f3d3
--- /dev/null
+++ b/vlmeval/vlm/cambrian.py
@@ -0,0 +1,84 @@
+import torch
+from PIL import Image
+from .base import BaseModel
+from ..smp import *
+import warnings
+
+IMAGE_TOKEN_INDEX = -200
+DEFAULT_IMAGE_TOKEN = ''
+DEFAULT_IM_START_TOKEN = ''
+DEFAULT_IM_END_TOKEN = ''
+
+
+class Cambrian(BaseModel):
+
+ INSTALL_REQ = True
+ INTERLEAVE = False
+
+ def __init__(self, model_path='nyu-visionx/cambrian-8b', **kwargs):
+ assert model_path is not None
+ try:
+ from cambrian.conversation import conv_templates, SeparatorStyle
+ from cambrian.model.builder import load_pretrained_model
+ from cambrian.mm_utils import tokenizer_image_token, process_images, get_model_name_from_path
+ except Exception as e:
+ logging.critical('Please install cambrian from https://github.com/cambrian-mllm/cambrian.')
+ raise e
+
+ model_name = get_model_name_from_path(model_path)
+ tokenizer, model, image_processor, context_len = load_pretrained_model(
+ model_path,
+ None,
+ model_name,
+ device_map=None
+ )
+
+ if '8b' in model_path:
+ self.conv_mode = 'llama_3'
+ elif '13b' in model_path:
+ self.conv_mode = 'vicuna_v1'
+ else:
+ self.conv_mode = 'chatml_direct'
+
+ self.model_config = model.config
+ self.conv_templates = conv_templates
+ self.tokenizer_image_token = tokenizer_image_token
+ self.process_images = process_images
+
+ self.tokenizer = tokenizer
+ self.image_processor = image_processor
+ self.model = model.to('cuda')
+
+ def process(self, image, question):
+ if self.model_config.mm_use_im_start_end:
+ question = DEFAULT_IM_START_TOKEN + DEFAULT_IMAGE_TOKEN + DEFAULT_IM_END_TOKEN + '\n' + question
+ else:
+ question = DEFAULT_IMAGE_TOKEN + '\n' + question
+ conv = self.conv_templates[self.conv_mode].copy()
+ conv.append_message(conv.roles[0], question)
+ conv.append_message(conv.roles[1], None)
+ prompt = conv.get_prompt()
+ image_size = [image.size]
+ image_tensor = self.process_images([image], self.image_processor, self.model_config)
+ input_ids = self.tokenizer_image_token(prompt, self.tokenizer, IMAGE_TOKEN_INDEX, return_tensors='pt')
+ input_ids = input_ids.unsqueeze(0).cuda()
+ return input_ids, image_tensor, image_size, prompt
+
+ def generate_inner(self, message, dataset=None):
+ prompt, image_path = self.message_to_promptimg(message, dataset=dataset)
+ image = Image.open(image_path).convert('RGB')
+ input_ids, image_tensor, image_sizes, prompt = self.process(image, prompt)
+ input_ids = input_ids.to(device='cuda', non_blocking=True)
+ with torch.inference_mode():
+ output_ids = self.model.generate(
+ input_ids,
+ images=image_tensor,
+ image_sizes=image_sizes,
+ do_sample=False,
+ temperature=0,
+ num_beams=1,
+ max_new_tokens=2048,
+ use_cache=True
+ )
+ outputs = self.tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0].strip()
+ return outputs
diff --git a/vlmeval/vlm/chameleon.py b/vlmeval/vlm/chameleon.py
new file mode 100644
index 0000000000000000000000000000000000000000..81f9740b6ea9345bf2fe7d49ed978d4e38e0b3f8
--- /dev/null
+++ b/vlmeval/vlm/chameleon.py
@@ -0,0 +1,49 @@
+import os.path as osp
+import warnings
+from .base import BaseModel
+from ..smp import *
+from PIL import Image
+import torch
+
+
+class Chameleon(BaseModel):
+
+ INSTALL_REQ = False
+ INTERLEAVE = True
+
+ def __init__(self, model_path='facebook/chameleon-7b', **kwargs):
+ try:
+ from transformers import ChameleonProcessor, ChameleonForConditionalGeneration
+ except Exception as e:
+ logging.critical('Please install the latest transformers.')
+ raise e
+
+ processor = ChameleonProcessor.from_pretrained(model_path)
+ model = ChameleonForConditionalGeneration.from_pretrained(model_path, torch_dtype=torch.bfloat16)
+
+ self.model = model.cuda().eval()
+ self.processor = processor
+
+ def generate_inner(self, message, dataset=None):
+ content, images = '', []
+ for x in message:
+ if x['type'] == 'text':
+ content += x['value']
+ elif x['type'] == 'image':
+ content += '\n'
+ images.append(Image.open(x['value']))
+
+ inputs = self.processor(
+ text=[content],
+ images=images,
+ padding=True,
+ return_tensors='pt'
+ ).to(device='cuda', dtype=torch.bfloat16)
+ generate_ids = self.model.generate(**inputs, max_new_tokens=2048)
+ input_token_len = inputs.input_ids.shape[1]
+ text = self.processor.batch_decode(
+ generate_ids[:, input_token_len:],
+ skip_special_tokens=True,
+ clean_up_tokenization_spaces=False
+ )[0]
+ return text
diff --git a/vlmeval/vlm/cogvlm.py b/vlmeval/vlm/cogvlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..d17c142da31f51bddb656f645b96845e8fc25ed6
--- /dev/null
+++ b/vlmeval/vlm/cogvlm.py
@@ -0,0 +1,132 @@
+import torch
+from PIL import Image
+from .base import BaseModel
+from ..smp import *
+from ..dataset import DATASET_TYPE
+
+
+class GLM4v(BaseModel):
+
+ INSTALL_REQ = False
+ INTERLEAVE = False
+
+ def __init__(self, model_path='THUDM/glm-4v-9b', **kwargs):
+ from transformers import AutoModelForCausalLM, LlamaTokenizer, AutoTokenizer
+ assert model_path is not None
+ self.model_path = model_path
+ self.tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
+ self.model = AutoModelForCausalLM.from_pretrained(
+ model_path,
+ torch_dtype=torch.bfloat16,
+ low_cpu_mem_usage=True,
+ trust_remote_code=True
+ ).to('cuda').eval()
+ gen_kwargs = {'max_length': 2048, 'do_sample': False}
+ gen_kwargs.update(kwargs)
+ self.kwargs = gen_kwargs
+ self.end_text_token = '<|endoftext|>'
+
+ def generate_inner(self, message, dataset=None):
+ prompt, image_path = self.message_to_promptimg(message, dataset=dataset)
+ image = Image.open(image_path).convert('RGB')
+ if dataset is not None and DATASET_TYPE(dataset) in ['MCQ', 'Y/N']:
+ prompt += '\nShort Answer.'
+ inputs = self.tokenizer.apply_chat_template(
+ [{'role': 'user', 'image': image, 'content': prompt}],
+ add_generation_prompt=True, tokenize=True, return_tensors='pt', return_dict=True
+ )
+ inputs = inputs.to('cuda')
+
+ with torch.no_grad():
+ outputs = self.model.generate(**inputs, **self.kwargs)
+ outputs = outputs[:, inputs['input_ids'].shape[1]:]
+ response = self.tokenizer.decode(outputs[0])
+ return response.split(self.end_text_token)[0]
+
+
+class CogVlm(BaseModel):
+
+ INSTALL_REQ = False
+ INTERLEAVE = False
+
+ def __init__(self, model_path='THUDM/cogvlm2-llama3-chat-19B', tokenizer_name=None, **kwargs):
+ from transformers import AutoModelForCausalLM, LlamaTokenizer, AutoTokenizer
+ assert model_path is not None
+ model = AutoModelForCausalLM.from_pretrained(
+ model_path,
+ torch_dtype=torch.bfloat16,
+ trust_remote_code=True,
+ ).to('cuda').eval()
+
+ self.kwargs = kwargs
+ if tokenizer_name:
+ tokenizer = LlamaTokenizer.from_pretrained(tokenizer_name)
+ gen_kwargs = {'max_length': 2048, 'do_sample': False}
+ self.end_text_token = ''
+ else:
+ tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
+ gen_kwargs = {'max_new_tokens': 2048, 'pad_token_id': 128002}
+ self.end_text_token = '<|end_of_text|>'
+ self.kwargs.update(gen_kwargs)
+ self.tokenizer = tokenizer
+ self.model = model
+
+ def use_custom_prompt(self, dataset):
+ assert dataset is not None
+ if DATASET_TYPE(dataset) == 'MCQ':
+ return True
+ return False
+
+ def build_prompt(self, line, dataset=None):
+ assert dataset is None or isinstance(dataset, str)
+ assert self.use_custom_prompt(dataset)
+ tgt_path = self.dump_image(line, dataset)
+
+ if dataset is not None and DATASET_TYPE(dataset) == 'MCQ':
+ question = line['question']
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ if hint is not None:
+ question = hint + '\n' + question
+
+ option_candidate = string.ascii_uppercase
+ options = {
+ cand: line[cand]
+ for cand in option_candidate
+ if cand in line and not pd.isna(line[cand])
+ }
+ for key, item in options.items():
+ question += f'\n{key}. {item}'
+ prompt = question
+
+ if not cn_string(prompt):
+ prompt = prompt + '\n' + "Answer with the option's letter from the given choices directly."
+ else:
+ prompt = prompt + '\n' + '请直接回答选项字母。'
+ else:
+ prompt = line['question']
+ message = [dict(type='text', value=prompt)]
+ message.extend([dict(type='image', value=p) for p in tgt_path])
+
+ return message
+
+ def generate_inner(self, message, dataset=None):
+ prompt, image_path = self.message_to_promptimg(message, dataset=dataset)
+ if dataset is not None and DATASET_TYPE(dataset) in ['MCQ', 'Y/N']:
+ prompt += '\nShort Answer.'
+
+ image = Image.open(image_path).convert('RGB')
+ inputs = self.model.build_conversation_input_ids(
+ self.tokenizer, query=prompt, history=[], images=[image]) # chat mode
+ inputs = {
+ 'input_ids': inputs['input_ids'].unsqueeze(0).to('cuda'),
+ 'token_type_ids': inputs['token_type_ids'].unsqueeze(0).to('cuda'),
+ 'attention_mask': inputs['attention_mask'].unsqueeze(0).to('cuda'),
+ 'images': [[inputs['images'][0].to('cuda').to(torch.bfloat16)]],
+ }
+
+ with torch.no_grad():
+ outputs = self.model.generate(**inputs, **self.kwargs)
+ outputs = outputs[:, inputs['input_ids'].shape[1]:]
+ response = self.tokenizer.decode(outputs[0])
+ response = response.split(self.end_text_token)[0].strip()
+ return response
diff --git a/vlmeval/vlm/deepseek_vl.py b/vlmeval/vlm/deepseek_vl.py
new file mode 100644
index 0000000000000000000000000000000000000000..0be9306b1f081c0d0fbd9da2c3555d35475929ad
--- /dev/null
+++ b/vlmeval/vlm/deepseek_vl.py
@@ -0,0 +1,82 @@
+import sys
+import torch
+from transformers import AutoModelForCausalLM
+import warnings
+from .base import BaseModel
+from ..smp import *
+
+
+class DeepSeekVL(BaseModel):
+
+ INSTALL_REQ = True
+ INTERLEAVE = True
+
+ def check_install(self):
+ try:
+ import deepseek_vl
+ except Exception as e:
+ logging.critical(
+ 'Please first install deepseek_vl from source codes in: https://github.com/deepseek-ai/DeepSeek-VL')
+ raise e
+
+ def __init__(self, model_path='deepseek-ai/deepseek-vl-1.3b-chat', **kwargs):
+ self.check_install()
+ assert model_path is not None
+ self.model_path = model_path
+ from deepseek_vl.models import VLChatProcessor
+
+ self.vl_chat_processor = VLChatProcessor.from_pretrained(model_path)
+ self.tokenizer = self.vl_chat_processor.tokenizer
+
+ model = AutoModelForCausalLM.from_pretrained(model_path, trust_remote_code=True)
+ self.model = model.to(torch.bfloat16).cuda().eval()
+
+ torch.cuda.empty_cache()
+ default_kwargs = dict(max_new_tokens=512, do_sample=False, use_cache=True)
+ default_kwargs.update(kwargs)
+ self.kwargs = default_kwargs
+ warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ')
+
+ def prepare_inputs(self, message):
+ def prepare_itlist(msgs):
+ content, images = '', []
+ for s in msgs:
+ if s['type'] == 'image':
+ images.append(s['value'])
+ content += ''
+ elif s['type'] == 'text':
+ content += s['value']
+ return content, images
+ conversation = []
+ if 'role' not in message[0]:
+ content, images = prepare_itlist(message)
+ conversation.append(dict(role='User', content=content, images=images))
+ else:
+ role_map = {'user': 'User', 'assistant': 'Assistant'}
+ for msgs in message:
+ role = role_map[msgs['role']]
+ content, images = prepare_itlist(msgs['content'])
+ conversation.append(dict(role=role, content=content, images=images))
+ conversation.append(dict(role='Assistant', content=''))
+ return conversation
+
+ def generate_inner(self, message, dataset=None):
+ conversation = self.prepare_inputs(message)
+ from deepseek_vl.utils.io import load_pil_images
+ pil_images = load_pil_images(conversation)
+ prepare_inputs = self.vl_chat_processor(conversations=conversation, images=pil_images, force_batchify=True)
+ prepare_inputs = prepare_inputs.to(self.model.device)
+ inputs_embeds = self.model.prepare_inputs_embeds(**prepare_inputs)
+
+ outputs = self.model.language_model.generate(
+ inputs_embeds=inputs_embeds,
+ attention_mask=prepare_inputs.attention_mask,
+ pad_token_id=self.tokenizer.eos_token_id,
+ bos_token_id=self.tokenizer.bos_token_id,
+ eos_token_id=self.tokenizer.eos_token_id,
+ **self.kwargs)
+ answer = self.tokenizer.decode(outputs[0].cpu().tolist(), skip_special_tokens=True)
+ return answer
+
+ def chat_inner(self, message, dataset=None):
+ return self.generate_inner(message, dataset=dataset)
diff --git a/vlmeval/vlm/deepseek_vl2.py b/vlmeval/vlm/deepseek_vl2.py
new file mode 100644
index 0000000000000000000000000000000000000000..af6497ea2597a1ccb74f665c89cdf128c1d6033b
--- /dev/null
+++ b/vlmeval/vlm/deepseek_vl2.py
@@ -0,0 +1,163 @@
+import sys
+import torch
+from transformers import AutoModelForCausalLM
+import warnings
+from .base import BaseModel
+from ..smp import *
+from PIL import Image
+
+
+class DeepSeekVL2(BaseModel):
+
+ INSTALL_REQ = True
+ INTERLEAVE = True
+
+ def check_install(self):
+ try:
+ import deepseek_vl2
+ except Exception as e:
+ logging.critical(
+ 'Please first install deepseek_vl2 from source codes in: https://github.com/deepseek-ai/DeepSeek-VL2')
+ raise e
+
+ def __init__(self, model_path='deepseek-ai/deepseek-vl2-tiny', **kwargs):
+ self.check_install()
+ assert model_path is not None
+ self.model_path = model_path
+ from deepseek_vl2.models import DeepseekVLV2Processor, DeepseekVLV2ForCausalLM
+
+ self.vl_chat_processor = DeepseekVLV2Processor.from_pretrained(model_path)
+ self.tokenizer = self.vl_chat_processor.tokenizer
+
+ model: DeepseekVLV2ForCausalLM = AutoModelForCausalLM.from_pretrained(model_path,
+ trust_remote_code=True,
+ torch_dtype=torch.bfloat16)
+ self.model = model.cuda().eval()
+
+ torch.cuda.empty_cache()
+ default_kwargs = dict(max_new_tokens=2048, do_sample=False, use_cache=True)
+ default_kwargs.update(kwargs)
+ self.kwargs = default_kwargs
+ warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ')
+
+ def prepare_inputs(self, message, dataset=None):
+
+ if dataset == 'MMMU_DEV_VAL':
+
+ def prepare_itlist(msgs):
+ content, images = '', []
+ image_idx = 1
+ for s in msgs:
+ if s['type'] == 'image':
+ images.append(s['value'])
+ content += f''
+ image_idx += 1
+ elif s['type'] == 'text':
+ content += s['value']
+ # content = '' * (image_idx-1) + '\n' + content
+ content = '' * (image_idx - 1) + '\n' + content
+ return content, images
+
+ conversation = []
+ if 'role' not in message[0]:
+ content, images = prepare_itlist(message)
+ content = content.replace(
+ 'Please select the correct answer from the options above.',
+ "Answer with the option's letter from the given choices directly. Answer the question using a single word or phrase.\n" # noqa
+ )
+ content = content.replace('Question:', "")
+ content = content.replace('Options:\n', "")
+ conversation.append(dict(role='<|User|>', content=content, images=images))
+ else:
+ role_map = {'user': '<|User|>', 'assistant': '<|Assistant|>'}
+ for msgs in message:
+ role = role_map[msgs['role']]
+ content, images = prepare_itlist(msgs['content'])
+ content = content.replace(
+ 'Please select the correct answer from the options above.',
+ "Answer with the option's letter from the given choices directly. Answer the question using a single word or phrase.\n" # noqa
+ )
+ content = content.replace('Question:', "")
+ content = content.replace('Options:\n', "")
+ conversation.append(dict(role=role, content=content, images=images))
+ conversation.append(dict(role='<|Assistant|>', content=''))
+
+ else:
+
+ def prepare_itlist(msgs):
+ content, images = '', []
+ for s in msgs:
+ if s['type'] == 'image':
+ images.append(s['value'])
+ content += '\n'
+ elif s['type'] == 'text':
+ content += s['value']
+ return content, images
+
+ conversation = []
+ if 'role' not in message[0]:
+ content, images = prepare_itlist(message)
+ conversation.append(dict(role='<|User|>', content=content, images=images))
+ else:
+ role_map = {'user': '<|User|>', 'assistant': '<|Assistant|>'}
+ for msgs in message:
+ role = role_map[msgs['role']]
+ content, images = prepare_itlist(msgs['content'])
+ conversation.append(dict(role=role, content=content, images=images))
+ conversation.append(dict(role='<|Assistant|>', content=''))
+
+ return conversation
+
+ def generate_inner(self, message, dataset=None):
+ conversation = self.prepare_inputs(message, dataset)
+ from deepseek_vl2.utils.io import load_pil_images
+ pil_images = load_pil_images(conversation)
+
+ if dataset == 'MMMU_DEV_VAL':
+ if len(pil_images):
+ h, w = pil_images[0].size
+ pil_images[0] = pil_images[0].resize((2 * h, 2 * w), Image.BILINEAR)
+
+ prepare_inputs = self.vl_chat_processor(
+ conversations=conversation,
+ images=pil_images,
+ force_batchify=True,
+ system_prompt=""
+ )
+ prepare_inputs = prepare_inputs.to(self.model.device)
+ inputs_embeds = self.model.prepare_inputs_embeds(**prepare_inputs)
+
+ inputs_embeds, past_key_values = self.model.incremental_prefilling(
+ input_ids=prepare_inputs.input_ids,
+ images=prepare_inputs.images,
+ images_seq_mask=prepare_inputs.images_seq_mask,
+ images_spatial_crop=prepare_inputs.images_spatial_crop,
+ attention_mask=prepare_inputs.attention_mask,
+ chunk_size=512
+ )
+
+ # run the model to get the response
+ outputs = self.model.generate(
+ inputs_embeds=inputs_embeds,
+ input_ids=prepare_inputs.input_ids,
+ images=prepare_inputs.images,
+ images_seq_mask=prepare_inputs.images_seq_mask,
+ images_spatial_crop=prepare_inputs.images_spatial_crop,
+ attention_mask=prepare_inputs.attention_mask,
+ past_key_values=past_key_values,
+ pad_token_id=self.tokenizer.eos_token_id,
+ bos_token_id=self.tokenizer.bos_token_id,
+ eos_token_id=self.tokenizer.eos_token_id,
+ **self.kwargs
+ )
+
+ answer = self.tokenizer.decode(
+ outputs[0][len(prepare_inputs.input_ids[0]):].cpu().tolist(),
+ skip_special_tokens=True
+ )
+ answer = answer.rstrip('.')
+
+ return answer
+
+ def chat_inner(self, message, dataset=None):
+ return self.generate_inner(message, dataset=dataset)
diff --git a/vlmeval/vlm/eagle_x.py b/vlmeval/vlm/eagle_x.py
new file mode 100644
index 0000000000000000000000000000000000000000..2f02bc692589b901a84684aa8a9e2d80117d6f4e
--- /dev/null
+++ b/vlmeval/vlm/eagle_x.py
@@ -0,0 +1,180 @@
+import torch
+from PIL import Image
+from abc import abstractproperty
+import sys
+import os.path as osp
+from .base import BaseModel
+from ..smp import *
+from ..dataset import DATASET_TYPE
+import copy
+
+
+# This function is used to split Eagle-X5-34B
+def split_model(model_name):
+ import math
+ device_map = {}
+ num_gpus = torch.cuda.device_count()
+ rank, world_size = get_rank_and_world_size()
+ num_gpus = num_gpus // world_size
+
+ num_layers_map = {
+ 'Eagle-X5-34B-Chat': 60,
+ 'Eagle-X5-34B-Plus': 60
+ }
+ if model_name not in num_layers_map:
+ return 'cuda'
+ num_layers = num_layers_map[model_name] + 8
+ # Since the first GPU will be used for ViT, treat it as 0.5 GPU.
+ num_layers_per_gpu = math.ceil(num_layers / num_gpus)
+ num_layers_per_gpu = [num_layers_per_gpu] * num_gpus
+ num_layers_per_gpu[-1] = num_layers - sum(num_layers_per_gpu[:-1])
+ num_layers_per_gpu[0] -= 4
+ layer_cnt = 0
+ for i, num_layer in enumerate(num_layers_per_gpu):
+ for j in range(num_layer):
+ device_map[f'model.layers.{layer_cnt}'] = rank + world_size * i
+ layer_cnt += 1
+ device_map['model.vision_tower'] = rank
+ device_map['model.embed_tokens'] = rank
+ device_map['model.norm'] = rank
+ device_map['model.rotary_emb'] = rank
+ device_map['model.mm_projector'] = rank
+ device_map['lm_head'] = rank
+ device_map[f'model.layers.{num_layers - 1}'] = rank
+
+ logging.warning("Remove L157-L158 in https://github.com/NVlabs/EAGLE/blob/fef95f103b5e9899acbbe2c237e5b99147ab7e8e/eagle/model/builder.py to make it work properly.") # noqa: E501
+ return device_map
+
+
+class Eagle(BaseModel):
+ INSTALL_REQ = True
+ INTERLEAVE = True
+
+ def __init__(self,
+ model_path='NVEagle/Eagle-X5-7B',
+ **kwargs):
+ try:
+ from eagle.model.builder import load_pretrained_model
+ from eagle.utils import disable_torch_init
+ from eagle.mm_utils import get_model_name_from_path
+ except Exception as e:
+ logging.critical('''Please install eagle before using Eagle,
+ you can install it from "https://github.com/NVlabs/EAGLE.git"''')
+ raise e
+
+ warnings.warn('Please install the latest version of eagle from github before you evaluate the Eagle model.')
+ assert osp.exists(model_path) or splitlen(model_path) == 2
+ model_name = get_model_name_from_path(model_path)
+ rank, world_size = get_rank_and_world_size()
+
+ device_map = split_model(model_path.split('/')[-1])
+
+ self.tokenizer, self.model, self.image_processor, self.context_len = (
+ load_pretrained_model(model_path, None, model_name, False, False, device_map=device_map)
+ )
+ self.model.eval()
+ self.conv_mode = 'vicuna_v1'
+
+ default_kwargs = dict(
+ do_sample=True,
+ temperature=0.2,
+ top_p=0.5,
+ num_beams=1,
+ max_new_tokens=512,
+ use_cache=True
+ )
+
+ default_kwargs.update(kwargs)
+ self.kwargs = default_kwargs
+ warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ')
+ torch.cuda.empty_cache()
+
+ def generate_inner(self, message, dataset=None):
+ try:
+ from eagle import conversation as conversation_lib
+ from eagle.constants import (IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_TOKEN,
+ DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN)
+ from eagle.conversation import conv_templates, SeparatorStyle
+ from eagle.mm_utils import tokenizer_image_token, process_images, KeywordsStoppingCriteria
+ except Exception as e:
+ logging.critical('''Please install eagle before using Eagle,
+ you can install it from "https://github.com/NVlabs/EAGLE.git"''')
+ raise e
+
+ kwargs = self.kwargs
+
+ images = []
+ prompt = ''
+
+ for s in message:
+ if s['type'] == 'image':
+ images.append(s['value'])
+ elif s['type'] == 'text':
+ prompt += s['value']
+
+ DEFAULT_IMAGE_TOKEN = DEFAULT_IMAGE_TOKEN * len(images)
+ if self.model.config.mm_use_im_start_end:
+ prompt = DEFAULT_IM_START_TOKEN + DEFAULT_IMAGE_TOKEN + DEFAULT_IM_END_TOKEN + '\n' + prompt
+ else:
+ prompt = DEFAULT_IMAGE_TOKEN + '\n' + prompt
+
+ conv = conv_templates[self.conv_mode].copy()
+ conv.append_message(conv.roles[0], prompt)
+ conv.append_message(conv.roles[1], None)
+ prompt = conv.get_prompt()
+ images = [Image.open(s).convert('RGB') for s in images]
+
+ image_tensor = process_images(images, self.image_processor, self.model.config)
+ input_ids = tokenizer_image_token(prompt, self.tokenizer, IMAGE_TOKEN_INDEX, return_tensors='pt')
+ input_ids = input_ids.to(device='cuda', non_blocking=True)
+ image_tensor = image_tensor.to(dtype=torch.float16, device='cuda', non_blocking=True)
+
+ with torch.inference_mode():
+ output_ids = self.model.generate(
+ input_ids.unsqueeze(0),
+ images=image_tensor,
+ image_sizes=[img.size for img in images],
+ **kwargs
+ )
+
+ outputs = self.tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0].strip()
+ return outputs
+
+ def use_custom_prompt(self, dataset):
+ assert dataset is not None
+ if listinstr(['MMMU'], dataset):
+ return False
+ if DATASET_TYPE(dataset) == 'MCQ' or dataset == 'MMVet':
+ return True
+ return False
+
+ def build_prompt(self, line, dataset=None):
+ assert dataset is None or isinstance(dataset, str)
+ assert self.use_custom_prompt(dataset)
+ tgt_path = self.dump_image(line, dataset)
+ question = line['question']
+ if dataset == 'MMVet':
+ prompt = question + '\nAnswer the question directly. '
+ elif DATASET_TYPE(dataset) == 'MCQ':
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ options_prompt = ''
+ for key, item in options.items():
+ options_prompt += f'{key}. {item}\n'
+
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ prompt = f'Hint: {hint}\n' if hint is not None else ''
+ prompt += f'{question}\n'
+ prompt += (
+ f'{options_prompt}\nAnswer with the option’s letter from the given choices directly. '
+ if len(options) else 'Answer the question directly. '
+ )
+ else:
+ raise NotImplementedError
+
+ message = [dict(type='text', value=prompt)]
+ message.extend([dict(type='image', value=s) for s in tgt_path])
+ return message
diff --git a/vlmeval/vlm/emu.py b/vlmeval/vlm/emu.py
new file mode 100644
index 0000000000000000000000000000000000000000..10041f74d869c09d3b4303c20262cbe828f319a4
--- /dev/null
+++ b/vlmeval/vlm/emu.py
@@ -0,0 +1,305 @@
+import os
+import sys
+import torch
+from PIL import Image
+import os.path as osp
+from .base import BaseModel
+from ..smp import *
+from huggingface_hub import snapshot_download
+from PIL import Image, ImageOps
+
+
+def get_local_root(repo_id):
+ if osp.exists(repo_id) and osp.isdir(repo_id):
+ return repo_id
+
+ cache_path = get_cache_path(repo_id, repo_type='models')
+ if cache_path is None:
+ cache_path = snapshot_download(repo_id=repo_id)
+ assert osp.exists(cache_path) and osp.isdir(cache_path)
+ return cache_path
+
+
+def pad_image_to_aspect_ratio(img, max_aspect_ratio=5):
+ """
+ Pad an image to ensure its aspect ratio (width/height or height/width) is less than the given value.
+
+ Parameters:
+ img (PIL.Image): The input PIL Image object.
+ max_aspect_ratio (float): The maximum allowed aspect ratio.
+
+ Returns:
+ PIL.Image: The padded image.
+ """
+ width, height = img.size
+ # Calculate the required minimum dimensions to satisfy the aspect ratio constraint
+ if width > height * max_aspect_ratio:
+ # Width is too large, pad height
+ new_height = int(width / max_aspect_ratio + 1)
+ new_width = width
+ elif height > width * max_aspect_ratio:
+ # Height is too large, pad width
+ new_width = int(height / max_aspect_ratio + 1)
+ new_height = height
+ else:
+ # Aspect ratio is already less than or equal to max_aspect_ratio
+ return img
+
+ # Calculate the padding amounts
+ pad_width = (new_width - width)
+ pad_height = (new_height - height)
+
+ # Pad the image symmetrically
+ padding = (pad_width // 2, pad_height // 2, pad_width - pad_width // 2, pad_height - pad_height // 2)
+ padded_img = ImageOps.expand(img, padding, fill=(0, 0, 0)) # Fill color is black (0, 0, 0) by default
+
+ return padded_img
+
+
+class Emu(BaseModel):
+
+ INSTALL_REQ = False
+ INTERLEAVE = True
+
+ def __init__(self,
+ model_path='BAAI/Emu2-Chat',
+ **kwargs):
+
+ self.model_path = model_path
+ assert osp.exists(model_path) or splitlen(model_path) == 2
+
+ from transformers import AutoModelForCausalLM, AutoTokenizer
+ from accelerate import init_empty_weights, infer_auto_device_map, dispatch_model
+
+ local_rank = os.environ.get('LOCAL_RANK', 0)
+
+ device_num = torch.cuda.device_count()
+ assert local_rank * 2 <= device_num, 'The number of devices does not match the world size'
+ assert device_num >= 2, 'You need at least 2 GPUs to use EMU'
+
+ device_1 = local_rank
+ device_2 = local_rank + device_num // 2
+
+ torch.cuda.set_device(device_1)
+ torch.cuda.set_device(device_2)
+
+ tokenizer = AutoTokenizer.from_pretrained(model_path) # "BAAI/Emu2-Chat"
+ self.tokenizer = tokenizer
+ with init_empty_weights():
+ model = AutoModelForCausalLM.from_pretrained(
+ model_path, # "BAAI/Emu2-Chat"
+ torch_dtype=torch.bfloat16,
+ trust_remote_code=True)
+
+ device_map = infer_auto_device_map(
+ model,
+ max_memory={
+ device_1: '38GiB',
+ device_2: '38GiB'
+ },
+ no_split_module_classes=['Block', 'LlamaDecoderLayer'])
+
+ # input and output logits should be on same device
+ device_map['model.decoder.lm.lm_head'] = device_1
+
+ model = dispatch_model(
+ model,
+ device_map=device_map).eval()
+
+ self.model = model
+ kwargs_default = dict(max_new_tokens=512, length_penalty=-1)
+ kwargs_default.update(kwargs)
+ self.kwargs = kwargs_default
+ warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ')
+
+ def generate_inner(self, message, dataset=None):
+ query, images = '', []
+ for item in message:
+ if item['type'] == 'image':
+ images.append(Image.open(item['value']).convert('RGB'))
+ query += '[]'
+ elif item['type'] == 'text':
+ query += item['value']
+
+ inputs = self.model.build_input_ids(
+ text=[query],
+ tokenizer=self.tokenizer,
+ image=images
+ )
+
+ with torch.no_grad():
+ outputs = self.model.generate(
+ input_ids=inputs['input_ids'],
+ attention_mask=inputs['attention_mask'],
+ image=inputs['image'].to(torch.bfloat16),
+ **self.kwargs)
+
+ output_text = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
+ return output_text[0]
+
+
+class Emu3_chat(BaseModel):
+ INSTALL_REQ = False
+ INTERLEAVE = False
+
+ def __init__(self, model_path='BAAI/Emu3-Chat', tokenizer_path='BAAI/Emu3-VisionTokenizer', **kwargs):
+ assert model_path is not None
+ assert tokenizer_path is not None
+ try:
+ from transformers import AutoTokenizer, AutoModel, AutoImageProcessor, AutoModelForCausalLM
+ local_root = get_local_root(model_path)
+ sys.path.append(local_root)
+ from processing_emu3 import Emu3Processor
+ except Exception as err:
+ raise err
+
+ # load model wights
+ model = AutoModelForCausalLM.from_pretrained(
+ model_path,
+ device_map='cuda',
+ torch_dtype=torch.bfloat16,
+ attn_implementation="flash_attention_2",
+ trust_remote_code=True)
+ model.eval()
+ self.model = model
+ self.tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True, padding_side="left")
+ self.image_processor = AutoImageProcessor.from_pretrained(tokenizer_path, trust_remote_code=True)
+ self.image_tokenizer = AutoModel.from_pretrained(
+ tokenizer_path, device_map='cuda', trust_remote_code=True).eval()
+ self.processor = Emu3Processor(self.image_processor, self.image_tokenizer, self.tokenizer)
+ self.kwargs = kwargs
+
+ def generate_inner(self, message, dataset=None):
+ prompt, image = self.message_to_promptimg(message)
+ image = Image.open(image).convert('RGB')
+ image = pad_image_to_aspect_ratio(image, 5)
+
+ inputs = self.processor(
+ text=[prompt],
+ image=[image],
+ mode='U',
+ return_tensors="pt",
+ padding="longest",
+ )
+ from transformers.generation.configuration_utils import GenerationConfig
+ # prepare hyper parameters
+ GENERATION_CONFIG = GenerationConfig(
+ pad_token_id=self.tokenizer.pad_token_id,
+ bos_token_id=self.tokenizer.bos_token_id,
+ eos_token_id=self.tokenizer.eos_token_id,
+ max_new_tokens=1024,
+ )
+ # generate
+ outputs = self.model.generate(
+ inputs.input_ids.to('cuda'),
+ GENERATION_CONFIG,
+ attention_mask=inputs.attention_mask.to('cuda'),
+ )
+
+ outputs = outputs[:, inputs.input_ids.shape[-1]:]
+ response = self.processor.batch_decode(outputs, skip_special_tokens=True)[0]
+ return response
+
+
+class Emu3_gen(BaseModel):
+ INSTALL_REQ = False
+ INTERLEAVE = False
+
+ def __init__(self,
+ model_path='BAAI/Emu3-Gen',
+ tokenizer_path='BAAI/Emu3-VisionTokenizer',
+ output_path='',
+ **kwargs):
+
+ assert model_path is not None
+ assert tokenizer_path is not None
+ try:
+ from transformers import AutoTokenizer, AutoModel, AutoImageProcessor, AutoModelForCausalLM
+ local_root = get_local_root(model_path)
+ sys.path.append(local_root)
+ from processing_emu3 import Emu3Processor
+ except Exception as err:
+ raise err
+
+ # load model wights
+ model = AutoModelForCausalLM.from_pretrained(
+ model_path,
+ device_map='cuda',
+ torch_dtype=torch.bfloat16,
+ attn_implementation="flash_attention_2",
+ trust_remote_code=True)
+ model.eval()
+ self.model = model
+
+ self.tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True, padding_side="left")
+ self.image_processor = AutoImageProcessor.from_pretrained(tokenizer_path, trust_remote_code=True)
+ self.image_tokenizer = AutoModel.from_pretrained(
+ tokenizer_path,
+ device_map='cuda',
+ trust_remote_code=True).eval()
+ self.processor = Emu3Processor(self.image_processor, self.image_tokenizer, self.tokenizer)
+ self.kwargs = kwargs
+ self.output_path = output_path
+
+ def generate_inner(self, message, dataset=None):
+ query = ''
+ for item in message:
+ if item['type'] == 'text':
+ query += item['value']
+ else:
+ raise ValueError('Please input the text in generation stage.')
+
+ # prepare input
+ POSITIVE_PROMPT = " masterpiece, film grained, best quality."
+ NEGATIVE_PROMPT = "lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry." # noqa: E501
+
+ classifier_free_guidance = 3.0
+ prompt = "a portrait of young girl."
+ prompt += POSITIVE_PROMPT
+
+ kwargs = dict(
+ mode='G',
+ ratio="1:1",
+ image_area=self.model.config.image_area,
+ return_tensors="pt",
+ padding="longest") # noqa: E501
+
+ pos_inputs = self.processor(text=prompt, **kwargs)
+ neg_inputs = self.processor(text=NEGATIVE_PROMPT, **kwargs)
+ from transformers.generation.configuration_utils import GenerationConfig
+ # prepare hyper parameters
+ GENERATION_CONFIG = GenerationConfig(
+ use_cache=True,
+ eos_token_id=self.model.config.eos_token_id,
+ pad_token_id=self.model.config.pad_token_id,
+ max_new_tokens=40960,
+ do_sample=True,
+ top_k=2048,
+ )
+
+ h = pos_inputs.image_size[:, 0]
+ w = pos_inputs.image_size[:, 1]
+ constrained_fn = self.processor.build_prefix_constrained_fn(h, w)
+ from transformers.generation import LogitsProcessorList, PrefixConstrainedLogitsProcessor, UnbatchedClassifierFreeGuidanceLogitsProcessor # noqa: E501
+ logits_processor = LogitsProcessorList([
+ UnbatchedClassifierFreeGuidanceLogitsProcessor(
+ classifier_free_guidance,
+ self.model,
+ unconditional_ids=neg_inputs.input_ids.to("cuda:0"),
+ ),
+ PrefixConstrainedLogitsProcessor(constrained_fn, num_beams=1),
+ ])
+
+ # generate
+ outputs = self.model.generate(
+ pos_inputs.input_ids.to("cuda:0"),
+ GENERATION_CONFIG,
+ logits_processor=logits_processor,
+ attention_mask=pos_inputs.attention_mask.to("cuda:0"),
+ )
+
+ mm_list = self.processor.decode(outputs[0])
+ for idx, im in enumerate(mm_list):
+ if not isinstance(im, Image.Image):
+ continue
+ im.save(os.path.join(self.output_path, f"result_{idx}.png"))
diff --git a/vlmeval/vlm/falcon_vlm.py b/vlmeval/vlm/falcon_vlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..1abf84cbbc3cdb529b4370cd74116d753d56db38
--- /dev/null
+++ b/vlmeval/vlm/falcon_vlm.py
@@ -0,0 +1,34 @@
+from PIL import Image
+import requests
+
+from .base import BaseModel
+
+
+class Falcon2VLM(BaseModel):
+
+ INSTALL_REQ = False
+ INTERLEAVE = False
+
+ def __init__(self, model_path='tiiuae/falcon-11B-vlm', **kwargs):
+ import torch
+ from transformers import LlavaNextForConditionalGeneration, LlavaNextProcessor
+
+ self.model_path = model_path
+ self.processor = LlavaNextProcessor.from_pretrained(model_path, tokenizer_class='PreTrainedTokenizerFast')
+ self.model = LlavaNextForConditionalGeneration.from_pretrained(
+ model_path, torch_dtype=torch.bfloat16, device_map='cuda').eval()
+ default_kwargs = {'max_new_tokens': 512}
+ default_kwargs.update(kwargs)
+ self.kwargs = default_kwargs
+
+ def generate_inner(self, message, dataset=None):
+ prompt, image_path = self.message_to_promptimg(message, dataset=dataset)
+ image = Image.open(image_path).convert('RGB')
+
+ prompt = f'User:\n{prompt} Falcon:'
+ inputs = self.processor(text=prompt, images=image, return_tensors='pt').to('cuda')
+
+ output = self.model.generate(**inputs, **self.kwargs)
+ prompt_length = inputs['input_ids'].shape[1]
+ model_response = self.processor.decode(output[0][prompt_length:], skip_special_tokens=True).strip()
+ return model_response
diff --git a/vlmeval/vlm/gemma.py b/vlmeval/vlm/gemma.py
new file mode 100644
index 0000000000000000000000000000000000000000..8d8bf393452b80972f64e58df6cdbdcec32a4017
--- /dev/null
+++ b/vlmeval/vlm/gemma.py
@@ -0,0 +1,109 @@
+from PIL import Image
+import torch
+
+from .base import BaseModel
+from ..smp import *
+
+
+class PaliGemma(BaseModel):
+ INSTALL_REQ = False
+ INTERLEAVE = False
+
+ def __init__(self, model_path='google/paligemma-3b-mix-448', **kwargs):
+ try:
+ from transformers import AutoProcessor, PaliGemmaForConditionalGeneration
+ except Exception as e:
+ logging.critical('Please install the latest version transformers.')
+ raise e
+
+ model = PaliGemmaForConditionalGeneration.from_pretrained(
+ model_path,
+ torch_dtype=torch.bfloat16,
+ device_map='cpu',
+ revision='bfloat16',
+ ).eval()
+ self.model = model.cuda()
+ self.processor = AutoProcessor.from_pretrained(model_path)
+ self.kwargs = kwargs
+
+ def generate_inner(self, message, dataset=None):
+ prompt, image_path = self.message_to_promptimg(message, dataset=dataset)
+ image = Image.open(image_path).convert('RGB')
+
+ model_inputs = self.processor(
+ text=prompt, images=image, return_tensors='pt'
+ ).to('cuda')
+ input_len = model_inputs['input_ids'].shape[-1]
+
+ with torch.inference_mode():
+ generation = self.model.generate(
+ **model_inputs, max_new_tokens=512, do_sample=False
+ )
+ generation = generation[0][input_len:]
+ res = self.processor.decode(generation, skip_special_tokens=True)
+ return res
+
+
+class Gemma3(BaseModel):
+
+ INSTALL_REQ = False
+ INTERLEAVE = True
+
+ def __init__(self, model_path='google/gemma-3-4b-it', **kwargs):
+ logging.info(
+ "Please install transformers via \n"
+ "pip install git+https://github.com/huggingface/transformers@v4.49.0-Gemma-3"
+ )
+ try:
+ from transformers import AutoProcessor, Gemma3ForConditionalGeneration
+ import torch
+ except Exception as e:
+ logging.critical('Please install torch and transformers')
+ raise e
+
+ self.model = Gemma3ForConditionalGeneration.from_pretrained(
+ model_path, device_map="cuda", attn_implementation="flash_attention_2"
+ ).eval()
+
+ self.device = self.model.device
+ self.processor = AutoProcessor.from_pretrained(model_path)
+
+ self.system_prompt = kwargs.pop('system_prompt', 'You are a helpful assistant. ')
+
+ default_kwargs = {
+ 'do_sample': False,
+ 'max_new_tokens': 2048
+ }
+ default_kwargs.update(kwargs)
+ self.kwargs = default_kwargs
+
+ def message2pipeline(self, message):
+ ret = []
+ if hasattr(self, 'system_prompt') and self.system_prompt is not None:
+ ret = [
+ dict(role='system', content=[dict(type='text', text=self.system_prompt)])
+ ]
+ content = []
+ for m in message:
+ if m['type'] == 'text':
+ content.append(dict(type='text', text=m['value']))
+ elif m['type'] == 'image':
+ content.append(dict(type='image', url=m['value']))
+ ret.append(dict(role='user', content=content))
+ return ret
+
+ def generate_inner(self, message, dataset=None):
+ messages = self.message2pipeline(message)
+ inputs = self.processor.apply_chat_template(
+ messages, add_generation_prompt=True, tokenize=True,
+ return_dict=True, return_tensors="pt",
+ ).to(self.device, dtype=torch.bfloat16)
+
+ input_len = inputs['input_ids'].shape[-1]
+
+ with torch.inference_mode():
+ generation = self.model.generate(**inputs, **self.kwargs)
+ generation = generation[0][input_len:]
+
+ decoded = self.processor.decode(generation, skip_special_tokens=True)
+ return decoded
diff --git a/vlmeval/vlm/h2ovl_mississippi.py b/vlmeval/vlm/h2ovl_mississippi.py
new file mode 100644
index 0000000000000000000000000000000000000000..b5957d14df6728b0f6e20cf15ca8c3948111a058
--- /dev/null
+++ b/vlmeval/vlm/h2ovl_mississippi.py
@@ -0,0 +1,117 @@
+import torch
+from transformers import AutoTokenizer, AutoModel
+import warnings
+from .base import BaseModel
+from ..smp import *
+from ..dataset import DATASET_TYPE
+import pandas as pd
+import string
+
+
+class H2OVLChat(BaseModel):
+
+ INSTALL_REQ = False
+ INTERLEAVE = True
+
+ def __init__(self, model_path='h2oai/h2ovl-mississippi-2b', **kwargs):
+ assert model_path is not None
+
+ self.model_path = model_path
+ self.tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True, use_fast=False)
+
+ device = torch.cuda.current_device()
+ self.device = device
+ self.model = AutoModel.from_pretrained(
+ model_path,
+ torch_dtype=torch.bfloat16,
+ trust_remote_code=True).eval()
+ self.model = self.model.to(device)
+ self.image_size = self.model.config.vision_config.image_size
+
+ kwargs_default = dict(do_sample=False, max_new_tokens=1024, top_p=None, num_beams=1)
+ kwargs_default.update(kwargs)
+ self.kwargs = kwargs_default
+ warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ')
+
+ def use_custom_prompt(self, dataset):
+ return True
+
+ def build_multi_choice_prompt(self, line, dataset=None):
+ question = line['question']
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ if hint is not None:
+ question = hint + '\n' + question
+
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ for key, item in options.items():
+ question += f'\n{key}. {item}'
+ prompt = question
+
+ if len(options):
+ prompt += '\n请直接回答选项字母。' if cn_string(
+ prompt) else "\nAnswer with the option's letter from the given choices directly."
+ else:
+ prompt += '\n请直接回答问题。' if cn_string(prompt) else '\nAnswer the question directly.'
+
+ return prompt
+
+ def build_prompt(self, line, dataset=None):
+ assert self.use_custom_prompt(dataset)
+ assert dataset is None or isinstance(dataset, str)
+ tgt_path = self.dump_image(line, dataset)
+
+ if dataset is not None and listinstr(['MME'], dataset):
+ question = line['question']
+ prompt = question + ' Answer the question using a single word or phrase.'
+ elif dataset is not None and listinstr(['HallusionBench'], dataset):
+ question = line['question']
+ prompt = question + ' Please answer yes or no. Answer the question using a single word or phrase.'
+ elif dataset is not None and DATASET_TYPE(dataset) == 'MCQ':
+ prompt = self.build_multi_choice_prompt(line, dataset)
+ elif dataset is not None and DATASET_TYPE(dataset) == 'VQA':
+ if 'MathVista' in dataset:
+ prompt = line['question']
+ elif listinstr(['LLaVABench'], dataset):
+ question = line['question']
+ prompt = question + '\nAnswer this question in detail.'
+ elif listinstr(['MMVet'], dataset):
+ prompt = line['question']
+ else:
+ question = line['question']
+ prompt = question + '\nAnswer the question using a single word or phrase.'
+ else:
+ prompt = line['question']
+ message = [dict(type='text', value=prompt)]
+ message.extend([dict(type='image', value=s) for s in tgt_path])
+ return message
+
+ def generate_inner(self, message, dataset=None):
+ image_num = len([x for x in message if x['type'] == 'image'])
+ question = ''
+ image_files = [x['value'] for x in message if x['type'] == 'image']
+
+ if image_num == 1:
+ question = '\n' + '\n'.join([x['value'] for x in message if x['type'] == 'text'])
+
+ elif image_num > 1:
+ text_part = ' '.join([x['value'] for x in message if x['type'] == 'text'])
+ image_part = ' '.join([f': ' for i in range(image_num)])
+ question = image_part + '\n' + text_part
+
+ else:
+ question = '\n'.join([x['value'] for x in message if x['type'] == 'text'])
+ image_files = None
+
+ response, history = self.model.chat(
+ self.tokenizer,
+ image_files=image_files,
+ question=question,
+ generation_config=self.kwargs,
+ max_tiles=6,
+ history=None,
+ return_history=True)
+ return response
diff --git a/vlmeval/vlm/idefics.py b/vlmeval/vlm/idefics.py
new file mode 100644
index 0000000000000000000000000000000000000000..3cab5d2ae0ecabbb16424a0ce4129566579aace4
--- /dev/null
+++ b/vlmeval/vlm/idefics.py
@@ -0,0 +1,309 @@
+import torch
+import os.path as osp
+import warnings
+from .base import BaseModel
+from ..smp import splitlen, listinstr
+from PIL import Image
+
+
+class IDEFICS(BaseModel):
+ INSTALL_REQ = False
+ INTERLEAVE = True
+
+ def __init__(self, model_path='HuggingFaceM4/idefics-9b-instruct', **kwargs):
+ assert osp.exists(model_path) or splitlen(model_path) == 2
+ from transformers import IdeficsForVisionText2Text, AutoProcessor
+
+ self.model = IdeficsForVisionText2Text.from_pretrained(
+ model_path, torch_dtype=torch.bfloat16, device_map='auto'
+ )
+ self.processor = AutoProcessor.from_pretrained(model_path)
+ kwargs_default = {'max_new_tokens': 512}
+ kwargs_default.update(kwargs)
+ self.kwargs = kwargs_default
+ self.file_root = osp.dirname(__file__)
+ warnings.warn(
+ f'Following kwargs received: {self.kwargs}, will use as generation config. '
+ )
+
+ def generate_inner(self, message, dataset=None):
+ prompts = (
+ ['Users:']
+ + [msg['value'] if msg['type'] == 'text' else Image.open(msg['value']) for msg in message]
+ + ['', '\nAssistant: ']
+ )
+ inputs = self.processor(
+ prompts, add_end_of_utterance_token=False, return_tensors='pt'
+ ).to('cuda')
+ exit_condition = self.processor.tokenizer(
+ '', add_special_tokens=False
+ ).input_ids
+ bad_words_ids = self.processor.tokenizer(
+ ['', ''], add_special_tokens=False
+ ).input_ids
+
+ generated_ids = self.model.generate(
+ **inputs,
+ eos_token_id=exit_condition,
+ bad_words_ids=bad_words_ids,
+ **self.kwargs,
+ )
+ generated_text = self.processor.batch_decode(
+ generated_ids, skip_special_tokens=True
+ )
+ text = generated_text[0].split('\nAssistant: ')[-1]
+ return text
+
+
+class IDEFICS2(BaseModel):
+ INSTALL_REQ = True
+ INTERLEAVE = True
+
+ def __init__(self, model_path='HuggingFaceM4/idefics2-8b', **kwargs):
+ from transformers import AutoProcessor, AutoModelForVision2Seq
+ from transformers.image_utils import load_image
+ assert model_path is not None
+ self.model_path = model_path
+ if 'Idefics3' in self.model_path.lower():
+ warnings.warn('Install transfomers from source: PR https://github.com/open-compass/VLMEvalKit/pull/379')
+ warnings.warn('Reference: https://huggingface.co/HuggingFaceM4/Idefics3-8B-Llama3')
+ self.processor = AutoProcessor.from_pretrained(model_path)
+ model = AutoModelForVision2Seq.from_pretrained(
+ model_path,
+ torch_dtype=torch.bfloat16,
+ _attn_implementation='flash_attention_2',
+ device_map='cpu')
+ self.model = model.to('cuda')
+
+ kwargs_default = {'max_new_tokens': 1024}
+ kwargs_default.update(kwargs)
+ self.kwargs = kwargs_default
+ warnings.warn(
+ f'Following kwargs received: {self.kwargs}, will use as generation config. '
+ )
+ torch.cuda.empty_cache()
+
+ def _process(self, formatted_messages, formatted_images):
+ inputs = self.processor(
+ text=formatted_messages, images=formatted_images, return_tensors='pt'
+ )
+ inputs = {k: v.to(self.model.device) for k, v in inputs.items()}
+ return inputs
+
+ def build_prompt_default(self, message, add_brief=False, add_yes_or_no=False, change_the_img_place=False):
+ if change_the_img_place:
+ new_message = []
+ for s in message:
+ if s['type'] == 'image':
+ new_message.append(s)
+ for s in message:
+ if s['type'] == 'text':
+ new_message.append(s)
+ message = new_message
+ prompt, images = 'User:', []
+ for msg in message:
+ if msg['type'] == 'image':
+ img = load_image(msg['value'])
+ images.append(img)
+ prompt += ''
+ elif msg['type'] == 'text':
+ prompt += msg['value'].strip()
+ if add_brief:
+ prompt += '\nGive a very brief answer.'
+ if add_yes_or_no:
+ prompt += '\nAnswer yes or no.'
+ prompt += '\nAssistant:'
+ return prompt, images
+
+ def build_prompt_puremcq(self, message):
+ replace_mapping = {
+ '\nOptions:': '\nChoices:',
+ 'Please select the correct answer from the options above.': 'Answer with the letter.',
+ }
+
+ prompt, images = 'User:', []
+ for msg in message:
+ if msg['type'] == 'image':
+ img = load_image(msg['value'])
+ images.append(img)
+ prompt += ''
+ elif msg['type'] == 'text':
+ instruction = msg['value'].strip()
+ for k, v in replace_mapping.items():
+ instruction = instruction.replace(k, v)
+ prompt += instruction
+ prompt += '\nAssistant: Answer:'
+ return prompt, images
+
+ def build_prompt_mt(self, message):
+ prompt, images = '', []
+ for msg in message:
+ if msg['role'] == 'user':
+ prompt += 'User: '
+ elif msg['role'] == 'assistant':
+ prompt += 'Assistant: '
+ for item in msg['content']:
+ if item['type'] == 'image':
+ img = load_image(item['value'])
+ images.append(img)
+ prompt += ''
+ elif item['type'] == 'text':
+ prompt += item['value'].strip()
+ prompt += '\n'
+ return prompt + 'Assistant: '
+
+ def build_prompt_mmbench(self, message):
+ replace_mapping = {
+ '\nOptions:': '\nChoices:',
+ 'Please select the correct answer from the options above.': 'Answer with a letter.',
+ }
+
+ prompt, images = 'User:', []
+ for msg in message:
+ if msg['type'] == 'image':
+ img = load_image(msg['value'])
+ images.append(img)
+ prompt += ''
+ elif msg['type'] == 'text':
+ instruction = msg['value'].strip()
+ for k, v in replace_mapping.items():
+ instruction = instruction.replace(k, v)
+ # Swap hint and question
+ if instruction.startswith('Hint:'):
+ hint, question = instruction.split('\nQuestion:')
+ question, choices = question.split('\nChoices:')
+ instruction = (
+ 'Question:' + question + '\n' + hint + '\nChoices:' + choices
+ )
+ prompt += instruction
+ prompt += '\nAssistant: Answer:'
+ return prompt, images
+
+ def build_prompt_mmmu(self, message):
+ replace_mapping = {
+ 'Question:': '',
+ 'Please select the correct answer from the options above.': 'Answer with the letter.',
+ '\nOptions:': '\nChoices:',
+ }
+
+ prompt, images, img_counter = 'User: Question: ', [], 1
+ for msg in message:
+ if msg['type'] == 'image':
+ prompt += f':\n'
+ img_counter += 1
+ img_counter = 1
+
+ for msg in message:
+ if msg['type'] == 'image':
+ img = load_image(msg['value'])
+ images.append(img)
+ prompt += f' '
+ img_counter += 1
+ elif msg['type'] == 'text':
+ instruction = msg['value'].strip()
+ for k, v in replace_mapping.items():
+ instruction = instruction.replace(k, v)
+ prompt += instruction.strip()
+ prompt += '\nAssistant:'
+ if 'A.' in prompt and 'B.' in prompt:
+ prompt += ' Answer:'
+ return prompt, images
+
+ def build_prompt_mathvista(self, message):
+ replace_mapping = {
+ '(A) ': 'A. ',
+ '(B) ': 'B. ',
+ '(C) ': 'C. ',
+ '(D) ': 'D. ',
+ '(E) ': 'E. ',
+ '(F) ': 'F. ',
+ '(G) ': 'G. ',
+ '(H) ': 'H. ',
+ '\nOptions:': '\nChoices:',
+ 'Hint: ': '',
+ }
+
+ prompt, images = 'User:', []
+ for msg in message:
+ if msg['type'] == 'image':
+ img = load_image(msg['value'])
+ images.append(img)
+ prompt += ''
+ elif msg['type'] == 'text':
+ instruction = msg['value'].strip()
+ for k, v in replace_mapping.items():
+ instruction = instruction.replace(k, v)
+ prompt += instruction.strip()
+ if 'A.' in prompt and 'B.' in prompt:
+ prompt += '\nAnswer with the letter.'
+ prompt += '\nAssistant:'
+ if 'A.' in prompt and 'B.' in prompt:
+ prompt += ' Answer:'
+ return prompt, images
+
+ def chat_inner(self, message, dataset=None):
+ formatted_messages, formatted_images = self.build_prompt_mt(message)
+ inputs = self._process(formatted_messages, formatted_images)
+
+ generated_ids = self.model.generate(**inputs, **self.kwargs)
+ generated_text = self.processor.batch_decode(
+ generated_ids[:, inputs['input_ids'].size(1):], skip_special_tokens=True
+ )[0]
+ response = generated_text.strip()
+ # print(dataset, " | ", formatted_messages.replace("\n", "\\n"), " | ", response.replace("\n", "\\n"))
+ return response
+
+ def generate_inner(self, message, dataset=None):
+ if dataset in [
+ 'MMBench_DEV_EN', 'MMBench_DEV_EN_V11',
+ 'MMBench_TEST_EN', 'MMBench_TEST_EN_V11',
+ 'MMBench_DEV_CN', 'MMBench_DEV_CN_V11',
+ 'MMBench_TEST_CN', 'MMBench_TEST_CN_V11',
+ 'MMBench', 'MMBench_V11', 'MMBench_CN', 'MMBench_CN_V11'
+ ]:
+ formatted_messages, formatted_images = self.build_prompt_mmbench(message)
+ elif dataset in ['MMMU_DEV_VAL', 'MMMU_TEST']:
+ formatted_messages, formatted_images = self.build_prompt_mmmu(message)
+ elif dataset in ['MathVista_MINI']:
+ formatted_messages, formatted_images = self.build_prompt_mathvista(message)
+ elif dataset in [
+ 'MME',
+ 'MMVet',
+ 'OCRVQA_TEST',
+ 'OCRVQA_TESTCORE',
+ 'TextVQA_VAL',
+ 'ChartQA_TEST',
+ 'DocVQA_VAL',
+ 'DocVQA_TEST',
+ 'InfoVQA_VAL',
+ 'InfoVQA_TEST',
+ ]:
+ formatted_messages, formatted_images = self.build_prompt_default(
+ message, add_brief=True
+ )
+ elif dataset == 'HallusionBench':
+ formatted_messages, formatted_images = self.build_prompt_default(
+ message, add_yes_or_no=True
+ )
+ elif dataset in [
+ 'MMStar',
+ 'SEEDBench_IMG',
+ 'AI2D_TEST',
+ 'ScienceQA_VAL',
+ 'ScienceQA_TEST',
+ ]:
+ formatted_messages, formatted_images = self.build_prompt_puremcq(message)
+ elif listinstr(['MLVU','TempCompass','MVBench'], dataset):
+ formatted_messages, formatted_images = self.build_prompt_default(message, change_the_img_place=True)
+ else:
+ formatted_messages, formatted_images = self.build_prompt_default(message)
+
+ inputs = self._process(formatted_messages, formatted_images)
+
+ generated_ids = self.model.generate(**inputs, **self.kwargs)
+ generated_text = self.processor.batch_decode(
+ generated_ids[:, inputs['input_ids'].size(1):], skip_special_tokens=True
+ )[0]
+ response = generated_text.strip()
+ # print(dataset, " | ", formatted_messages.replace("\n", "\\n"), " | ", response.replace("\n", "\\n"))
+ return response
diff --git a/vlmeval/vlm/instructblip.py b/vlmeval/vlm/instructblip.py
new file mode 100644
index 0000000000000000000000000000000000000000..881e60224cc0d5fe199039dfff47e12401b4866a
--- /dev/null
+++ b/vlmeval/vlm/instructblip.py
@@ -0,0 +1,57 @@
+import torch
+from PIL import Image
+import os.path as osp
+import sys
+from .base import BaseModel
+from ..smp import *
+
+
+class InstructBLIP(BaseModel):
+
+ INSTALL_REQ = True
+ INTERLEAVE = False
+
+ def __init__(self, name):
+ self.config_map = {
+ 'instructblip_7b': 'misc/blip2_instruct_vicuna7b.yaml',
+ 'instructblip_13b': 'misc/blip2_instruct_vicuna13b.yaml',
+ }
+
+ self.file_path = __file__
+ config_root = osp.dirname(self.file_path)
+
+ try:
+ from lavis.models import load_preprocess
+ from omegaconf import OmegaConf
+ from lavis.common.registry import registry
+ except Exception as e:
+ logging.critical('Please install lavis before using InstructBLIP. ')
+ raise e
+
+ assert name in self.config_map
+ cfg_path = osp.join(config_root, self.config_map[name])
+ cfg = OmegaConf.load(cfg_path)
+
+ model_cfg = cfg.model
+ assert osp.exists(model_cfg.llm_model) or splitlen(model_cfg.llm_model) == 2
+ model_cls = registry.get_model_class(name='blip2_vicuna_instruct')
+ model = model_cls.from_config(model_cfg)
+ model.eval()
+
+ self.device = torch.device('cuda') if torch.cuda.is_available() else 'cpu'
+ device = self.device
+ model.to(device)
+ self.model = model
+ self.kwargs = {'max_length': 512}
+
+ preprocess_cfg = cfg.preprocess
+ vis_processors, _ = load_preprocess(preprocess_cfg)
+ self.vis_processors = vis_processors
+
+ def generate_inner(self, message, dataset=None):
+ prompt, image_path = self.message_to_promptimg(message, dataset=dataset)
+ vis_processors = self.vis_processors
+ raw_image = Image.open(image_path).convert('RGB')
+ image_tensor = vis_processors['eval'](raw_image).unsqueeze(0).to(self.device)
+ outputs = self.model.generate(dict(image=image_tensor, prompt=prompt))
+ return outputs[0]
diff --git a/vlmeval/vlm/internvl/__init__.py b/vlmeval/vlm/internvl/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f1b4cb47096ac17b4821d7d700090221a293645f
--- /dev/null
+++ b/vlmeval/vlm/internvl/__init__.py
@@ -0,0 +1,3 @@
+from .internvl_chat import InternVLChat
+
+__all__ = ['InternVLChat']
diff --git a/vlmeval/vlm/internvl/internvl_chat.py b/vlmeval/vlm/internvl/internvl_chat.py
new file mode 100644
index 0000000000000000000000000000000000000000..18308571e07a18fdfb843861e017ae0858077bf6
--- /dev/null
+++ b/vlmeval/vlm/internvl/internvl_chat.py
@@ -0,0 +1,412 @@
+import math
+import pandas as pd
+import random
+import re
+import string
+import torch
+import torch.distributed as dist
+import torchvision.transforms as T
+import transformers
+import warnings
+from PIL import Image
+from torchvision.transforms.functional import InterpolationMode
+from transformers import AutoTokenizer, AutoConfig, AutoModel, CLIPImageProcessor
+
+from .utils import (build_multi_choice_prompt,
+ build_video_prompt,
+ build_mpo_prompt,
+ build_mcq_cot_prompt,
+ build_qa_cot_prompt,
+ mpo_post_processing,
+ reorganize_prompt,
+ split_model, load_image)
+from .utils import mpo_prompt_with_final_answer, mpo_prompt_without_final_answer
+from ..base import BaseModel
+from ...dataset import DATASET_TYPE, DATASET_MODALITY
+from ...smp import *
+
+
+class InternVLChat(BaseModel):
+ INSTALL_REQ = False
+ INTERLEAVE = True
+
+ def __init__(self,
+ model_path='OpenGVLab/InternVL-Chat-V1-5',
+ load_in_8bit=False,
+ use_mpo_prompt=False,
+ version='V1.0',
+ # Best-of-N parameters
+ best_of_n=1,
+ reward_model_path=None,
+ **kwargs):
+
+ assert best_of_n >= 1
+ assert model_path is not None
+ assert version_cmp(transformers.__version__, '4.37.2', 'ge')
+
+ self.use_mpo_prompt = use_mpo_prompt
+ self.use_cot = (os.getenv('USE_COT') == '1')
+
+ self.model_path = model_path
+ self.tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True, use_fast=False)
+
+ # Regular expression to match the pattern 'Image' followed by a number, e.g. Image1
+ self.pattern = r'Image(\d+)'
+ # Replacement pattern to insert a hyphen between 'Image' and the number, e.g. Image-1
+ self.replacement = r'Image-\1'
+
+ # Convert InternVL2 response to dataset format
+ # e.g. Image1 -> Image-1
+
+ # Regular expression to match the pattern 'Image-' followed by a number
+ self.reverse_pattern = r'Image-(\d+)'
+ # Replacement pattern to remove the hyphen (Image-1 -> Image1)
+ self.reverse_replacement = r'Image\1'
+
+ if auto_split_flag():
+ device_map, visible_devices = split_model(model_path=model_path)
+ self.device = visible_devices[0]
+ self.model = AutoModel.from_pretrained(
+ model_path,
+ torch_dtype=torch.bfloat16,
+ load_in_8bit=load_in_8bit,
+ trust_remote_code=True,
+ low_cpu_mem_usage=True,
+ device_map=device_map).eval()
+ else:
+ self.model = AutoModel.from_pretrained(
+ model_path,
+ torch_dtype=torch.bfloat16,
+ load_in_8bit=load_in_8bit,
+ trust_remote_code=True,
+ low_cpu_mem_usage=True).eval().cuda()
+ self.device = 'cuda'
+
+ if best_of_n > 1:
+ assert version == 'V2.0', 'only support BoN evaluation with version==V2.0'
+ assert reward_model_path is not None
+
+ if auto_split_flag():
+ rm_device_map, visible_devices = split_model(model_path=reward_model_path)
+ rm_kwargs = {'device_map': rm_device_map}
+ else:
+ rm_kwargs = {}
+
+ self.reward_tokenizer = AutoTokenizer.from_pretrained(reward_model_path, trust_remote_code=True, use_fast=False)
+ self.reward_model = AutoModel.from_pretrained(
+ reward_model_path,
+ torch_dtype=torch.bfloat16,
+ load_in_8bit=load_in_8bit,
+ trust_remote_code=True,
+ low_cpu_mem_usage=True, **rm_kwargs).eval()
+
+ if not auto_split_flag():
+ self.reward_model = self.reward_model.to(self.device)
+
+ if not self.use_cot:
+ os.environ['USE_COT'] = '1'
+ self.use_cot = True
+ print('[Warning] Since Best-of-N is enabled, USE_COT is forced to be set to 1.')
+
+ print(f'Enable Best-of-N evaluation with PRM: {reward_model_path}')
+
+ self.image_size = self.model.config.vision_config.image_size
+ self.version = version
+ self.best_of_n = best_of_n
+ kwargs_default = dict(do_sample=False, max_new_tokens=4096, top_p=None)
+ kwargs_default.update(kwargs)
+ self.kwargs = kwargs_default
+
+ warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ')
+
+ def use_custom_prompt(self, dataset):
+ assert dataset is not None
+ if listinstr(['MMDU', 'MME-RealWorld', 'MME-RealWorld-CN', 'WeMath_COT', 'MMAlignBench'], dataset):
+ # For Multi-Turn we don't have custom prompt
+ return False
+ if DATASET_MODALITY(dataset) == 'VIDEO':
+ # For Video benchmarks we don't have custom prompt at here
+ return False
+ else:
+ return True
+
+ def build_prompt(self, line, dataset=None):
+ use_mpo_prompt = self.use_mpo_prompt and (self.use_cot or dataset in ['MMStar', 'HallusionBench', 'OCRBench'])
+
+ assert self.use_custom_prompt(dataset)
+ assert dataset is None or isinstance(dataset, str)
+ tgt_path = self.dump_image(line, dataset)
+
+ if dataset is not None and DATASET_TYPE(dataset) == 'Y/N':
+ question = line['question']
+ if listinstr(['MME'], dataset):
+ prompt = question + ' Answer the question using a single word or phrase.'
+ elif listinstr(['HallusionBench', 'AMBER'], dataset):
+ prompt = question + ' Please answer yes or no. Answer the question using a single word or phrase.'
+ else:
+ prompt = question
+ elif dataset is not None and DATASET_TYPE(dataset) == 'MCQ':
+ prompt = build_multi_choice_prompt(line, dataset)
+ if os.getenv('USE_COT') == '1':
+ prompt = build_mcq_cot_prompt(line, prompt)
+ elif dataset is not None and DATASET_TYPE(dataset) == 'VQA':
+ question = line['question']
+ if listinstr(['LLaVABench', 'WildVision'], dataset):
+ prompt = question + '\nAnswer this question in detail.'
+ elif listinstr(['OCRVQA', 'TextVQA', 'ChartQA', 'DocVQA', 'InfoVQA', 'OCRBench',
+ 'DUDE', 'SLIDEVQA', 'GQA', 'MMLongBench_DOC'], dataset):
+ prompt = question + '\nAnswer the question using a single word or phrase.'
+ elif listinstr(['MathVista', 'MathVision', 'VCR', 'MTVQA', 'MMVet', 'MathVerse',
+ 'MMDU', 'CRPE', 'MIA-Bench', 'MM-Math', 'DynaMath', 'QSpatial',
+ 'WeMath', 'LogicVista'], dataset):
+ prompt = question
+ if os.getenv('USE_COT') == '1':
+ prompt = build_qa_cot_prompt(line, prompt)
+ else:
+ prompt = question + '\nAnswer the question using a single word or phrase.'
+ else:
+ # VQA_ex_prompt: OlympiadBench, VizWiz
+ prompt = line['question']
+ if os.getenv('USE_COT') == '1':
+ prompt = build_qa_cot_prompt(line, prompt)
+
+ message = [dict(type='text', value=prompt)]
+ message.extend([dict(type='image', value=s) for s in tgt_path])
+
+ if use_mpo_prompt:
+ message = build_mpo_prompt(message, line, dataset)
+ return message
+
+ def set_max_num(self, dataset):
+ # The total limit on the number of images processed, set to avoid Out-of-Memory issues.
+ self.total_max_num = 64
+ if dataset is None:
+ self.max_num = 6
+ return None
+ res_12_datasets = ['ChartQA_TEST', 'MMMU_DEV_VAL', 'MMMU_TEST', 'MME-RealWorld',
+ 'VCR_EN', 'VCR_ZH', 'OCRVQA']
+ res_18_datasets = ['DocVQA_VAL', 'DocVQA_TEST', 'DUDE', 'MMLongBench_DOC', 'SLIDEVQA']
+ res_24_datasets = ['InfoVQA_VAL', 'InfoVQA_TEST', 'OCRBench', 'HRBench4K', 'HRBench8K']
+ if DATASET_MODALITY(dataset) == 'VIDEO':
+ self.max_num = 1
+ elif listinstr(res_12_datasets, dataset):
+ self.max_num = 12
+ elif listinstr(res_18_datasets, dataset):
+ self.max_num = 18
+ elif listinstr(res_24_datasets, dataset):
+ self.max_num = 24
+ else:
+ self.max_num = 6
+
+ def generate_v1_2(self, message, dataset=None):
+ self.INTERLEAVE = False
+ prompt, image_path = self.message_to_promptimg(message, dataset=dataset)
+ image = Image.open(image_path).convert('RGB')
+ image = image.resize((self.image_size, self.image_size))
+ image_processor = CLIPImageProcessor.from_pretrained(self.model_path)
+ pixel_values = image_processor(images=image, return_tensors='pt').pixel_values
+ pixel_values = pixel_values.to(torch.bfloat16).to(self.device)
+ with torch.no_grad():
+ response = self.model.chat(self.tokenizer, pixel_values=pixel_values,
+ question=prompt, generation_config=self.kwargs)
+ return response
+
+ def generate_v1_5(self, message, dataset=None):
+ image_num = len([x for x in message if x['type'] == 'image'])
+ max_num = max(1, min(self.max_num, self.total_max_num // image_num))
+ prompt = '\n'.join([x['value'] for x in message if x['type'] == 'text'])
+
+ if DATASET_MODALITY(dataset) == 'VIDEO':
+ prompt = build_video_prompt(prompt, dataset)
+
+ if image_num > 1:
+ image_path = [x['value'] for x in message if x['type'] == 'image']
+ pixel_values_list = []
+ for file_name in image_path:
+ pixel_values_list.append(load_image(file_name, max_num=max_num).to(self.device).to(torch.bfloat16))
+ pixel_values = torch.cat(pixel_values_list, dim=0)
+ elif image_num == 1:
+ image_path = [x['value'] for x in message if x['type'] == 'image'][0]
+ pixel_values = load_image(image_path, max_num=max_num).to(self.device).to(torch.bfloat16)
+ else:
+ pixel_values = None
+ with torch.no_grad():
+ response = self.model.chat(
+ self.tokenizer,
+ pixel_values=pixel_values,
+ question=prompt,
+ generation_config=self.kwargs,
+ verbose=True)
+ return response
+
+ @torch.no_grad()
+ def generate_v2(self, message, dataset=None):
+
+ use_mpo_prompt = self.use_mpo_prompt and (self.use_cot or dataset in ['MMStar', 'HallusionBench', 'OCRBench'])
+
+ image_num = len([x for x in message if x['type'] == 'image'])
+ max_num = max(1, min(self.max_num, self.total_max_num // image_num))
+ prompt = reorganize_prompt(message, image_num, dataset=dataset)
+
+ if dataset is not None and DATASET_MODALITY(dataset) == 'VIDEO':
+ prompt = build_video_prompt(prompt, dataset)
+
+ if image_num > 1:
+ image_path = [x['value'] for x in message if x['type'] == 'image']
+ num_patches_list, pixel_values_list = [], []
+ for image_idx, file_name in enumerate(image_path):
+ upscale_flag = image_idx == 0 and dataset is not None and listinstr(['MMMU'], dataset)
+ curr_pixel_values = load_image(
+ file_name, max_num=max_num, upscale=upscale_flag).to(self.device).to(torch.bfloat16)
+ num_patches_list.append(curr_pixel_values.size(0))
+ pixel_values_list.append(curr_pixel_values)
+ pixel_values = torch.cat(pixel_values_list, dim=0)
+ elif image_num == 1:
+ image_path = [x['value'] for x in message if x['type'] == 'image'][0]
+ upscale_flag = dataset is not None and listinstr(['MMMU'], dataset)
+ pixel_values = load_image(
+ image_path, max_num=max_num, upscale=upscale_flag).to(self.device).to(torch.bfloat16)
+ num_patches_list = [pixel_values.size(0)]
+ else:
+ pixel_values = None
+ num_patches_list = []
+
+ response_list = []
+ for idx in range(self.best_of_n):
+ kwargs_default = self.kwargs.copy()
+ kwargs_default['do_sample'] = idx > 0
+ kwargs_default['temperature'] = 0.7
+ kwargs_default['top_p'] = 0.95
+
+ response = self.model.chat(
+ self.tokenizer,
+ pixel_values=pixel_values,
+ num_patches_list=num_patches_list,
+ question=prompt,
+ generation_config=kwargs_default,
+ verbose=idx == 0,
+ )
+ response_list.append(response)
+
+ if self.best_of_n > 1:
+ response_list = self.reward_model.select_best_response(
+ tokenizer=self.reward_tokenizer,
+ question=prompt,
+ response_list=response_list,
+ pixel_values=pixel_values,
+ num_patches_list=num_patches_list,
+ )
+ response = response_list[0]
+
+ if use_mpo_prompt:
+ response = mpo_post_processing(response, dataset)
+ return response
+
+ def generate_inner(self, message, dataset=None):
+ self.set_max_num(dataset)
+ print(f'InternVL model version: {self.version}')
+ if self.version in ['V1.1', 'V1.2']:
+ return self.generate_v1_2(message, dataset)
+ elif self.version == 'V1.5':
+ return self.generate_v1_5(message, dataset)
+ elif self.version == 'V2.0':
+ return self.generate_v2(message, dataset)
+ else:
+ raise ValueError(f'Unsupported version: {self.version}')
+
+ def build_history(self, message):
+ # Global Variables
+ image_path = []
+ image_cnt = 0
+
+ def concat_tilist(tilist):
+ nonlocal image_cnt # Declare image_cnt as nonlocal to modify it
+ prompt = ''
+ for item in tilist:
+ # Substitute the pattern in the text
+ if item['type'] == 'text':
+ prompt += re.sub(self.pattern, self.replacement, item['value'])
+ elif item['type'] == 'image':
+ image_cnt += 1
+ prompt += '\n'
+ image_path.append(item['value'])
+ return prompt
+
+ # Only previous messages
+ assert len(message) % 2 == 0
+ history = []
+ for i in range(len(message) // 2):
+ m1, m2 = message[2 * i], message[2 * i + 1]
+ assert m1['role'] == 'user' and m2['role'] == 'assistant'
+ history.append((concat_tilist(m1['content']), concat_tilist(m2['content'])))
+
+ return history, image_path, image_cnt
+
+ def chat_inner_v2(self, message, dataset=None):
+
+ if len(message) > 1:
+ history, image_path, image_cnt = self.build_history(message[:-1])
+ else:
+ history, image_path, image_cnt = None, [], 1
+ current_msg = message[-1]
+ question = ''
+
+ # If message is just text in the conversation
+ if len(current_msg['content']) == 1 and current_msg['content'][0]['type'] == 'text':
+ question = current_msg['content'][0]['value']
+ question = re.sub(self.pattern, self.replacement, question) # Fix pattern as per InternVL
+ else:
+ for msg in current_msg['content']:
+ if msg['type'] == 'text':
+ question += re.sub(self.pattern, self.replacement, msg['value'])
+ elif msg['type'] == 'image':
+ image_cnt += 1
+ question += '\n'
+ image_path.append(msg['value'])
+
+ if image_cnt > 1:
+ num_patches_list = []
+ pixel_values_list = []
+ for image_idx, file_name in enumerate(image_path):
+ upscale_flag = image_idx == 0 and dataset is not None and listinstr(['MMMU_DEV_VAL'], dataset)
+ curr_pixel_values = load_image(
+ file_name, max_num=self.max_num, upscale=upscale_flag).to(self.device).to(torch.bfloat16)
+ num_patches_list.append(curr_pixel_values.size(0))
+ pixel_values_list.append(curr_pixel_values)
+ pixel_values = torch.cat(pixel_values_list, dim=0)
+ elif image_cnt == 1:
+ upscale_flag = listinstr(['MMMU_DEV_VAL'], dataset)
+ pixel_values = load_image(
+ image_path, max_num=self.max_num, upscale=upscale_flag).to(self.device).to(torch.bfloat16)
+ num_patches_list = [pixel_values.size(0)]
+ else:
+ pixel_values = None
+ num_patches_list = []
+
+ response, history = self.model.chat(
+ self.tokenizer,
+ pixel_values=pixel_values,
+ num_patches_list=num_patches_list,
+ question=question,
+ generation_config=self.kwargs,
+ history=history,
+ return_history=True
+ )
+
+ response = re.sub(self.reverse_pattern, self.reverse_replacement, response)
+
+ return response
+
+ def chat_inner(self, message, dataset=None):
+ self.set_max_num(dataset)
+
+ if self.version in ['V1.1', 'V1.2']:
+ raise ValueError(f'Unsupported version for Multi-Turn: {self.version}')
+ elif self.version == 'V1.5':
+ raise ValueError(f'Unsupported version for Multi-Turn: {self.version}')
+ elif self.version == 'V2.0':
+ kwargs_default = dict(do_sample=False, max_new_tokens=512, top_p=None, num_beams=1)
+ self.kwargs = kwargs_default
+ return self.chat_inner_v2(message, dataset)
+ else:
+ raise ValueError(f'Unsupported version for Multi-Turn: {self.version}')
diff --git a/vlmeval/vlm/internvl/utils.py b/vlmeval/vlm/internvl/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c6997601fb4bc036dd63fe5c21c04ed246a2cfa
--- /dev/null
+++ b/vlmeval/vlm/internvl/utils.py
@@ -0,0 +1,358 @@
+import math
+import pandas as pd
+import random
+import re
+import string
+import torch
+import torch.distributed as dist
+import torchvision.transforms as T
+import transformers
+import warnings
+from PIL import Image
+from torchvision.transforms.functional import InterpolationMode
+from transformers import AutoTokenizer, AutoConfig, AutoModel, CLIPImageProcessor
+
+from ..base import BaseModel
+from ...dataset import DATASET_TYPE, DATASET_MODALITY
+from ...smp import *
+
+IMAGENET_MEAN = (0.485, 0.456, 0.406)
+IMAGENET_STD = (0.229, 0.224, 0.225)
+
+
+def build_transform(input_size):
+ MEAN, STD = IMAGENET_MEAN, IMAGENET_STD
+ transform = T.Compose([
+ T.Lambda(lambda img: img.convert('RGB') if img.mode != 'RGB' else img),
+ T.Resize((input_size, input_size), interpolation=InterpolationMode.BICUBIC),
+ T.ToTensor(),
+ T.Normalize(mean=MEAN, std=STD)
+ ])
+ return transform
+
+
+def find_closest_aspect_ratio(aspect_ratio, target_ratios, width, height, image_size):
+ best_ratio_diff = float('inf')
+ best_ratio = (1, 1)
+ area = width * height
+ for ratio in target_ratios:
+ target_aspect_ratio = ratio[0] / ratio[1]
+ ratio_diff = abs(aspect_ratio - target_aspect_ratio)
+ if ratio_diff < best_ratio_diff:
+ best_ratio_diff = ratio_diff
+ best_ratio = ratio
+ elif ratio_diff == best_ratio_diff:
+ if area > 0.5 * image_size * image_size * ratio[0] * ratio[1]:
+ best_ratio = ratio
+ return best_ratio
+
+
+def dynamic_preprocess(image, min_num=1, max_num=6, image_size=448, use_thumbnail=False):
+ orig_width, orig_height = image.size
+ aspect_ratio = orig_width / orig_height
+
+ # calculate the existing image aspect ratio
+ target_ratios = set(
+ (i, j) for n in range(min_num, max_num + 1) for i in range(1, n + 1) for j in range(1, n + 1) if
+ i * j <= max_num and i * j >= min_num)
+ target_ratios = sorted(target_ratios, key=lambda x: x[0] * x[1])
+
+ # find the closest aspect ratio to the target
+ target_aspect_ratio = find_closest_aspect_ratio(
+ aspect_ratio, target_ratios, orig_width, orig_height, image_size)
+
+ # calculate the target width and height
+ target_width = image_size * target_aspect_ratio[0]
+ target_height = image_size * target_aspect_ratio[1]
+ blocks = target_aspect_ratio[0] * target_aspect_ratio[1]
+
+ # resize the image
+ resized_img = image.resize((target_width, target_height))
+ processed_images = []
+ for i in range(blocks):
+ box = (
+ (i % (target_width // image_size)) * image_size,
+ (i // (target_width // image_size)) * image_size,
+ ((i % (target_width // image_size)) + 1) * image_size,
+ ((i // (target_width // image_size)) + 1) * image_size
+ )
+ # split the image
+ split_img = resized_img.crop(box)
+ processed_images.append(split_img)
+ assert len(processed_images) == blocks
+ if use_thumbnail and len(processed_images) != 1:
+ thumbnail_img = image.resize((image_size, image_size))
+ processed_images.append(thumbnail_img)
+ return processed_images
+
+
+def load_image(image_file, input_size=448, max_num=6, upscale=False):
+ image = Image.open(image_file).convert('RGB')
+ if upscale:
+ image = image.resize((image.width * 2, image.height * 2), Image.BILINEAR)
+ transform = build_transform(input_size=input_size)
+ images = dynamic_preprocess(image, image_size=input_size, use_thumbnail=True, max_num=max_num)
+ pixel_values = [transform(image) for image in images]
+ pixel_values = torch.stack(pixel_values)
+ return pixel_values
+
+
+def get_local_rank_and_local_world_size():
+ if not dist.is_available():
+ return 0, 1
+ if not dist.is_initialized():
+ return 0, 1
+
+ if 'SLURM_LOCALID' in os.environ:
+ local_rank = int(os.environ['SLURM_LOCALID'])
+ local_world_size = int(os.environ['SLURM_NTASKS_PER_NODE'])
+ return local_rank, local_world_size
+
+ if 'LOCAL_RANK' in os.environ and 'LOCAL_WORLD_SIZE' in os.environ:
+ return int(os.environ['LOCAL_RANK']), int(os.environ['LOCAL_WORLD_SIZE'])
+
+ raise NotImplementedError(
+ "Fail to get local_rank and local_world_size! "
+ "Please ensure that you set the environment variable "
+ "`LOCAL_RANK` and `LOCAL_WORLD_SIZE`"
+ )
+
+
+def split_model(model_path):
+ num_gpus_per_node = torch.cuda.device_count()
+ rank, world_size = get_rank_and_world_size()
+ try:
+ local_rank, local_world_size = get_local_rank_and_local_world_size()
+ except:
+ local_rank = rank
+
+ if 'GPUS_PER_PROCESS' in os.environ:
+ gpus_per_process = int(os.environ['GPUS_PER_PROCESS'])
+ else:
+ gpus_per_process = 8 # default to use 8 GPUs for one model
+ gpus_per_process = min(gpus_per_process, num_gpus_per_node // local_world_size)
+ start_gpu = local_rank * gpus_per_process
+ end_gpu = start_gpu + gpus_per_process
+
+ assert end_gpu <= num_gpus_per_node, f"Process {local_rank} tries to access GPU {end_gpu}, " \
+ f"but only {num_gpus_per_node} GPUs are available per node."
+
+ visible_devices = list(range(start_gpu, end_gpu))
+
+ device_map = {}
+ config = AutoConfig.from_pretrained(model_path, trust_remote_code=True)
+
+ num_gpus_for_vit = 0.5
+ num_layers = config.llm_config.num_hidden_layers
+ num_layers_per_gpu = math.ceil(num_layers / (len(visible_devices) - num_gpus_for_vit))
+ num_layers_per_gpu = [num_layers_per_gpu] * len(visible_devices)
+ num_layers_per_gpu[0] = math.ceil(num_layers_per_gpu[0] * 0.5)
+
+ layer_cnt = 0
+ for i, num_layer in enumerate(num_layers_per_gpu):
+ for j in range(num_layer):
+ device_map[f'language_model.model.layers.{layer_cnt}'] = visible_devices[i]
+ layer_cnt += 1
+ device_map['vision_model'] = visible_devices[0]
+ device_map['mlp1'] = visible_devices[0]
+ device_map['language_model.model.tok_embeddings'] = visible_devices[0]
+ device_map['language_model.model.embed_tokens'] = visible_devices[0]
+ device_map['language_model.output'] = visible_devices[0]
+ device_map['language_model.model.norm'] = visible_devices[0]
+ device_map['language_model.model.rotary_emb'] = visible_devices[0]
+ device_map['language_model.lm_head'] = visible_devices[0]
+ device_map[f'language_model.model.layers.{num_layers - 1}'] = visible_devices[0]
+
+ return device_map, visible_devices
+
+
+def split_model_old(model_name):
+ import math
+ device_map = {}
+ num_gpus = torch.cuda.device_count()
+ rank, world_size = get_rank_and_world_size()
+ num_gpus = num_gpus // world_size
+
+ num_layers_map = {
+ 'InternVL2-8B': 32,
+ 'InternVL2-26B': 48,
+ 'InternVL2-40B': 60,
+ 'InternVL2-Llama3-76B': 80
+ }
+
+ if model_name not in num_layers_map:
+ return 'cuda'
+ num_layers = num_layers_map[model_name]
+ # Since the first GPU will be used for ViT, treat it as 0.5 GPU.
+ num_layers_per_gpu = math.ceil(num_layers / (num_gpus - 0.5))
+ num_layers_per_gpu = [num_layers_per_gpu] * num_gpus
+ num_layers_per_gpu[0] = math.ceil(num_layers_per_gpu[0] * 0.5)
+ layer_cnt = 0
+ for i, num_layer in enumerate(num_layers_per_gpu):
+ for j in range(num_layer):
+ device_map[f'language_model.model.layers.{layer_cnt}'] = rank + world_size * i
+ layer_cnt += 1
+ device_map['vision_model'] = rank
+ device_map['mlp1'] = rank
+ device_map['language_model.model.tok_embeddings'] = rank
+ device_map['language_model.model.embed_tokens'] = rank
+ device_map['language_model.output'] = rank
+ device_map['language_model.model.norm'] = rank
+ device_map['language_model.lm_head'] = rank
+ device_map['language_model.model.rotary_emb'] = rank
+ device_map[f'language_model.model.layers.{num_layers - 1}'] = rank
+ return device_map
+
+
+def build_mcq_cot_prompt(line, prompt):
+ cot_prompt = (
+ "Answer the preceding multiple choice question. The last line of your response should follow "
+ "this format: 'Answer: \\boxed{$LETTER}' (without quotes), where LETTER is one of the options. "
+ "If you are uncertain or the problem is too complex, make a reasoned guess based on the "
+ "information provided. Avoid repeating steps indefinitely—provide your best guess even if "
+ "unsure. Think step by step logically, considering all relevant information before answering."
+ )
+ prompt = prompt.replace("Answer with the option's letter from the given choices directly.", '').strip()
+ prompt = prompt + '\n' + cot_prompt
+
+ return prompt
+
+
+def build_qa_cot_prompt(line, prompt):
+ cot_prompt = (
+ "Answer the preceding question. The last line of your response should follow this format: "
+ "'Answer: \\boxed{$FINAL_ANSWER}' (without quotes), where 'FINAL_ANSWER' is your conclusion "
+ "based on the reasoning provided. If you are uncertain or the problem is too complex, make "
+ "a reasoned guess based on the information provided. Avoid repeating steps indefinitely—"
+ "provide your best guess even if unsure. Think step by step logically, considering all "
+ "relevant information before answering."
+ )
+ prompt = prompt + '\n' + cot_prompt
+
+ return prompt
+
+
+def build_multi_choice_prompt(line, dataset=None):
+ question = line['question']
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ if hint is not None:
+ question = hint + '\n' + question
+
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ for key, item in options.items():
+ question += f'\n{key}. {item}'
+ prompt = question
+
+ if len(options):
+ prompt += '\n请直接回答选项字母。' if cn_string(
+ prompt) else "\nAnswer with the option's letter from the given choices directly."
+ else:
+ prompt += '\n请直接回答问题。' if cn_string(prompt) else '\nAnswer the question directly.'
+
+ return prompt
+
+
+def build_video_prompt(prompt, dataset=None, max_frames=64):
+ for start in range(0, max_frames, 8):
+ images_to_remove = ''.join([f'' for i in range(start + 1, start + 9)])
+ prompt = prompt.replace(images_to_remove, '')
+ for i in range(max_frames):
+ prompt = prompt.replace(f'Image-{i + 1}', f'Frame-{i + 1}')
+ if listinstr(['MMBench-Video'], dataset):
+ prompt = prompt.replace('\nAnswer:', '')
+ elif listinstr(['Video-MME', 'WorldSense'], dataset):
+ prompt = prompt.replace('\nAnswer:', '')
+ prompt += "\nAnswer with the option's letter from the given choices directly."
+ elif listinstr(['MVBench'], dataset):
+ prompt = prompt.replace('Best option:(', '')
+
+ return prompt
+
+
+def reorganize_prompt(message, image_num, dataset=None):
+ if dataset is not None and listinstr(['MUIRBench'], dataset):
+ prompt = '\n'.join([x['value'] for x in message if x['type'] == 'text'])
+ images_to_remove = ' '.join([''] * image_num)
+ prompt = prompt.replace(images_to_remove, '')
+ for i in range(image_num):
+ prompt = prompt.replace('', f'', 1)
+ prompt = ''.join([f'Image-{i + 1}: \n' for i in range(image_num)]) + prompt
+ elif image_num == 1:
+ prompt = '\n' + '\n'.join([x['value'] for x in message if x['type'] == 'text'])
+ else:
+ prompt, image_idx = '', 1
+ for x in message:
+ if x['type'] == 'text':
+ prompt += x['value']
+ elif x['type'] == 'image':
+ prompt += f''
+ image_idx += 1
+ prompt = ''.join([f'Image-{i + 1}: \n' for i in range(image_num)]) + prompt
+ images_to_remove = ''.join([f'' for i in range(image_num)])
+ prompt = prompt.replace(images_to_remove, '')
+ return prompt
+
+
+mpo_prompt_with_final_answer = (
+ "Your task is to answer the question below. "
+ "Give step by step reasoning before you answer, and when you're ready to answer, "
+ "please use the format \"Final answer: ..\""
+ "\n\n"
+ "Question:"
+ "\n\n"
+ "{question}"
+)
+
+mpo_prompt_without_final_answer = (
+ "Your task is to answer the question below. "
+ "Give step by step reasoning. "
+ "\n\n"
+ "Question:"
+ "\n\n"
+ "{question}"
+)
+
+
+def mpo_post_processing(response, dataset):
+
+ def extract_answer(text):
+ match = re.search(r'(Final answer:|Answer:)\s*(.*)', text, re.IGNORECASE)
+ if match:
+ return match.group(2).strip()
+ return text
+
+ if dataset is not None and (DATASET_TYPE(dataset) in ['Y/N', 'MCQ'] or listinstr(['CRPE'], dataset)):
+ response = extract_answer(response).strip()
+ return response
+
+
+def build_mpo_prompt(message, line, dataset):
+ if listinstr(['LLaVABench', 'MMVet'], dataset):
+ return message
+
+ question_orig = line['question']
+ if listinstr(['MathVerse', 'MathVision'], dataset):
+ question_orig = question_orig.split('Question:', 1)[-1].strip()
+ question_orig = question_orig.replace('Choices:\n', '').strip()
+ if listinstr(['WeMath'], dataset):
+ question_orig = question_orig.replace('Regarding the format, please answer following the template below, and be sure to include two <> symbols:\n: <> : <>', '').strip()
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ options_prompt = ''
+ for key, item in options.items():
+ options_prompt += f'{key}. {item}\n'
+
+ if options_prompt.strip():
+ question_orig = f'{question_orig}\n{options_prompt}'
+
+ cot_prompt = mpo_prompt_with_final_answer
+ prompt = cot_prompt.format(question=question_orig).strip()
+ message[0]['value'] = prompt
+ return message
diff --git a/vlmeval/vlm/janus.py b/vlmeval/vlm/janus.py
new file mode 100644
index 0000000000000000000000000000000000000000..aeadd7fba5497b867823a1d9a1f0cebdd72e8580
--- /dev/null
+++ b/vlmeval/vlm/janus.py
@@ -0,0 +1,136 @@
+import sys
+import torch
+from transformers import AutoModelForCausalLM, AutoConfig
+import warnings
+from .base import BaseModel
+from ..smp import *
+from ..dataset import DATASET_TYPE
+
+
+class Janus(BaseModel):
+
+ INSTALL_REQ = True
+ INTERLEAVE = True
+
+ def check_install(self):
+ try:
+ import janus
+ except Exception as e:
+ logging.critical(
+ 'Please first install janus from source codes in: https://github.com/deepseek-ai/Janus')
+ raise e
+
+ def __init__(self, model_path='deepseek-ai/Janus-1.3B', **kwargs):
+ self.check_install()
+ assert model_path is not None
+ self.model_path = model_path
+ from janus.models import VLChatProcessor
+
+ self.vl_chat_processor = VLChatProcessor.from_pretrained(model_path)
+ self.tokenizer = self.vl_chat_processor.tokenizer
+
+ model = AutoModelForCausalLM.from_pretrained(model_path, trust_remote_code=True)
+ self.model = model.to(torch.bfloat16).cuda().eval()
+
+ torch.cuda.empty_cache()
+ default_kwargs = dict(
+ max_new_tokens=2048,
+ do_sample=False,
+ use_cache=True,
+ output_logits=False,
+ output_scores=False,
+ return_dict_in_generate=False)
+
+ default_kwargs.update(kwargs)
+ self.kwargs = default_kwargs
+ warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ')
+
+ def prepare_inputs(self, message):
+ def prepare_itlist(msgs):
+ content, images = '', []
+ for s in msgs:
+ if s['type'] == 'image':
+ images.append(s['value'])
+ content += ''
+ elif s['type'] == 'text':
+ content += s['value']
+ return content, images
+ conversation = []
+ if 'role' not in message[0]:
+ content, images = prepare_itlist(message)
+ conversation.append(dict(role='User', content=content, images=images))
+ else:
+ role_map = {'user': 'User', 'assistant': 'Assistant'}
+ for msgs in message:
+ role = role_map[msgs['role']]
+ content, images = prepare_itlist(msgs['content'])
+ conversation.append(dict(role=role, content=content, images=images))
+ conversation.append(dict(role='Assistant', content=''))
+ return conversation
+
+ def generate_inner(self, message, dataset=None):
+ if dataset is None or not ('MMVet' in dataset):
+ self.vl_chat_processor.system_prompt = ""
+ else:
+ self.vl_chat_processor.system_prompt = "You are a helpful assistant. Please answer truthfully and write out your thinking step by step to be sure you get the right answer." # noqa: E501
+
+ conversation = self.prepare_inputs(message)
+ from janus.utils.io import load_pil_images
+ pil_images = load_pil_images(conversation)
+ prepare_inputs = self.vl_chat_processor(conversations=conversation, images=pil_images, force_batchify=True)
+ prepare_inputs = prepare_inputs.to(self.model.device, dtype=torch.bfloat16)
+ inputs_embeds = self.model.prepare_inputs_embeds(**prepare_inputs)
+
+ outputs = self.model.language_model.generate(
+ inputs_embeds=inputs_embeds,
+ attention_mask=prepare_inputs.attention_mask,
+ pad_token_id=self.tokenizer.eos_token_id,
+ bos_token_id=self.tokenizer.bos_token_id,
+ eos_token_id=self.tokenizer.eos_token_id,
+ **self.kwargs)
+ answer = self.tokenizer.decode(outputs[0].cpu().tolist(), skip_special_tokens=True)
+ return answer
+
+ def chat_inner(self, message, dataset=None):
+ return self.generate_inner(message, dataset=dataset)
+
+ def use_custom_prompt(self, dataset):
+ assert dataset is not None
+ if DATASET_TYPE(dataset) == 'Y/N' or DATASET_TYPE(dataset) == 'MCQ' or dataset == 'MMVet':
+ return True
+ return False
+
+ def build_prompt(self, line, dataset=None):
+ assert dataset is None or isinstance(dataset, str)
+ assert self.use_custom_prompt(dataset)
+ tgt_path = self.dump_image(line, dataset)
+ question = line['question']
+ if DATASET_TYPE(dataset) == 'Y/N':
+ if dataset == 'POPE':
+ question = question.replace(" Please answer yes or no.", "")
+ prompt = '\n' + question + "\nAnswer the question using a single word or phrase."
+ elif DATASET_TYPE(dataset) == 'MCQ':
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ options_prompt = ''
+ for key, item in options.items():
+ options_prompt += f'{key}. {item}\n'
+
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ prompt = f'\nHint: {hint}\n' if hint is not None else '\n'
+ prompt += f'{question}\n'
+ prompt += (
+ f"{options_prompt}\nAnswer with the option's letter from the given choices directly."
+ if len(options) else 'Answer the question directly. '
+ )
+ elif dataset == 'MMVet':
+ prompt = '\n' + question
+ else:
+ raise NotImplementedError
+
+ message = [dict(type='image', value=s) for s in tgt_path]
+ message.extend([dict(type='text', value=prompt)])
+ return message
diff --git a/vlmeval/vlm/kosmos.py b/vlmeval/vlm/kosmos.py
new file mode 100644
index 0000000000000000000000000000000000000000..352af4a1a855a4bf370c963f9dcd143124ae5e6c
--- /dev/null
+++ b/vlmeval/vlm/kosmos.py
@@ -0,0 +1,114 @@
+import torch
+import re
+from PIL import Image
+from abc import abstractproperty
+import sys
+import os.path as osp
+from .base import BaseModel
+from ..smp import *
+from ..dataset import DATASET_TYPE
+import copy
+
+
+class Kosmos2(BaseModel):
+ INSTALL_REQ = True
+ INTERLEAVE = True
+
+ def __init__(self,
+ model_path='microsoft/kosmos-2-patch14-224',
+ **kwargs):
+ try:
+ from transformers import AutoProcessor, Kosmos2ForConditionalGeneration
+ except Exception as e:
+ logging.critical("Please install Transformers version 4.45.1 by running: pip install transformers==4.45.1")
+ raise e
+
+ assert osp.exists(model_path) or splitlen(model_path) == 2
+
+ self.model = (
+ Kosmos2ForConditionalGeneration.from_pretrained(model_path, torch_dtype=torch.float16)
+ .to(torch.device('cuda'))
+ )
+ self.processor = AutoProcessor.from_pretrained(model_path)
+
+ default_kwargs = dict(
+ max_new_tokens=512,
+ use_cache=True
+ )
+
+ default_kwargs.update(kwargs)
+ self.kwargs = default_kwargs
+ warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ')
+ torch.cuda.empty_cache()
+
+ def generate_inner(self, message, dataset=None):
+ TASK_TOKEN = ' '
+ QEUSTION_TOKEN = 'Question: '
+ ANSWER_TOKEN = 'Answer: '
+ images = []
+ prompt = ''
+
+ prompt += TASK_TOKEN
+ for s in message:
+ if s['type'] == 'image':
+ images.append(s['value'])
+ elif s['type'] == 'text':
+ prompt += QEUSTION_TOKEN
+ prompt += s['value']
+ prompt += ANSWER_TOKEN
+
+ images = [Image.open(s) for s in images]
+ inputs = self.processor(text=prompt, images=images[0], return_tensors='pt').to(torch.device('cuda'))
+
+ generated_ids = self.model.generate(
+ pixel_values=inputs['pixel_values'],
+ input_ids=inputs['input_ids'],
+ attention_mask=inputs['attention_mask'],
+ image_embeds=None,
+ image_embeds_position_mask=inputs['image_embeds_position_mask'],
+ **self.kwargs
+ )
+
+ generated_text = self.processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
+ processed_text = self.processor.post_process_generation(generated_text, cleanup_and_extract=True)[0]
+ cleaned_answer = re.sub(r'(Question:.*?Answer:|Question:.*)', '', processed_text).strip()
+ return cleaned_answer
+
+ def use_custom_prompt(self, dataset):
+ assert dataset is not None
+ if listinstr(['MMMU'], dataset):
+ return False
+ if DATASET_TYPE(dataset) == 'MCQ' or dataset == 'MMVet':
+ return True
+ return False
+
+ def build_prompt(self, line, dataset=None):
+ assert dataset is None or isinstance(dataset, str)
+ assert self.use_custom_prompt(dataset)
+ tgt_path = self.dump_image(line, dataset)
+ question = line['question']
+ if dataset == 'MMVet':
+ prompt = question + '\nAnswer the question directly. '
+ elif DATASET_TYPE(dataset) == 'MCQ':
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ options_prompt = ''
+ for key, item in options.items():
+ options_prompt += f'{key}. {item}\n'
+
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ prompt = f'Hint: {hint}\n' if hint is not None else ''
+ prompt += f'{question}\n'
+ prompt += (
+ f'{options_prompt}\nAnswer with the option’s letter from the given choices directly. '
+ if len(options) else 'Answer the question directly. '
+ )
+ else:
+ raise NotImplementedError
+
+ message = [dict(type='text', value=prompt)]
+ message.extend([dict(type='image', value=s) for s in tgt_path])
+ return message
diff --git a/vlmeval/vlm/llama_vision.py b/vlmeval/vlm/llama_vision.py
new file mode 100644
index 0000000000000000000000000000000000000000..3bbba986a5c9d89fe1558054e9e58d3ed0ebf016
--- /dev/null
+++ b/vlmeval/vlm/llama_vision.py
@@ -0,0 +1,206 @@
+import torch
+from PIL import Image
+import os.path as osp
+import sys
+from .base import BaseModel
+from ..smp import *
+from ..dataset import DATASET_TYPE
+
+
+class llama_vision(BaseModel):
+
+ INSTALL_REQ = False
+ INTERLEAVE = False
+
+ # This function is used to split Llama-3.2-90B
+ def split_model(self):
+ import math
+ device_map = {}
+ num_gpus = torch.cuda.device_count()
+ rank, world_size = get_rank_and_world_size()
+ num_gpus = num_gpus // world_size
+
+ num_layers = 100
+ # GPU0: -5, GPU-1: -7
+ total_cost = num_layers + 5 + 7
+
+ # Since the first GPU will be used for ViT, treat it as 0.8 GPU.
+ num_layers_per_gpu = total_cost // num_gpus
+ num_layers_per_gpu = [num_layers_per_gpu] * num_gpus
+ # The total number of GPUs might be odd
+ num_layers_per_gpu[-1] = total_cost - sum(num_layers_per_gpu[:-1])
+ num_layers_per_gpu[0] -= 5
+ num_layers_per_gpu[-1] -= 7
+
+ layer_cnt = 0
+ for i, num_layer in enumerate(num_layers_per_gpu):
+ for j in range(num_layer):
+ device_map[f'language_model.model.layers.{layer_cnt}'] = rank + world_size * i
+ layer_cnt += 1
+
+ device_map['vision_model'] = rank
+ device_map['language_model.model.embed_tokens'] = rank
+ device_map['language_model.model.rotary_emb'] = rank
+ device_map['language_model.model.norm'] = rank + world_size * (num_gpus - 1)
+ device_map['language_model.lm_head'] = rank + world_size * (num_gpus - 1)
+ device_map['multi_modal_projector'] = rank + world_size * (num_gpus - 1)
+ return device_map
+
+ def __init__(self, model_path='meta-llama/Llama-3.2-11B-Vision-Instruct', **kwargs):
+ try:
+ from transformers import MllamaForConditionalGeneration, AutoProcessor
+ except Exception as e:
+ logging.critical('Please install transformers>=4.45.0 before using llama_vision.')
+ raise e
+
+ rank, world_size = get_rank_and_world_size()
+
+ if '11b' in model_path.lower() and auto_split_flag():
+ assert world_size == 1, 'We only support world_size == 1 when AUTO_SPLIT is set for Llama-3.2-11B'
+ logging.warning('Currently, we only support to split the 11B model across all GPUs.')
+ self.model = MllamaForConditionalGeneration.from_pretrained(
+ model_path,
+ torch_dtype=torch.bfloat16,
+ device_map='auto',
+ ).eval()
+ elif '90b' in model_path.lower():
+ device_map = self.split_model()
+ self.model = MllamaForConditionalGeneration.from_pretrained(
+ model_path,
+ torch_dtype=torch.bfloat16,
+ device_map=device_map,
+ ).eval()
+ else:
+ self.model = MllamaForConditionalGeneration.from_pretrained(
+ model_path,
+ torch_dtype=torch.bfloat16,
+ device_map='cpu',
+ ).cuda().eval()
+
+ self.device = 'cuda'
+ self.processor = AutoProcessor.from_pretrained(model_path)
+ if 'Instruct' in model_path or 'cot' in model_path or 'CoT' in model_path:
+ kwargs_default = dict(do_sample=True, temperature=0.6, top_p=0.9)
+ else:
+ kwargs_default = dict(do_sample=False, max_new_tokens=2048, temperature=0.0, top_p=None, num_beams=1)
+ kwargs.update(kwargs_default)
+ print(f'Following kwargs received: {kwargs}, will use as generation config. ')
+ self.kwargs = kwargs
+ self.model_name = model_path
+
+ def use_custom_prompt(self, dataset):
+ if dataset is None:
+ return False
+ if listinstr(['AI2D', 'MMMU', 'MathVista', 'ChartQA', 'DocVQA'], dataset):
+ # For Certain dataset we use custom prompt
+ return True
+ else:
+ return False
+
+ def build_prompt(self, line, dataset=None):
+ assert self.use_custom_prompt(dataset)
+ assert dataset is None or isinstance(dataset, str)
+ tgt_path = self.dump_image(line, dataset)
+ question = line['question']
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ if listinstr(['AI2D'], dataset):
+ self.kwargs['max_new_tokens'] = 400
+ for key, item in options.items():
+ question += f'\n{key}. {item}'
+ if '11B' in self.model_name:
+ prompt = (
+ f'Look at the scientific diagram carefully and answer the following question: {question}\n'
+ f'Think step by step and finally respond to the question '
+ f"with only the correct option number as \"FINAL ANSWER\"."
+ f"Let's think step by step."
+ )
+ elif '90B' in self.model_name:
+ prompt = (
+ f'Look at the scientific diagram carefully and answer the following question: {question}\n'
+ f'Respond only with the correct option digit.'
+ )
+ elif listinstr(['MMMU'], dataset):
+ self.kwargs['max_new_tokens'] = 2048
+ options = '\n'.join([f'{key}. {item}' for key, item in options.items()])
+ prompt = (
+ f'Look at the image carefully and solve the following question step-by-step. '
+ f'Question: {question} Options: {options} Indicate the correct answer at the end.'
+ )
+ for i in range(len(tgt_path)):
+ prompt = prompt.replace(f'', '')
+ elif listinstr(['MathVista'], dataset):
+ self.kwargs['max_new_tokens'] = 2048
+ prompt = f'{question}'
+ elif listinstr(['ChartQA'], dataset):
+ self.kwargs['max_new_tokens'] = 512
+ if '11B' in self.model_name:
+ prompt = (
+ f'You are provided a chart image and will be asked a question. '
+ f'You have to think through your answer and provide a step-by-step solution. '
+ f'Once you have the solution, write the final answer in at most a few words at the end '
+ f"with the phrase \"FINAL ANSWER:\". "
+ f"The question is: {question}Let's think step by step."
+ )
+ elif '90B' in self.model_name:
+ prompt = (
+ f'You are provided a chart image and will be asked a question. '
+ f'Follow these steps carefully:\n '
+ f'Step 1: Analyze the question to understand what specific data or information is being asked for. '
+ f'Focus on whether the question is asking for a specific number or category '
+ f'from the chart image.\n '
+ f'Step 2: Identify any numbers, categories, or groups mentioned in the question '
+ f'and take note of them. Focus on detecting and matching them directly to the image. \n'
+ f'Step 3: Study the image carefully and find the relevant data corresponding to the categories '
+ f'or numbers mentioned. Avoid unnecessary assumptions or calculations; '
+ f'simply read the correct data from the image.\n '
+ f'Step 4: Develop a clear plan to solve the question by locating the right data. '
+ f'Focus only on the specific category or group that matches the question. \n'
+ f'Step 5: Use step-by-step reasoning to ensure you are referencing the correct numbers '
+ f'or data points from the image, avoiding unnecessary extra steps or interpretations.\n '
+ f"Step 6: Provide the final answer, starting with \"FINAL ANSWER:\" "
+ f'and using as few words as possible, '
+ f'simply stating the number or data point requested. \n\n '
+ f"The question is: {question}Let's think step by step."
+ )
+ elif listinstr(['DocVQA'], dataset):
+ self.kwargs['max_new_tokens'] = 512
+ prompt = (
+ f'Read the text in the image carefully and answer the question '
+ f'with the text as seen exactly in the image. '
+ f'For yes/no questions, just respond Yes or No. '
+ f'If the answer is numeric, just respond with the number and nothing else. '
+ f'If the answer has multiple words, just respond with the words and absolutely nothing else. '
+ f'Never respond in a sentence or a phrase.\n Question: {question}'
+ )
+ else:
+ raise NotImplementedError(f'Dataset {dataset}) not supported.')
+
+ message = [dict(type='text', value=prompt)]
+ message.extend([dict(type='image', value=s) for s in tgt_path])
+ return message
+
+ def generate_inner(self, message, dataset=None):
+ prompt, image_path = self.message_to_promptimg(message, dataset=dataset)
+
+ image = Image.open(image_path)
+ messages = [
+ {'role': 'user', 'content': [
+ {'type': 'image'},
+ {'type': 'text', 'text': prompt}
+ ]}
+ ]
+ input_text = self.processor.apply_chat_template(messages, add_generation_prompt=True)
+ inputs = self.processor(image, input_text, return_tensors='pt').to(self.device)
+ if not self.use_custom_prompt(dataset):
+ if dataset is not None and DATASET_TYPE(dataset) in ['MCQ', 'Y/N']:
+ self.kwargs['max_new_tokens'] = 128
+ else:
+ self.kwargs['max_new_tokens'] = 512
+ if "cot" in self.model_name or "CoT" in self.model_name:
+ self.kwargs['max_new_tokens'] = 2048
+ output = self.model.generate(**inputs, **self.kwargs)
+ return self.processor.decode(output[0][inputs['input_ids'].shape[1]:]).replace('<|eot_id|>', '')
diff --git a/vlmeval/vlm/llava/__init__.py b/vlmeval/vlm/llava/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9ad9a644a262fe21e34f656d067798edcd18b522
--- /dev/null
+++ b/vlmeval/vlm/llava/__init__.py
@@ -0,0 +1,4 @@
+from .llava import LLaVA, LLaVA_Next, LLaVA_Next2, LLaVA_OneVision, LLaVA_OneVision_HF
+from .llava_xtuner import LLaVA_XTuner
+
+__all__ = ['LLaVA', 'LLaVA_Next', 'LLaVA_XTuner', 'LLaVA_Next2', 'LLaVA_OneVision', 'LLaVA_OneVision_HF']
diff --git a/vlmeval/vlm/llava/llava.py b/vlmeval/vlm/llava/llava.py
new file mode 100644
index 0000000000000000000000000000000000000000..5618e7952fc32ec4ddbe10a58ba538dd41a7c4a1
--- /dev/null
+++ b/vlmeval/vlm/llava/llava.py
@@ -0,0 +1,896 @@
+import torch
+from PIL import Image
+from abc import abstractproperty
+import sys
+import os.path as osp
+from ..base import BaseModel
+from ...smp import *
+from ...dataset import DATASET_TYPE, DATASET_MODALITY
+import copy
+import requests
+
+
+class LLaVA(BaseModel):
+
+ INSTALL_REQ = True
+ INTERLEAVE = True
+
+ def __init__(self, model_path="liuhaotian/llava_v1.5_7b", **kwargs):
+ try:
+ from llava.model.builder import load_pretrained_model
+ from llava.mm_utils import get_model_name_from_path
+ except Exception as err:
+ logging.critical(
+ "Please install llava from https://github.com/haotian-liu/LLaVA"
+ )
+ raise err
+
+ assert osp.exists(model_path) or splitlen(model_path) == 2
+ self.system_prompt = (
+ "A chat between a curious human and an artificial intelligence assistant. "
+ "The assistant gives helpful, detailed, and polite answers to the human's questions. "
+ )
+ self.stop_str = ""
+
+ if model_path == "Lin-Chen/ShareGPT4V-7B":
+ model_name = "llava-v1.5-7b"
+ elif model_path == "Lin-Chen/ShareGPT4V-13B":
+ model_name = "llava-v1.5-13b"
+ else:
+ model_name = get_model_name_from_path(model_path)
+
+ try:
+ self.tokenizer, self.model, self.image_processor, self.context_len = (
+ load_pretrained_model(
+ model_path=model_path,
+ model_base=None,
+ model_name=model_name,
+ device_map="cpu",
+ )
+ )
+ except Exception as err:
+ if "ShareGPT4V" in model_path:
+ import llava
+
+ logging.critical(
+ "Please manually remove the encoder type check in "
+ f"{llava.__path__[0]}/model/multimodal_encoder/builder.py "
+ "Line 8 to use the ShareGPT4V model. "
+ )
+ else:
+ logging.critical("Unknown error when loading LLaVA model.")
+ raise err
+
+ self.model = self.model.cuda()
+ self.conv_mode = "llava_v1"
+
+ kwargs_default = dict(
+ do_sample=False,
+ temperature=0,
+ max_new_tokens=2048,
+ top_p=None,
+ num_beams=1,
+ use_cache=True,
+ ) # noqa E501
+ kwargs_default.update(kwargs)
+ self.kwargs = kwargs_default
+ warnings.warn(
+ f"Following kwargs received: {self.kwargs}, will use as generation config. "
+ )
+
+ def use_custom_prompt(self, dataset):
+ assert dataset is not None
+ if DATASET_TYPE(dataset) == "MCQ":
+ return True
+ return False
+
+ def build_prompt(self, line, dataset=None):
+ assert self.use_custom_prompt(dataset)
+ assert dataset is None or isinstance(dataset, str)
+ tgt_path = self.dump_image(line, dataset)
+
+ question = line["question"]
+ hint = line["hint"] if ("hint" in line and not pd.isna(line["hint"])) else None
+ if hint is not None:
+ question = hint + "\n" + question
+
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ for key, item in options.items():
+ question += f"\n{key}. {item}"
+ prompt = question
+
+ if len(options):
+ prompt += (
+ "\n请直接回答选项字母。"
+ if cn_string(prompt)
+ else "\nAnswer with the option's letter from the given choices directly."
+ )
+ else:
+ prompt += (
+ "\n请直接回答问题。"
+ if cn_string(prompt)
+ else "\nAnswer the question directly."
+ )
+
+ message = [dict(type="image", value=s) for s in tgt_path]
+ message.append(dict(type="text", value=prompt))
+ return message
+
+ def concat_tilist(self, message):
+ text, images = "", []
+ for item in message:
+ if item["type"] == "text":
+ text += item["value"]
+ elif item["type"] == "image":
+ text += " "
+ images.append(item["value"])
+ return text, images
+
+ def chat_inner(self, message, dataset=None):
+ from llava.mm_utils import (
+ process_images,
+ tokenizer_image_token,
+ KeywordsStoppingCriteria,
+ )
+ from llava.constants import IMAGE_TOKEN_INDEX
+
+ prompt = self.system_prompt
+ images = []
+ for utter in message:
+ prompt += "USER: " if utter["role"] == "user" else "ASSISTANT: "
+ content, images_sub = self.concat_tilist(utter["content"])
+ prompt += content
+ images.extend(images_sub)
+ prompt += " " if utter["role"] == "user" else self.stop_str
+ assert message[-1]["role"] == "user", message
+ prompt += "ASSISTANT: "
+
+ images = [Image.open(s).convert("RGB") for s in images]
+ args = abstractproperty()
+ args.image_aspect_ratio = "pad"
+ image_tensor = process_images(images, self.image_processor, args).to(
+ "cuda", dtype=torch.float16
+ )
+
+ input_ids = (
+ tokenizer_image_token(
+ prompt, self.tokenizer, IMAGE_TOKEN_INDEX, return_tensors="pt"
+ )
+ .unsqueeze(0)
+ .cuda()
+ )
+ keywords = [self.stop_str]
+ stopping_criteria = KeywordsStoppingCriteria(
+ keywords, self.tokenizer, input_ids
+ )
+ with torch.inference_mode():
+ output_ids = self.model.generate(
+ input_ids,
+ images=image_tensor,
+ stopping_criteria=[stopping_criteria],
+ **self.kwargs,
+ )
+ output = self.tokenizer.batch_decode(output_ids, skip_special_tokens=True)[
+ 0
+ ].strip()
+ return output
+
+ def generate_inner(self, message, dataset=None):
+ from llava.mm_utils import (
+ process_images,
+ tokenizer_image_token,
+ KeywordsStoppingCriteria,
+ )
+ from llava.constants import IMAGE_TOKEN_INDEX
+
+ # Support interleave text and image
+ content, images = self.concat_tilist(message)
+
+ images = [Image.open(s).convert("RGB") for s in images]
+ args = abstractproperty()
+ args.image_aspect_ratio = "pad"
+ if images:
+ image_tensor = process_images(images, self.image_processor, args).to(
+ "cuda", dtype=torch.float16
+ )
+ else:
+ image_tensor = None
+
+ prompt = self.system_prompt + "USER: " + content + " ASSISTANT: "
+
+ input_ids = (
+ tokenizer_image_token(
+ prompt, self.tokenizer, IMAGE_TOKEN_INDEX, return_tensors="pt"
+ )
+ .unsqueeze(0)
+ .cuda()
+ )
+ keywords = [self.stop_str]
+ stopping_criteria = KeywordsStoppingCriteria(
+ keywords, self.tokenizer, input_ids
+ )
+ with torch.inference_mode():
+ output_ids = self.model.generate(
+ input_ids,
+ images=image_tensor,
+ stopping_criteria=[stopping_criteria],
+ **self.kwargs,
+ )
+
+ output = self.tokenizer.batch_decode(output_ids, skip_special_tokens=True)[
+ 0
+ ].strip()
+ return output
+
+
+class LLaVA_Next(BaseModel):
+
+ INSTALL_REQ = False
+ INTERLEAVE = True
+
+ def __init__(self, model_path="llava-hf/llava-v1.6-vicuna-7b-hf", **kwargs):
+ import transformers
+ from transformers import (
+ LlavaNextProcessor,
+ LlavaNextForConditionalGeneration,
+ AutoProcessor,
+ LlavaForConditionalGeneration,
+ )
+
+ self.model_path = model_path
+ if "34b" in model_path.lower():
+ self.processor = LlavaNextProcessor.from_pretrained(
+ self.model_path, use_fast=False
+ )
+ elif "interleave" in model_path.lower():
+ self.processor = AutoProcessor.from_pretrained(self.model_path)
+ else:
+ self.processor = LlavaNextProcessor.from_pretrained(self.model_path)
+ flash_attn_flag = False
+ try:
+ import flash_attn
+
+ flash_attn_flag = True
+ except ImportError:
+ pass
+
+ if flash_attn_flag:
+ if "interleave" in model_path.lower():
+ model = LlavaForConditionalGeneration.from_pretrained(
+ self.model_path,
+ torch_dtype=torch.float16,
+ low_cpu_mem_usage=True,
+ use_flash_attention_2=True,
+ )
+ else:
+ model = LlavaNextForConditionalGeneration.from_pretrained(
+ self.model_path,
+ torch_dtype=torch.float16,
+ low_cpu_mem_usage=True,
+ use_flash_attention_2=True,
+ )
+ else:
+ if "interleave" in model_path.lower():
+ model = LlavaForConditionalGeneration.from_pretrained(
+ self.model_path, torch_dtype=torch.float16, low_cpu_mem_usage=True
+ )
+ else:
+ model = LlavaNextForConditionalGeneration.from_pretrained(
+ self.model_path, torch_dtype=torch.float16, low_cpu_mem_usage=True
+ )
+
+ model = model.eval()
+ self.model = model.cuda()
+ kwargs_default = dict(
+ do_sample=False, temperature=0, max_new_tokens=2048, top_p=None, num_beams=1
+ )
+ kwargs_default.update(kwargs)
+ self.kwargs = kwargs_default
+ warnings.warn(
+ f"Following kwargs received: {self.kwargs}, will use as generation config. "
+ )
+
+ def apply_prompt_template(self, prompt):
+ model_path = self.model_path.lower()
+ if "mistral" in model_path:
+ template = "[INST] PLACEHOLDER [/INST]"
+ elif "vicuna" in model_path:
+ template = (
+ "A chat between a curious human and an artificial intelligence assistant. "
+ "The assistant gives helpful, detailed, and polite answers to the human's questions. "
+ "USER: PLACEHOLDER ASSISTANT:"
+ )
+ elif "34b" in model_path:
+ template = (
+ "<|im_start|>system\nAnswer the questions.<|im_end|><|im_start|>user\nPLACEHOLDER<|im_end|>"
+ "<|im_start|>assistant\n"
+ )
+ else:
+ raise NotImplementedError(
+ f"Prompt template for {model_path} not implemented."
+ )
+
+ prompt = template.replace("PLACEHOLDER", f"\n{prompt}")
+ return prompt
+
+ def output_process(self, answer):
+ if "" in answer:
+ answer = answer.replace("", "").strip()
+ if "[/INST]" in answer:
+ answer = answer.split("[/INST]")[1].strip()
+ elif "ASSISTANT:" in answer:
+ answer = answer.split("ASSISTANT:")[1].strip()
+ elif "assistant\n" in answer:
+ answer = answer.split("assistant\n")[1].strip()
+ elif "<|end_header_id|>\n\n" in answer:
+ answer = answer.split("<|end_header_id|>\n\n")[2].strip()
+
+ if " " in answer:
+ answer = answer.split(" ")[0].strip()
+ elif "<|im_end|>" in answer:
+ answer = answer.split("<|im_end|>")[0].strip()
+ elif "<|eot_id|>" in answer:
+ answer = answer.split("<|eot_id|>")[0].strip()
+ return answer
+
+ def use_custom_prompt(self, dataset):
+ assert dataset is not None
+ if DATASET_TYPE(dataset) == "MCQ":
+ return True
+ return False
+
+ def build_prompt(self, line, dataset=None):
+ assert self.use_custom_prompt(dataset)
+ assert dataset is None or isinstance(dataset, str)
+ tgt_path = self.dump_image(line, dataset)
+
+ question = line["question"]
+ hint = line["hint"] if ("hint" in line and not pd.isna(line["hint"])) else None
+ if hint is not None:
+ question = hint + "\n" + question
+
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ for key, item in options.items():
+ question += f"\n{key}. {item}"
+ prompt = question
+
+ if len(options):
+ prompt += (
+ "\n请直接回答选项字母。"
+ if cn_string(prompt)
+ else "\nAnswer with the option's letter from the given choices directly."
+ )
+ else:
+ prompt += (
+ "\n请直接回答问题。"
+ if cn_string(prompt)
+ else "\nAnswer the question directly."
+ )
+ message = [dict(type="image", value=s) for s in tgt_path]
+ message.append(dict(type="text", value=prompt))
+ return message
+
+ def generate_inner(self, message, dataset=None):
+ content, images = [], []
+ for msg in message:
+ if msg["type"] == "text":
+ content.append({"type": msg["type"], "text": msg["value"]})
+ else:
+ content.append({"type": "image"})
+ images.append(Image.open(msg["value"]).convert("RGB"))
+ conversation = [
+ {
+ "role": "user",
+ "content": content,
+ }
+ ]
+ prompt = self.processor.apply_chat_template(
+ conversation, add_generation_prompt=True
+ )
+ inputs = self.processor(prompt, images, return_tensors="pt").to(
+ "cuda", torch.float16
+ )
+ output = self.model.generate(**inputs, **self.kwargs)
+ answer = self.processor.decode(output[0], skip_special_token=True)
+ answer = self.output_process(answer)
+ return answer
+
+
+class LLaVA_Next2(BaseModel):
+ INSTALL_REQ = True
+ INTERLEAVE = True
+
+ DEFAULT_IMAGE_TOKEN = ""
+ IMAGE_TOKEN_INDEX = -200
+
+ def __init__(self, model_path="lmms-lab/llama3-llava-next-8b", **kwargs):
+ assert model_path is not None
+ try:
+ from llava.model.builder import load_pretrained_model
+ from llava.conversation import conv_templates, SeparatorStyle
+ from llava.mm_utils import (
+ get_model_name_from_path,
+ tokenizer_image_token,
+ KeywordsStoppingCriteria,
+ )
+ except Exception as err:
+ logging.critical(
+ "Please `pip install git+https://github.com/LLaVA-VL/LLaVA-NeXT.git`"
+ )
+ raise err
+
+ model_name = get_model_name_from_path(model_path)
+ tokenizer, model, image_processor, _ = load_pretrained_model(
+ model_path, None, model_name, device_map=None
+ )
+ model.cuda().eval()
+ model.tie_weights()
+
+ if "llama3" in model_path.lower():
+ conv_mode = "llava_llama_3"
+ elif "qwen" in model_path.lower():
+ conv_mode = "qwen_1_5"
+ self.conv_template = conv_mode
+ self.conv_templates = conv_templates
+ self.tokenizer = tokenizer
+ self.model = model
+ self.image_processor = image_processor
+ self.tokenizer_image_token = tokenizer_image_token
+ self.KeywordStoppingCriteria = KeywordsStoppingCriteria
+ self.SeparatorStyle = SeparatorStyle
+
+ def generate_inner(self, message, dataset=None):
+ content, images = "", []
+ for msg in message:
+ if msg["type"] == "text":
+ content += msg["value"]
+ else:
+ images.append(Image.open(msg["value"]).convert("RGB"))
+ content += self.DEFAULT_IMAGE_TOKEN + "\n"
+
+ preprocess = self.image_processor.preprocess
+ image_tokenizer = self.tokenizer_image_token
+ image_tensor = [
+ preprocess(f, return_tensors="pt")["pixel_values"][0].half().cuda()
+ for f in images
+ ]
+ image_tensor = torch.stack(image_tensor)
+
+ conv = copy.deepcopy(self.conv_templates[self.conv_template])
+ conv.append_message(conv.roles[0], content)
+ conv.append_message(conv.roles[1], None)
+ prompt_question = conv.get_prompt()
+
+ input_ids = image_tokenizer(
+ prompt_question, self.tokenizer, self.IMAGE_TOKEN_INDEX, return_tensors="pt"
+ )
+ input_ids = input_ids.unsqueeze(0).cuda()
+
+ stop_str = conv.sep if conv.sep_style != self.SeparatorStyle.TWO else conv.sep2
+ keywords = [stop_str]
+ stopping_criteria = self.KeywordStoppingCriteria(
+ keywords, self.tokenizer, input_ids
+ )
+
+ cont = self.model.generate(
+ input_ids,
+ images=image_tensor,
+ do_sample=False,
+ temperature=0,
+ max_new_tokens=2048,
+ stopping_criteria=[stopping_criteria],
+ )
+ text_outputs = self.tokenizer.batch_decode(cont, skip_special_tokens=True)[0]
+ return text_outputs
+
+
+class LLaVA_OneVision(BaseModel):
+ INSTALL_REQ = True
+ INTERLEAVE = True
+ VIDEO_LLM = True
+ DEFAULT_IMAGE_TOKEN = ""
+ IMAGE_TOKEN_INDEX = -200
+
+ # This function is used to split InternVL2-Llama3-76B
+ def split_model(self, model_path):
+ import math
+
+ device_map = {}
+ num_gpus = torch.cuda.device_count()
+ rank, world_size = get_rank_and_world_size()
+ num_gpus = num_gpus // world_size
+ if "72b" not in model_path.lower():
+ return None
+ # embed_tokens, vision_tower, mm_projector, lm_head are treated as 2 layers
+ num_layers = 80 + 8
+ num_layers_per_gpu = math.ceil(num_layers / num_gpus)
+ num_layers_per_gpu = [num_layers_per_gpu] * num_gpus
+ num_layers_per_gpu[0] -= 6
+ num_layers_per_gpu[-1] -= 2
+ layer_cnt = 0
+ for i, num_layer in enumerate(num_layers_per_gpu):
+ for j in range(num_layer):
+ device_map[f"model.layers.{layer_cnt}"] = rank + world_size * i
+ layer_cnt += 1
+ last_gpu = rank + world_size * (num_gpus - 1)
+ device_map["model.image_newline"] = rank
+ device_map["model.embed_tokens"] = rank
+ device_map["model.norm"] = rank
+ device_map["model.vision_tower"] = rank
+ device_map["model.vision_resampler"] = rank
+ device_map["model.mm_projector"] = rank
+ device_map["lm_head"] = last_gpu
+ return device_map
+
+ def __init__(self, model_path="lmms-lab/llava-onevision-qwen2-7b-si", **kwargs):
+ assert model_path is not None
+ try:
+ from llava.model.builder import load_pretrained_model
+ from llava.conversation import conv_templates, SeparatorStyle
+ from llava.mm_utils import (
+ get_model_name_from_path,
+ process_images,
+ tokenizer_image_token,
+ KeywordsStoppingCriteria,
+ ) # noqa: E501
+ except Exception as err:
+ logging.critical(
+ "Please `pip install git+https://github.com/LLaVA-VL/LLaVA-NeXT.git`"
+ )
+ raise err
+
+ video_kwargs_default = dict(
+ overwrite=True, mm_spatial_pool_mode="average", force_sample=True
+ )
+ video_kwargs_default.update(kwargs)
+ self.video_kwargs = video_kwargs_default
+
+ overwrite_config = None
+ if "video" in model_path.lower():
+ if self.video_kwargs["overwrite"]:
+ overwrite_config = {}
+ overwrite_config["mm_spatial_pool_mode"] = self.video_kwargs[
+ "mm_spatial_pool_mode"
+ ]
+
+ rank, world_size = get_rank_and_world_size()
+ model_name = get_model_name_from_path(model_path)
+ device_map = self.split_model(model_path)
+
+ if device_map is None:
+ if auto_split_flag():
+ assert world_size == 1, 'Only support world_size == 1 when AUTO_SPLIT set for non-72B LLaVA-OneVision'
+ logging.warning('Currently, we only support to split the non-72B model across all GPUs.')
+ tokenizer, model, image_processor, _ = load_pretrained_model(
+ model_path,
+ None,
+ model_name,
+ device_map="auto",
+ overwrite_config=overwrite_config,
+ )
+ else:
+ tokenizer, model, image_processor, _ = load_pretrained_model(
+ model_path,
+ None,
+ model_name,
+ device_map="cpu",
+ overwrite_config=overwrite_config,
+ )
+ model.cuda()
+ else:
+ tokenizer, model, image_processor, _ = load_pretrained_model(
+ model_path,
+ None,
+ model_name,
+ device_map=device_map,
+ overwrite_config=overwrite_config,
+ )
+ model.eval()
+ model.tie_weights()
+
+ if "llava" in model_path.lower():
+ conv_mode = "qwen_1_5"
+ if 'llava-video' in model_path.lower():
+ self.nframe = 64
+ else:
+ self.nframe = 16
+ if "72b" in model_path.lower():
+ self.nframe = 32
+
+ if "video" in model_path.lower():
+ self.force_sample = self.video_kwargs["force_sample"]
+ else:
+ self.force_sample = False
+
+ self.conv_template = conv_mode
+ self.conv_templates = conv_templates
+ self.tokenizer = tokenizer
+ self.model = model
+ self.image_processor = image_processor
+ self.tokenizer_image_token = tokenizer_image_token
+ self.process_images = (
+ process_images # Store process_images as a class attribute
+ )
+ self.KeywordStoppingCriteria = KeywordsStoppingCriteria
+ self.SeparatorStyle = SeparatorStyle
+
+ def generate_inner_image(self, message, dataset=None):
+ content, images = "", []
+ image_sizes = [] # Store image sizes
+
+ for msg in message:
+ if msg["type"] == "text":
+ content += msg["value"]
+ else:
+ img = Image.open(msg["value"]).convert("RGB")
+ images.append(img)
+ image_sizes.append(img.size) # Store the size of each image
+ content += self.DEFAULT_IMAGE_TOKEN + "\n"
+
+ # Process images using the class attribute self.process_images
+ image_tensor = self.process_images(
+ images, self.image_processor, self.model.config
+ )
+ image_tensor = [
+ _image.to(dtype=torch.float16, device="cuda") for _image in image_tensor
+ ]
+
+ conv = copy.deepcopy(self.conv_templates[self.conv_template])
+ conv.append_message(conv.roles[0], content)
+ conv.append_message(conv.roles[1], None)
+ prompt_question = conv.get_prompt()
+
+ input_ids = self.tokenizer_image_token(
+ prompt_question, self.tokenizer, self.IMAGE_TOKEN_INDEX, return_tensors="pt"
+ )
+ input_ids = input_ids.unsqueeze(0).cuda()
+
+ stop_str = conv.sep if conv.sep_style != self.SeparatorStyle.TWO else conv.sep2
+ keywords = [stop_str]
+ stopping_criteria = self.KeywordStoppingCriteria(
+ keywords, self.tokenizer, input_ids
+ )
+
+ # Pass image sizes along with other parameters
+ cont = self.model.generate(
+ input_ids,
+ images=image_tensor,
+ image_sizes=image_sizes, # Pass the image sizes here
+ do_sample=False,
+ temperature=0,
+ max_new_tokens=2048,
+ stopping_criteria=[stopping_criteria],
+ )
+ text_outputs = self.tokenizer.batch_decode(cont, skip_special_tokens=True)[0]
+ return text_outputs
+
+ def generate_inner_video(self, message, dataset=None):
+ content, text_content, visual_content, videos = "", "", "", []
+
+ for msg in message:
+ if msg["type"] == "text":
+ text_content += msg["value"]
+ else:
+ videos.append(msg["value"])
+ visual_content += self.DEFAULT_IMAGE_TOKEN + "\n"
+
+ if len(videos) > 1:
+ raise ValueError(
+ "LLaVA-OneVision does not support multiple videos as input."
+ )
+
+ video_frames, frame_time, video_time = self.load_video(
+ videos[0], self.nframe, 1, self.force_sample
+ )
+
+ time_instruciton = (
+ f"The video lasts for {video_time:.2f} seconds,"
+ f"and {len(video_frames[0])} frames are uniformly sampled from it."
+ f"These frames are located at {frame_time}."
+ f"Please answer the following questions related to this video.\n"
+ )
+
+ if self.force_sample:
+ content = visual_content + time_instruciton + text_content
+ else:
+ content = visual_content + text_content
+
+ image_tensors = []
+ frames = (
+ self.image_processor.preprocess(video_frames, return_tensors="pt")[
+ "pixel_values"
+ ]
+ .half()
+ .cuda()
+ )
+ image_tensors.append(frames)
+
+ conv = copy.deepcopy(self.conv_templates[self.conv_template])
+ conv.append_message(conv.roles[0], content)
+ conv.append_message(conv.roles[1], None)
+ prompt_question = conv.get_prompt()
+
+ input_ids = self.tokenizer_image_token(
+ prompt_question, self.tokenizer, self.IMAGE_TOKEN_INDEX, return_tensors="pt"
+ )
+ input_ids = input_ids.unsqueeze(0).cuda()
+ image_sizes = [frame.size for frame in video_frames]
+ modalities = ["video"] * len(video_frames)
+
+ stop_str = conv.sep if conv.sep_style != self.SeparatorStyle.TWO else conv.sep2
+ keywords = [stop_str]
+ stopping_criteria = self.KeywordStoppingCriteria(
+ keywords, self.tokenizer, input_ids
+ )
+
+ # Pass image sizes along with other parameters
+ cont = self.model.generate(
+ input_ids,
+ images=image_tensors,
+ image_sizes=image_sizes, # Pass the image sizes here
+ do_sample=False,
+ temperature=0,
+ max_new_tokens=2048,
+ modalities=modalities,
+ stopping_criteria=[stopping_criteria],
+ )
+ text_outputs = self.tokenizer.batch_decode(cont, skip_special_tokens=True)[0]
+ return text_outputs
+
+ def load_video(self, video_path, max_frames_num, force_sample=False, fps=1):
+ from decord import VideoReader, cpu
+ import numpy as np
+
+ if max_frames_num == 0:
+ return np.zeros((1, 336, 336, 3))
+ vr = VideoReader(video_path, ctx=cpu(0), num_threads=1)
+ total_frame_num = len(vr)
+ video_time = total_frame_num / vr.get_avg_fps()
+ fps = round(vr.get_avg_fps() / fps)
+ frame_idx = [i for i in range(0, len(vr), fps)]
+ frame_time = [i / fps for i in frame_idx]
+ if len(frame_idx) > max_frames_num or force_sample:
+ sample_fps = max_frames_num
+ uniform_sampled_frames = np.linspace(
+ 0, total_frame_num - 1, sample_fps, dtype=int
+ )
+ frame_idx = uniform_sampled_frames.tolist()
+ frame_time = [i / vr.get_avg_fps() for i in frame_idx]
+ frame_time = ",".join([f"{i:.2f}s" for i in frame_time])
+ spare_frames = vr.get_batch(frame_idx).asnumpy()
+ # import pdb;pdb.set_trace()
+ return spare_frames, frame_time, video_time
+
+ def generate_inner(self, message, dataset=None):
+ if DATASET_MODALITY(dataset) == 'VIDEO':
+ return self.generate_inner_video(message, dataset)
+ else:
+ return self.generate_inner_image(message, dataset)
+
+
+class LLaVA_OneVision_HF(BaseModel):
+ INSTALL_REQ = True
+ INTERLEAVE = True
+ VIDEO_LLM = True
+ DEFAULT_IMAGE_TOKEN = ""
+ IMAGE_TOKEN_INDEX = -200
+
+ def __init__(self, model_path="llava-hf/llava-onevision-qwen2-0.5b-ov-hf", **kwargs):
+ from transformers import AutoProcessor, LlavaOnevisionForConditionalGeneration
+ assert model_path is not None, "Model path must be provided."
+ self.model = LlavaOnevisionForConditionalGeneration.from_pretrained(
+ model_path, torch_dtype=torch.float16, low_cpu_mem_usage=True
+ ).to('cuda')
+ self.processor = AutoProcessor.from_pretrained(model_path)
+
+ self.video_kwargs = kwargs.get("video_kwargs", {})
+ self.force_sample = self.video_kwargs.get("force_sample", False)
+ self.nframe = kwargs.get("nframe", 8)
+ self.fps = 1
+ self.model_path = model_path
+
+ def generate_inner_image(self, message, dataset=None):
+ content, images = "", []
+ image_sizes = []
+
+ for msg in message:
+ if msg["type"] == "text":
+ content += msg["value"]
+ elif msg["type"] == "image":
+ img = Image.open(msg["value"]).convert("RGB")
+ images.append(img)
+ image_sizes.append(img.size)
+ content += self.DEFAULT_IMAGE_TOKEN + "\n"
+
+ conversation = [
+ {
+ "role": "user",
+ "content": [
+ {"type": "text", "text": content},
+ ],
+ }
+ ]
+ prompt = self.processor.apply_chat_template(conversation, add_generation_prompt=True)
+ inputs = self.processor(images=images, text=prompt, return_tensors="pt").to('cuda', torch.float16)
+
+ output = self.model.generate(**inputs, max_new_tokens=2048)
+ return self.processor.decode(output[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
+
+ def generate_inner_video(self, message, dataset=None):
+ content, text_content, visual_content, videos = "", "", "", []
+
+ for msg in message:
+ if msg["type"] == "text":
+ text_content += msg["value"]
+ elif msg["type"] == "video":
+ videos.append(msg["value"])
+ visual_content += self.DEFAULT_IMAGE_TOKEN + "\n"
+
+ if len(videos) > 1:
+ raise ValueError("LLaVA-OneVision does not support multiple videos as input.")
+
+ video_frames, frame_time, video_time = self.load_video(
+ videos[0], self.nframe, fps=1, force_sample=self.force_sample
+ )
+
+ time_instruction = (
+ f"The video lasts for {video_time:.2f} seconds, "
+ f"and {len(video_frames)} frames are uniformly sampled from it. "
+ f"These frames are located at {frame_time}. "
+ f"Please answer the following questions related to this video.\n"
+ )
+
+ content = visual_content + time_instruction + text_content
+ conversation = [
+ {
+ "role": "user",
+ "content": [{"type": "text", "text": content}, {"type": "video"}],
+ }
+ ]
+ prompt = self.processor.apply_chat_template(conversation, add_generation_prompt=True)
+
+ inputs = self.processor(videos=video_frames, text=prompt, return_tensors="pt").to('cuda', torch.float16)
+ output = self.model.generate(**inputs, max_new_tokens=2048)
+ return self.processor.decode(output[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
+
+ def load_video(self, video_path, max_frames_num, fps=1, force_sample=False):
+ from decord import VideoReader, cpu
+ import numpy as np
+
+ vr = VideoReader(video_path, ctx=cpu(0), num_threads=1)
+ total_frame_num = len(vr)
+ avg_fps = vr.get_avg_fps()
+
+ if avg_fps == 0:
+ raise ValueError(f"Video '{video_path}' has an average FPS of 0, which is invalid.")
+ if fps <= 0:
+ raise ValueError("FPS argument must be greater than 0.")
+
+ effective_fps = round(avg_fps / fps)
+ frame_idx = list(range(0, total_frame_num, effective_fps))
+ frame_time = [i / avg_fps for i in frame_idx]
+
+ if len(frame_idx) > max_frames_num or force_sample:
+ uniform_sampled_frames = np.linspace(0, total_frame_num - 1, max_frames_num, dtype=int)
+ frame_idx = uniform_sampled_frames.tolist()
+ frame_time = [i / avg_fps for i in frame_idx]
+
+ frame_time_str = ", ".join([f"{t:.2f}s" for t in frame_time])
+ video_frames = vr.get_batch(frame_idx).asnumpy()
+ video_time = total_frame_num / avg_fps
+
+ return video_frames, frame_time_str, video_time
+
+ def generate_inner(self, message, dataset=None):
+ if DATASET_MODALITY(dataset) == "VIDEO":
+ return self.generate_inner_video(message, dataset)
+ else:
+ return self.generate_inner_image(message, dataset)
diff --git a/vlmeval/vlm/llava/llava_xtuner.py b/vlmeval/vlm/llava/llava_xtuner.py
new file mode 100644
index 0000000000000000000000000000000000000000..f08033c80dc2c57a78cad339ccbaf8a3c36b5979
--- /dev/null
+++ b/vlmeval/vlm/llava/llava_xtuner.py
@@ -0,0 +1,239 @@
+import os
+import os.path as osp
+import string
+import sys
+import warnings
+
+import pandas as pd
+import torch
+from huggingface_hub import snapshot_download
+from PIL import Image
+from transformers import (AutoModel, AutoModelForCausalLM, AutoTokenizer,
+ CLIPImageProcessor, CLIPVisionModel,
+ GenerationConfig, StoppingCriteriaList)
+
+from ..base import BaseModel
+from ...smp import *
+from ...dataset import DATASET_TYPE
+
+
+class LLaVA_XTuner(BaseModel):
+
+ INSTALL_REQ = True
+ INTERLEAVE = False
+
+ def __init__(self,
+ llava_path,
+ llm_path=None,
+ visual_encoder_path='openai/clip-vit-large-patch14-336',
+ visual_select_layer=-2,
+ prompt_template=None,
+ stop_words=[],
+ torch_dtype=torch.float16):
+ try:
+ from peft import PeftModel
+ from xtuner.utils import PROMPT_TEMPLATE, StopWordStoppingCriteria
+ except Exception as err:
+ logging.critical(
+ 'Please install xtuner with `pip install -U xtuner` before '
+ 'using LLaVA_XTuner')
+ raise err
+
+ if not osp.isdir(llava_path):
+ cache_path = get_cache_path(llava_path)
+ if cache_path is not None:
+ llava_path = cache_path
+ else:
+ llava_path = snapshot_download(repo_id=llava_path)
+ assert osp.exists(llava_path) and osp.isdir(llava_path)
+
+ # build visual_encoder
+ if 'llm' in os.listdir(llava_path):
+ assert llm_path is None, (
+ "Please don't specify the `llm_path` since passed "
+ '`llava_path` contains a LLM!')
+ llm_path = osp.join(llava_path, 'llm')
+ else:
+ assert llm_path is not None, 'Please specify the `llm_path`!'
+
+ llm = AutoModelForCausalLM.from_pretrained(llm_path,
+ trust_remote_code=True,
+ torch_dtype=torch_dtype,
+ device_map='cpu')
+ tokenizer = AutoTokenizer.from_pretrained(llm_path,
+ trust_remote_code=True,
+ encode_special_tokens=True)
+ print(f'Load LLM from {llm_path}')
+
+ # build visual_encoder
+ if 'visual_encoder' in os.listdir(llava_path):
+ assert visual_encoder_path is None, (
+ "Please don't specify the `visual_encoder_path` since passed "
+ '`llava_path` contains a visual encoder!')
+ visual_encoder_path = osp.join(llava_path, 'visual_encoder')
+ else:
+ assert visual_encoder_path is not None, (
+ 'Please specify the `visual_encoder_path`!')
+ visual_encoder = CLIPVisionModel.from_pretrained(
+ visual_encoder_path, torch_dtype=torch_dtype, device_map='cpu')
+ image_processor = CLIPImageProcessor.from_pretrained(
+ visual_encoder_path)
+ print(f'Load visual_encoder from {visual_encoder_path}')
+
+ # load adapter
+ if 'llm_adapter' in os.listdir(llava_path):
+ adapter_path = osp.join(llava_path, 'llm_adapter')
+ llm = PeftModel.from_pretrained(llm,
+ adapter_path,
+ trust_remote_code=True,
+ device_map='cpu')
+ print(f'Load LLM adapter from {llava_path}')
+ if 'visual_encoder_adapter' in os.listdir(llava_path):
+ adapter_path = osp.join(llava_path, 'visual_encoder_adapter')
+ visual_encoder = PeftModel.from_pretrained(visual_encoder,
+ adapter_path,
+ trust_remote_code=True,
+ device_map='cpu')
+ print(f'Load visual_encoder adapter from {llava_path}')
+
+ # build projector
+ projector_path = osp.join(llava_path, 'projector')
+ projector = AutoModel.from_pretrained(projector_path,
+ trust_remote_code=True,
+ torch_dtype=torch_dtype,
+ device_map='cpu')
+ print(f'Load projector from {llava_path}')
+
+ llm.eval()
+ visual_encoder.eval()
+ projector.eval()
+
+ self.llm = llm.cuda()
+ self.tokenizer = tokenizer
+ self.visual_encoder = visual_encoder.cuda()
+ self.image_processor = image_processor
+ self.projector = projector.cuda()
+ self.visual_select_layer = visual_select_layer
+ if prompt_template is not None:
+ # modified prompt template
+ if prompt_template == 'llama3_chat':
+ self.prompt_template = dict(
+ SYSTEM=('<|start_header_id|>system<|end_header_id|>\n\n'
+ '{system}<|eot_id|>'),
+ INSTRUCTION=(
+ '<|start_header_id|>user<|end_header_id|>\n\n{input}<|eot_id|>'
+ '<|start_header_id|>assistant<|end_header_id|>\n\n'),
+ SUFFIX='<|eot_id|>',
+ SUFFIX_AS_EOS=True,
+ STOP_WORDS=['<|eot_id|>'])
+ else:
+ self.prompt_template = PROMPT_TEMPLATE[prompt_template]
+ stop_words += self.prompt_template.get('STOP_WORDS', [])
+ else:
+ self.prompt_template = None
+
+ self.stop_criteria = StoppingCriteriaList()
+ for word in stop_words:
+ self.stop_criteria.append(
+ StopWordStoppingCriteria(self.tokenizer, word))
+
+ def build_gen_config(self, dataset):
+ gen_kwargs = dict(max_new_tokens=512,
+ do_sample=True,
+ temperature=1,
+ num_beams=5,
+ eos_token_id=self.tokenizer.eos_token_id,
+ pad_token_id=self.tokenizer.pad_token_id
+ if self.tokenizer.pad_token_id is not None else
+ self.tokenizer.eos_token_id)
+ # For single word generation
+ if (dataset is not None
+ and DATASET_TYPE(dataset) in ['MCQ', 'Y/N']):
+ gen_kwargs.update(
+ dict(max_new_tokens=5, do_sample=False, num_beams=1))
+ return GenerationConfig(**gen_kwargs)
+
+ def use_custom_prompt(self, dataset):
+ assert dataset is not None
+ if DATASET_TYPE(dataset) == 'MCQ':
+ return True
+ return False
+
+ def build_prompt(self, line, dataset=None):
+ assert self.use_custom_prompt(dataset)
+ assert dataset is None or isinstance(dataset, str)
+ tgt_path = self.dump_image(line, dataset)
+
+ question = line['question']
+ hint = line['hint'] if ('hint' in line
+ and not pd.isna(line['hint'])) else None
+ if hint is not None:
+ question = hint + '\n' + question
+
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ for key, item in options.items():
+ question += f'\n{key}. {item}'
+
+ if not cn_string(question):
+ prompt = question + '\n' + ("Answer with the option's letter "
+ 'from the given choices directly.')
+ else:
+ prompt = question + '\n' + '请直接回答选项字母。'
+
+ message = [dict(type='text', value=prompt)]
+ message.extend([dict(type='image', value=s) for s in tgt_path])
+ return message
+
+ def generate_inner(self, message, dataset=None):
+ from xtuner.dataset.utils import expand2square
+ from xtuner.model.utils import prepare_inputs_labels_for_multimodal
+ from xtuner.utils import DEFAULT_IMAGE_TOKEN, IMAGE_TOKEN_INDEX
+ prompt, image_path = self.message_to_promptimg(message, dataset=dataset)
+ prompt = prompt.replace('', '')
+ image = Image.open(image_path).convert('RGB')
+ image = expand2square(
+ image,
+ tuple(int(x * 255) for x in self.image_processor.image_mean))
+ image = self.image_processor.preprocess(
+ image, return_tensors='pt')['pixel_values'][0]
+ image = image.cuda().unsqueeze(0)
+ visual_outputs = self.visual_encoder(image, output_hidden_states=True)
+ pixel_values = self.projector(
+ visual_outputs.hidden_states[self.visual_select_layer][:, 1:])
+
+ inputs = DEFAULT_IMAGE_TOKEN + '\n' + prompt
+
+ if self.prompt_template:
+ inputs = self.prompt_template['INSTRUCTION'].format(input=inputs)
+
+ chunk_encode = []
+ for idx, chunk in enumerate(inputs.split(DEFAULT_IMAGE_TOKEN)):
+ if idx == 0:
+ cur_encode = self.tokenizer(chunk)
+ else:
+ cur_encode = self.tokenizer(chunk, add_special_tokens=False)
+ chunk_encode.append(cur_encode)
+ assert len(chunk_encode) == 2
+ ids = []
+ for idx, cur_chunk_encode in enumerate(chunk_encode):
+ ids.extend(cur_chunk_encode['input_ids'])
+ if idx != len(chunk_encode) - 1:
+ ids.append(IMAGE_TOKEN_INDEX)
+ ids = torch.tensor(ids).cuda().unsqueeze(0)
+ mm_inputs = prepare_inputs_labels_for_multimodal(
+ llm=self.llm, input_ids=ids, pixel_values=pixel_values)
+
+ gen_config = self.build_gen_config(dataset)
+ generate_output = self.llm.generate(
+ **mm_inputs,
+ generation_config=gen_config,
+ streamer=None,
+ bos_token_id=self.tokenizer.bos_token_id,
+ stopping_criteria=self.stop_criteria)
+ predict = self.tokenizer.decode(generate_output[0],
+ skip_special_tokens=True).strip()
+ return predict
diff --git a/vlmeval/vlm/long_vita.py b/vlmeval/vlm/long_vita.py
new file mode 100644
index 0000000000000000000000000000000000000000..f4771a6809da66a08d68ee6c45c3d3d4d7d3ebf0
--- /dev/null
+++ b/vlmeval/vlm/long_vita.py
@@ -0,0 +1,813 @@
+import os
+import math
+import numpy as np
+from PIL import Image
+import decord
+from ..smp import *
+from .base import BaseModel
+from ..dataset import DATASET_TYPE
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from transformers.generation import GenerationConfig
+import torch
+
+
+IMG_TAG_TOKEN = ""
+VID_TAG_TOKEN = ""
+AUD_TAG_TOKEN = ""
+
+IMG_CONTEXT_TOKEN = ''
+IMG_START_TOKEN = ''
+VID_START_TOKEN = ''
+VID_END_TOKEN = ' '
+
+PATCH_CONTEXT_TOKEN = ''
+PATCH_START_TOKEN = ''
+PATCH_END_TOKEN = ' '
+
+AUD_START_TOKEN = '<|begin_of_audio|>'
+AUD_END_TOKEN = '<|end_of_audio|>'
+
+QUAD_START_TOKEN = ''
+QUAD_END_TOKEN = ' '
+REF_START_TOKEN = '['
+REF_END_TOKEN = ']'
+BOX_START_TOKEN = ''
+BOX_END_TOKEN = ' '
+
+
+IMAGENET_DEFAULT_MEAN = [0.485, 0.456, 0.406]
+IMAGENET_DEFAULT_STD = [0.229, 0.224, 0.225]
+IMAGENET_STANDARD_MEAN = [0.5, 0.5, 0.5]
+IMAGENET_STANDARD_STD = [0.5, 0.5, 0.5]
+OPENAI_CLIP_MEAN = [0.48145466, 0.4578275, 0.40821073]
+OPENAI_CLIP_STD = [0.26862954, 0.26130258, 0.27577711]
+
+
+# Model Constants
+IGNORE_INDEX = -100
+IMAGE_TOKEN_INDEX = -200
+DEFAULT_IMAGE_TOKEN = IMG_CONTEXT_TOKEN
+DEFAULT_IMAGE_PATCH_TOKEN = PATCH_CONTEXT_TOKEN
+DEFAULT_IM_START_TOKEN = IMG_START_TOKEN
+DEFAULT_IM_END_TOKEN = IMG_END_TOKEN
+
+
+def select_best_resolution(original_size, possible_resolutions):
+ """
+ Selects the best resolution from a list of possible resolutions based on the original size.
+
+ Args:
+ original_size (tuple): The original size of the image in the format (width, height).
+ possible_resolutions (list): A list of possible resolutions in the format [(width1, height1), (width2, height2), ...].
+
+ Returns:
+ tuple: The best fit resolution in the format (width, height).
+ """
+ original_width, original_height = original_size
+ best_fit = None
+ max_effective_resolution = 0
+ min_wasted_resolution = float("inf")
+
+ for width, height in possible_resolutions:
+ # Calculate the downscaled size to keep the aspect ratio
+ scale = min(width / original_width, height / original_height)
+ downscaled_width, downscaled_height = int(original_width * scale), int(
+ original_height * scale
+ )
+
+ # Calculate effective and wasted resolutions
+ effective_resolution = min(
+ downscaled_width * downscaled_height, original_width * original_height
+ )
+ wasted_resolution = (width * height) - effective_resolution
+
+ if effective_resolution > max_effective_resolution or (
+ effective_resolution == max_effective_resolution
+ and wasted_resolution < min_wasted_resolution
+ ):
+ max_effective_resolution = effective_resolution
+ min_wasted_resolution = wasted_resolution
+ best_fit = (width, height)
+
+ return best_fit
+
+
+def resize_and_pad_image(image, target_resolution):
+ """
+ Resize and pad an image to a target resolution while maintaining aspect ratio.
+
+ Args:
+ image (PIL.Image.Image): The input image.
+ target_resolution (tuple): The target resolution (width, height) of the image.
+
+ Returns:
+ PIL.Image.Image: The resized and padded image.
+ """
+ original_width, original_height = image.size
+ target_width, target_height = target_resolution
+
+ # Determine which dimension (width or height) to fill
+ scale_w = target_width / original_width
+ scale_h = target_height / original_height
+
+ if scale_w < scale_h:
+ # Width will be filled completely
+ new_width = target_width
+ new_height = min(math.ceil(original_height * scale_w), target_height)
+ else:
+ # Height will be filled completely
+ new_height = target_height
+ new_width = min(math.ceil(original_width * scale_h), target_width)
+
+ # Resize the image
+ resized_image = image.resize((new_width, new_height))
+
+ # Create a new image with the target size and paste the resized image onto it
+ new_image = Image.new("RGB", (target_width, target_height), (0, 0, 0))
+ paste_x = (target_width - new_width) // 2
+ paste_y = (target_height - new_height) // 2
+ new_image.paste(resized_image, (paste_x, paste_y))
+
+ return new_image
+
+
+def divide_to_patches(image, patch_size):
+ """
+ Divides an image into patches of a specified size.
+
+ Args:
+ image (PIL.Image.Image): The input image.
+ patch_size (int): The size of each patch.
+
+ Returns:
+ list: A list of PIL.Image.Image objects representing the patches.
+ """
+ patches = []
+ width, height = image.size
+ for i in range(0, height, patch_size):
+ for j in range(0, width, patch_size):
+ box = (j, i, j + patch_size, i + patch_size)
+ patch = image.crop(box)
+ patches.append(patch)
+
+ return patches
+
+
+def find_closest_aspect_ratio(aspect_ratio, target_ratios, width, height, image_size):
+ best_ratio_diff = float("inf")
+ best_ratio = (1, 1)
+ area = width * height
+ for ratio in target_ratios:
+ target_aspect_ratio = ratio[0] / ratio[1]
+ ratio_diff = abs(aspect_ratio - target_aspect_ratio)
+ if ratio_diff < best_ratio_diff:
+ best_ratio_diff = ratio_diff
+ best_ratio = ratio
+ elif ratio_diff == best_ratio_diff:
+ if area > 0.5 * image_size * image_size * ratio[0] * ratio[1]:
+ best_ratio = ratio
+ return best_ratio
+
+
+def dynamic_preprocess(image, min_num=1, max_num=6, image_size=448, use_thumbnail=False):
+ orig_width, orig_height = image.size
+ aspect_ratio = orig_width / orig_height
+
+ # calculate the existing image aspect ratio
+ target_ratios = set(
+ (i, j)
+ for n in range(min_num, max_num + 1)
+ for i in range(1, n + 1)
+ for j in range(1, n + 1)
+ if i * j <= max_num and i * j >= min_num
+ )
+ target_ratios = sorted(target_ratios, key=lambda x: x[0] * x[1])
+
+ # find the closest aspect ratio to the target
+ target_aspect_ratio = find_closest_aspect_ratio(
+ aspect_ratio, target_ratios, orig_width, orig_height, image_size
+ )
+
+ # calculate the target width and height
+ target_width = image_size * target_aspect_ratio[0]
+ target_height = image_size * target_aspect_ratio[1]
+ blocks = target_aspect_ratio[0] * target_aspect_ratio[1]
+
+ # resize the image
+ resized_img = image.resize((target_width, target_height))
+ processed_images = []
+ for i in range(blocks):
+ box = (
+ (i % (target_width // image_size)) * image_size,
+ (i // (target_width // image_size)) * image_size,
+ ((i % (target_width // image_size)) + 1) * image_size,
+ ((i // (target_width // image_size)) + 1) * image_size,
+ )
+ # split the image
+ split_img = resized_img.crop(box)
+ processed_images.append(split_img)
+ assert len(processed_images) == blocks
+ if use_thumbnail and len(processed_images) != 1:
+ thumbnail_img = image.resize((image_size, image_size))
+ processed_images = [
+ thumbnail_img,
+ ] + processed_images
+ return processed_images, (target_width, target_height)
+
+
+def get_external_inputs(tokens, tokenizer, image_processor, image_list=None, image_path_list=None, video_path_list=None, max_num_frame=4096, max_fps=1, image_token_length=256):
+ tokens = tokens.tolist()
+
+ IMG_CONTEXT_ID = tokenizer(IMG_CONTEXT_TOKEN, add_special_tokens=False).input_ids
+ IMG_START_ID = tokenizer(IMG_START_TOKEN, add_special_tokens=False).input_ids
+ IMG_END_ID = tokenizer(IMG_END_TOKEN, add_special_tokens=False).input_ids
+
+ VID_CONTEXT_ID = tokenizer(VID_CONTEXT_TOKEN, add_special_tokens=False).input_ids
+ VID_START_ID = tokenizer(VID_START_TOKEN, add_special_tokens=False).input_ids
+ VID_END_ID = tokenizer(VID_END_TOKEN, add_special_tokens=False).input_ids
+
+ PATCH_CONTEXT_ID = tokenizer(PATCH_CONTEXT_TOKEN, add_special_tokens=False).input_ids
+ PATCH_START_ID = tokenizer(PATCH_START_TOKEN, add_special_tokens=False).input_ids
+ PATCH_END_ID = tokenizer(PATCH_END_TOKEN, add_special_tokens=False).input_ids
+
+ IMG_TAG_ID = tokenizer(IMG_TAG_TOKEN, add_special_tokens=False).input_ids
+ VID_TAG_ID = tokenizer(VID_TAG_TOKEN, add_special_tokens=False).input_ids
+
+ assert len(IMG_CONTEXT_ID) == 1
+ assert len(IMG_START_ID) == 1
+ assert len(IMG_END_ID) == 1
+
+ assert len(VID_CONTEXT_ID) == 1
+ assert len(VID_START_ID) == 1
+ assert len(VID_END_ID) == 1
+
+ assert len(PATCH_CONTEXT_ID) == 1
+ assert len(PATCH_START_ID) == 1
+ assert len(PATCH_END_ID) == 1
+
+ IMG_CONTEXT_ID = IMG_CONTEXT_ID[0]
+ IMG_START_ID = IMG_START_ID[0]
+ IMG_END_ID = IMG_END_ID[0]
+
+ VID_CONTEXT_ID = VID_CONTEXT_ID[0]
+ VID_START_ID = VID_START_ID[0]
+ VID_END_ID = VID_END_ID[0]
+
+ PATCH_CONTEXT_ID = PATCH_CONTEXT_ID[0]
+ PATCH_START_ID = PATCH_START_ID[0]
+ PATCH_END_ID = PATCH_END_ID[0]
+
+ IMG_TAG_ID = IMG_TAG_ID[0]
+ VID_TAG_ID = VID_TAG_ID[0]
+
+ nl_tokens = tokenizer("\n", add_special_tokens=False).input_ids
+
+ image_indices = []
+ images = []
+
+ # ----------------------------------------------------------------
+ # image
+ for batch_idx, input_ids in enumerate(tokens):
+ img_positions = [i for i, x in enumerate(input_ids) if x == IMG_TAG_ID]
+ if len(img_positions) == 0:
+ continue
+ if image_path_list is not None:
+ assert len(img_positions) == len(image_path_list), f"{img_positions} {image_path_list} {IMG_CONTEXT_TOKEN} {IMG_CONTEXT_ID} {tokens}"
+ if image_list is not None:
+ assert len(img_positions) == len(image_list), f"{img_positions} {image_list} {IMG_CONTEXT_TOKEN} {IMG_CONTEXT_ID} {tokens}"
+
+ new_input_ids = []
+ st = 0
+ for img_idx, img_pos in enumerate(img_positions):
+ if image_path_list is not None:
+ image_patches, (best_width, best_height) = image_processor.process_images_with_subpatch(image_path_list[img_idx])
+ if image_list is not None:
+ image_patches, (best_width, best_height) = image_processor.process_images_with_subpatch(image_list[img_idx])
+ images.append(image_patches)
+
+ new_input_ids += input_ids[st:img_pos]
+
+ new_input_ids += [IMG_START_ID]
+
+ image_indice_b = torch.zeros(
+ 1, image_token_length, dtype=torch.int64
+ ) # This will change in collate_fn
+ image_indice_s = (
+ torch.arange(len(new_input_ids), len(new_input_ids) + image_token_length)
+ .unsqueeze(0)
+ .repeat(1, 1)
+ )
+ image_indice_b_s = torch.stack(
+ [image_indice_b, image_indice_s], dim=0
+ ) # 2, num_image, image_length
+ image_indices.append(image_indice_b_s)
+
+ new_input_ids += [IMG_CONTEXT_ID] * image_token_length
+
+ new_input_ids += [IMG_END_ID]
+
+ if len(image_patches) > 1:
+ for i in range(0, best_height, image_processor.patch_size):
+ new_input_ids += nl_tokens
+
+ for j in range(0, best_width, image_processor.patch_size):
+ new_input_ids += [PATCH_START_ID]
+
+ image_indice_b = torch.zeros(
+ 1, image_token_length, dtype=torch.int64
+ ) # This will change in collate_fn
+ image_indice_s = (
+ torch.arange(len(new_input_ids), len(new_input_ids) + image_token_length)
+ .unsqueeze(0)
+ .repeat(1, 1)
+ )
+ image_indice_b_s = torch.stack(
+ [image_indice_b, image_indice_s], dim=0
+ ) # 2, num_image, image_length
+ image_indices.append(image_indice_b_s)
+
+ new_input_ids += [PATCH_CONTEXT_ID] * image_token_length
+
+ new_input_ids += [PATCH_END_ID]
+
+ st = img_pos + 1
+
+ new_input_ids += input_ids[st:]
+
+ input_ids = new_input_ids
+ tokens[batch_idx] = input_ids
+
+ # ----------------------------------------------------------------
+ # video
+ for batch_idx, input_ids in enumerate(tokens):
+ vid_positions = [i for i, x in enumerate(input_ids) if x == VID_TAG_ID]
+ if len(vid_positions) == 0:
+ continue
+ if video_path_list is not None:
+ assert len(vid_positions) == len(video_path_list), f"{vid_positions} {video_path_list} {VID_CONTEXT_TOKEN} {VID_CONTEXT_ID} {tokens}"
+ if image_path_list is not None:
+ assert len(vid_positions) == len(image_path_list), f"{vid_positions} {image_path_list} {VID_CONTEXT_TOKEN} {VID_CONTEXT_ID} {tokens}"
+ if image_list is not None:
+ assert len(vid_positions) == len(image_list), f"{vid_positions} {image_list} {VID_CONTEXT_TOKEN} {VID_CONTEXT_ID} {tokens}"
+
+ new_input_ids = []
+ st = 0
+ for vid_idx, vid_pos in enumerate(vid_positions):
+ if video_path_list is not None:
+ video_frames, _ = image_processor.process_video(video_path_list[vid_idx], max_num_frame, max_fps)
+ if image_path_list is not None:
+ video_frames = image_processor.process_images([image_path_list[vid_idx]])
+ if image_list is not None:
+ video_frames = image_processor.process_images([image_list[vid_idx]])
+
+ images.append(video_frames)
+
+ new_input_ids += input_ids[st:vid_pos]
+
+ for _ in video_frames:
+ new_input_ids += [VID_START_ID]
+
+ image_indice_b = torch.zeros(
+ 1, image_token_length, dtype=torch.int64
+ ) # This will change in collate_fn
+ image_indice_s = (
+ torch.arange(len(new_input_ids), len(new_input_ids) + image_token_length)
+ .unsqueeze(0)
+ .repeat(1, 1)
+ )
+ image_indice_b_s = torch.stack(
+ [image_indice_b, image_indice_s], dim=0
+ ) # 2, num_image, image_length
+ image_indices.append(image_indice_b_s)
+
+ new_input_ids += [VID_CONTEXT_ID] * image_token_length
+
+ new_input_ids += [VID_END_ID]
+
+ st = vid_pos + 1
+
+ new_input_ids += input_ids[st:]
+
+ input_ids = new_input_ids
+ tokens[batch_idx] = input_ids
+
+ images = torch.cat(images, dim=0)
+ images = torch.tensor(images, dtype=torch.bfloat16).contiguous().to(torch.cuda.current_device())
+
+ image_indices = torch.cat(image_indices, dim=1)
+ image_indices = image_indices.contiguous().to(torch.cuda.current_device())
+
+ tokens = torch.tensor(tokens, dtype=torch.long, device='cuda')
+
+ return tokens, images, image_indices
+
+
+class ImageProcessor:
+ def __init__(
+ self,
+ process_type,
+ image_size=448,
+ normalize_type="imagenet",
+ min_patch_grid=1,
+ max_patch_grid=6,
+ ):
+ self.process_type = process_type
+ self.image_size = image_size
+
+ if normalize_type == "imagenet":
+ MEAN, STD = IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD
+ elif normalize_type == "clip":
+ MEAN, STD = OPENAI_CLIP_MEAN, OPENAI_CLIP_STD
+ elif normalize_type == "siglip":
+ MEAN, STD = IMAGENET_STANDARD_MEAN, IMAGENET_STANDARD_STD
+ else:
+ raise NotImplementedError
+ self.mean = MEAN
+ self.std = STD
+
+ self.patch_size = image_size
+ self.min_patch_grid = min_patch_grid
+ self.max_patch_grid = max_patch_grid
+
+ if self.process_type == "anyres":
+ self.grid_pinpoints = [
+ (i, j)
+ for i in range(min_patch_grid, max_patch_grid + 1)
+ for j in range(min_patch_grid, max_patch_grid + 1)
+ ]
+ self.possible_resolutions = [
+ [dim * self.patch_size for dim in pair] for pair in self.grid_pinpoints
+ ]
+
+ if self.process_type == "dynamic":
+ max_num = self.max_patch_grid
+ min_num = self.min_patch_grid
+ # calculate the existing image aspect ratio
+ target_ratios = set(
+ (i, j)
+ for n in range(min_num, max_num + 1)
+ for i in range(1, n + 1)
+ for j in range(1, n + 1)
+ if i * j <= max_num and i * j >= min_num
+ )
+ self.target_ratios = sorted(target_ratios, key=lambda x: x[0] * x[1])
+ self.possible_resolutions = [
+ [dim * self.patch_size for dim in pair] for pair in self.target_ratios
+ ]
+
+ def get_frame_paths(self, frame_root, num_frames=8):
+ os.makedirs(frame_root, exist_ok=True)
+
+ self.frame_tmpl = "frame-{}-of-{}.jpg"
+ return [
+ os.path.join(frame_root, self.frame_tmpl.format(i, num_frames))
+ for i in range(1, num_frames + 1)
+ ]
+
+ def save_video_frames(self, vid_path, max_fps=1, num_frames=8):
+ vid = decord.VideoReader(vid_path, num_threads=1)
+
+ step_size = len(vid) / (num_frames + 1)
+ fps = vid.get_avg_fps()
+ step_size = max(fps / max_fps, step_size)
+
+ indices = [int(i * step_size) for i in range(0, num_frames)]
+ indices = [i for i in indices if i < len(vid)]
+
+ num_frames = len(indices)
+
+ frame_paths = self.get_frame_paths(vid_path + ".saved_frames", num_frames)
+ flag = np.all([os.path.exists(p) for p in frame_paths])
+ if flag:
+ return frame_paths
+
+ images = [vid[i].asnumpy() for i in indices]
+ images = [Image.fromarray(arr) for arr in images]
+
+ for im, pth in zip(images, frame_paths):
+ im.save(pth)
+ return frame_paths
+
+ def get_video_frames(self, vid_path, max_fps=1, num_frames=8):
+ vid = decord.VideoReader(vid_path, num_threads=1)
+
+ step_size = len(vid) / (num_frames + 1)
+ fps = vid.get_avg_fps()
+ step_size = max(fps / max_fps, step_size)
+
+ indices = [int(i * step_size) for i in range(0, num_frames)]
+ indices = [i for i in indices if i < len(vid)]
+
+ images = [vid[i].asnumpy() for i in indices]
+ images = [Image.fromarray(arr) for arr in images]
+
+ return images
+
+ def process_video(self, video_file_or_dir, max_num_frame=8, max_fps=1):
+ import natsort
+ if os.path.isdir(video_file_or_dir):
+ all_filepath = []
+ for root, dirs, files in os.walk(video_file_or_dir):
+ for filename in files:
+ if (
+ filename.endswith("png")
+ or filename.endswith("jpeg")
+ or filename.endswith("jpg")
+ ):
+ filepath = os.path.join(root, filename)
+ all_filepath.append(filepath)
+
+ if len(all_filepath) == 0:
+ return None
+
+ all_filepath = natsort.natsorted(all_filepath)
+ total_frame = len(all_filepath)
+ if "ShareGPTVideo" in video_file_or_dir:
+ fps = 2
+ else:
+ fps = 1
+ target_frame = int(min(total_frame / fps * max_fps, max_num_frame))
+ index = [int(1.0 * total_frame / target_frame) * x for x in range(target_frame)]
+
+ selected_filepath = [all_filepath[x] for x in index]
+
+ img_or_path_list = selected_filepath
+ elif os.path.isfile(video_file_or_dir):
+ img_or_path_list = self.get_video_frames(
+ video_file_or_dir, num_frames=max_num_frame, max_fps=max_fps
+ )
+ else:
+ raise NotImplementedError
+
+ return self.process_images(img_or_path_list), img_or_path_list
+
+ def process_images(self, img_or_path_list):
+ if isinstance(img_or_path_list[0], str):
+ images = [Image.open(x).convert("RGB") for x in img_or_path_list]
+ elif isinstance(img_or_path_list[0], Image.Image):
+ images = [x.convert("RGB") for x in img_or_path_list]
+ else:
+ images = img_or_path_list
+
+ def expand2square(pil_img, background_color):
+ width, height = pil_img.size
+ if width == height:
+ return pil_img
+ elif width > height:
+ result = Image.new(pil_img.mode, (width, width), background_color)
+ result.paste(pil_img, (0, (width - height) // 2))
+ return result
+ else:
+ result = Image.new(pil_img.mode, (height, height), background_color)
+ result.paste(pil_img, ((height - width) // 2, 0))
+ return result
+
+ image_tensor = torch.ones([len(images), 3, self.image_size, self.image_size])
+
+ for i, image in enumerate(images):
+ image = expand2square(image, tuple(int(x * 255) for x in self.mean))
+
+ image = image.resize(
+ (self.image_size, self.image_size), resample=Image.Resampling.BICUBIC
+ )
+
+ image = np.array(image, dtype=np.float32)
+ image = image * 1.0 / 255.0
+
+ mean = np.array(self.mean, dtype=image.dtype)
+ std = np.array(self.std, dtype=image.dtype)
+ image = (image - mean) / std
+
+ image = torch.tensor(image, dtype=torch.float32)
+ image = image.permute(2, 0, 1)
+
+ image_tensor[i] = image
+
+ return image_tensor
+
+ def process_images_with_subpatch(self, img_or_path):
+ if self.process_type == "anyres":
+ return self.process_anyres(img_or_path)
+ if self.process_type == "dynamic":
+ return self.process_dynamic(img_or_path)
+
+ if isinstance(img_or_path, str):
+ image = Image.open(img_or_path).convert("RGB")
+ elif isinstance(img_or_path, Image.Image):
+ image = img_or_path.convert("RGB")
+ else:
+ image = img_or_path
+
+ return self.process_images([image])
+
+ def process_anyres(self, img_or_path):
+ if isinstance(img_or_path, str):
+ image = Image.open(img_or_path).convert("RGB")
+ elif isinstance(img_or_path, Image.Image):
+ image = img_or_path.convert("RGB")
+ else:
+ image = img_or_path
+
+ best_resolution = select_best_resolution(image.size, self.possible_resolutions)
+ image_padded = resize_and_pad_image(image, best_resolution)
+ patches = divide_to_patches(image_padded, self.patch_size)
+
+ if best_resolution == (self.patch_size, self.patch_size):
+ image_patches = [image]
+ else:
+ image_patches = [image] + patches
+
+ image_patches = self.process_images(image_patches)
+
+ return image_patches, best_resolution
+
+ def process_dynamic(self, img_or_path):
+ if isinstance(img_or_path, str):
+ image = Image.open(img_or_path).convert("RGB")
+ elif isinstance(img_or_path, Image.Image):
+ image = img_or_path.convert("RGB")
+ else:
+ image = img_or_path
+
+ image_patches, best_resolution = dynamic_preprocess(
+ image,
+ min_num=self.min_patch_grid,
+ max_num=self.max_patch_grid,
+ image_size=self.patch_size,
+ use_thumbnail=True,
+ )
+
+ image_patches = self.process_images(image_patches)
+
+ return image_patches, best_resolution
+
+
+class LongVITAWrapper(BaseModel):
+ allowed_types = ['text', 'image', 'video']
+ is_api: bool = False
+
+ INTERLEAVE = True
+ VIDEO_LLM = True
+
+ def __init__(self, model_path='VITA-MLLM/Long-VITA-16K_HF', max_num_frame=4096, **kwargs):
+ assert model_path is not None
+
+ self.default_params = {
+ 'top_p': 0,
+ 'top_k': 0,
+ 'temperature': 1.0,
+ 'repetition_penalty': 1.0,
+ 'do_sample': False,
+ 'max_new_tokens': 1024,
+ }
+
+ chat_template = """
+ {%- for message in messages %} {%- if (message.role == "user") or (message.role == "system" and not loop.first) or (message.role == "assistant" and not message.tool_calls) %} {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>' + '\n' }} {%- elif message.role == "assistant" %} {{- '<|im_start|>' + message.role }} {%- if message.content %} {{- '\n' + message.content }} {%- endif %} {%- for tool_call in message.tool_calls %} {%- if tool_call.function is defined %} {%- set tool_call = tool_call.function %} {%- endif %} {{- '\n\n{"name": "' }} {{- tool_call.name }} {{- '", "arguments": ' }} {{- tool_call.arguments | tojson }} {{- '}\n ' }} {%- endfor %} {{- '<|im_end|>\n' }} {%- elif message.role == "tool" %} {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != "tool") %} {{- '<|im_start|>user' }} {%- endif %} {{- '\n\n' }} {{- message.content }} {{- '\n ' }} {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %} {{- '<|im_end|>\n' }} {%- endif %} {%- endif %} {%- endfor %} {%- if add_generation_prompt %} {{- '<|im_start|>assistant\n' }} {%- endif %}
+ """
+
+ tokenizer = AutoTokenizer.from_pretrained(
+ model_path,
+ trust_remote_code=True,
+ chat_template=chat_template,
+ )
+
+ model = AutoModelForCausalLM.from_pretrained(
+ model_path,
+ trust_remote_code=True,
+ device_map="auto",
+ torch_dtype=torch.bfloat16,
+ attn_implementation="flash_attention_2",
+ ).eval()
+
+ model.generation_config = GenerationConfig.from_pretrained(model_path, trust_remote_code=True)
+ model.generation_config.max_new_tokens = 1024
+ model.generation_config.chat_format = "chatml"
+ model.generation_config.max_window_size = 1310720
+ model.generation_config.do_sample = False
+ model.generation_config.use_cache = True
+ model.generation_config.pad_token_id = tokenizer.pad_token_id
+
+ image_processor = ImageProcessor(
+ process_type="dynamic",
+ image_size=448,
+ normalize_type="imagenet",
+ min_patch_grid=1,
+ max_patch_grid=12,
+ )
+
+ self.model = model
+ self.tokenizer = tokenizer
+ self.image_processor = image_processor
+
+ max_num_frame = os.environ.get('MAX_NUM_FRAME', default=max_num_frame)
+ self.max_num_frame = int(max_num_frame)
+ print(f"max_num_frame {self.max_num_frame}")
+
+ def build_msgs(self, msgs_raw, system_prompt=None, dataset=None):
+ msgs = cp.deepcopy(msgs_raw)
+ image_list = []
+ image_path_list = []
+ video_path_list = []
+ text = ""
+ image_count = 1
+ for i, msg in enumerate(msgs):
+ if msg['type'] == 'text':
+ text += msg['value']
+ elif msg['type'] == 'image':
+ image_path_list.append(msg['value'])
+ if dataset == "Video-MME":
+ if image_count == 1:
+ text += f""
+ else:
+ text += f""
+ else:
+ text += f"\n"
+ image_count += 1
+
+ elif msg['type'] == 'video':
+ video_path_list.append(msg['value'])
+ text += f""
+ else:
+ raise ValueError(f"Invalid message type: {msg['type']}, {msg}")
+
+ # VideoMME
+ text = text.replace("\nAnswer: ", "\n")
+
+ if dataset == "OCRBench":
+ text += "\nAnswer this question using the text in the image directly without any other context."
+
+ elif dataset in ['MMMU_DEV_VAL', 'MMMU_TEST', "MMStar"]:
+ text = text.replace("Please select the correct answer from the options above.", "").strip() + "\n"
+ text += "Answer with the option's letter from the given choices directly."
+
+ elif dataset in ['MVBench',]:
+ text = text.replace("Only give the best option.Best option:(", "")
+ text += "Answer with the letter."
+
+ elif dataset in ['MMVet',]:
+ pass
+
+ elif dataset in ['MathVista_MINI',]:
+ text += "\nAnswer the question using a single word or phrase."
+
+ elif dataset is not None and DATASET_TYPE(dataset) in ['Y/N',]:
+ text = text.replace("Answer the question with Yes or No.", "").strip() + "\n"
+ text += "Answer yes or no."
+
+ elif dataset is not None and DATASET_TYPE(dataset) in ['MCQ',]:
+ text = text.replace("Please select the correct answer from the options above.", "").strip() + "\n"
+ text += "Answer with the letter."
+
+ elif dataset is not None and DATASET_TYPE(dataset) in ['VQA',]:
+ pass
+
+ elif dataset is not None and DATASET_TYPE(dataset) in ['Video-MCQ',]:
+ text += "Offer a very short reply."
+
+ else:
+ text = text.replace("Answer the question using a single word or phrase.", "").strip() + "\n"
+ text += "Answer the question using a single word or phrase."
+
+ return text, image_list, image_path_list, video_path_list
+
+ def generate_inner(self, inputs, dataset=None) -> str:
+ assert isinstance(inputs, str) or isinstance(inputs, list)
+ inputs = [inputs] if isinstance(inputs, str) else inputs
+
+ print("")
+ print("-" * 100, flush=True)
+
+ message, image_list, image_path_list, video_path_list = self.build_msgs(msgs_raw=inputs, dataset=dataset)
+
+ messages = [
+ {
+ "role": "user",
+ "content": message,
+ }
+ ]
+ inputs = self.tokenizer.apply_chat_template(
+ messages,
+ tokenize=True,
+ add_generation_prompt=True,
+ return_tensors="pt",
+ ).to("cuda")
+
+ print("input", self.tokenizer.decode(inputs[0], skip_special_tokens=False), flush=True)
+
+ inputs, images, image_indices = get_external_inputs(inputs, self.tokenizer, self.image_processor, image_path_list=image_path_list if len(image_path_list) > 0 else None, video_path_list=video_path_list if len(video_path_list) > 0 else None, max_num_frame=self.max_num_frame)
+ outputs = self.model.generate(inputs=inputs, images=images, image_indices=image_indices, **self.default_params)
+ output = self.tokenizer.decode(outputs[0][len(inputs[0]):], skip_special_tokens=True)
+ print(f"output", output, flush=True)
+
+ answer = output
+
+ return answer
+
+
+class LongVITA(LongVITAWrapper):
+
+ def generate(self, message, dataset=None):
+ return super(LongVITA, self).generate(message, dataset=dataset)
diff --git a/vlmeval/vlm/mantis.py b/vlmeval/vlm/mantis.py
new file mode 100644
index 0000000000000000000000000000000000000000..04b9757898c4e5f0135c6cb6c632ac1c2bf925e9
--- /dev/null
+++ b/vlmeval/vlm/mantis.py
@@ -0,0 +1,201 @@
+import torch
+from PIL import Image
+from abc import abstractproperty
+from .base import BaseModel
+from ..smp import *
+from ..dataset import DATASET_TYPE
+import warnings
+
+
+class Mantis(BaseModel):
+ """
+ Mantis Model
+ This implementation is adpated from the Llava model from llava.py and the Idefics model from idefics.py
+ """
+ INSTALL_REQ = True
+ INTERLEAVE = True
+
+ DEFAULT_IMAGE_TOKEN = ''
+ IMAGE_TOKEN_INDEX = -200
+
+ def __init__(self, model_path='TIGER-Lab/Mantis-8B-siglip-llama3', **kwargs):
+ assert model_path is not None
+ try:
+ from mantis.models.mllava import LlavaForConditionalGeneration, MLlavaProcessor
+ from mantis.models.mfuyu import MFuyuForCausalLM, MFuyuProcessor
+ from mantis.models.conversation import conv_mllava_v1 as default_conv, conv_templates
+ except Exception as e:
+ logging.critical(
+ "Mantis is not installed. Please install Mantis to use this model.Please use 'pip install "
+ "git+https://github.com/TIGER-AI-Lab/Mantis.git' to install"
+ )
+ raise e
+
+ try:
+ from transformers import AutoModelForVision2Seq, AutoProcessor
+ except Exception as e:
+ logging.critical(f'{type(e)}: {e}')
+ logging.critical("Upgrade transformers to use Mantis's idefics model.\nError: %s" % e)
+
+ # inference implementation for attention, can be "sdpa", "eager", "flash_attention_2".
+ # Seems FA2 is not effective during inference:
+ # https://discuss.huggingface.co/t/flash-attention-has-no-effect-on-inference/73453/5
+ # if is_flash_attn_2_available:
+ # best_fit_attn_implementation = "flash_attention_2"
+ # flash_attn has a bug that says: ERROR Error query and key must have the same dtype in generating
+
+ try:
+ import flash_attn
+ best_fit_attn_implementation = 'flash_attention_2'
+ except ImportError:
+ best_fit_attn_implementation = 'eager'
+ self.model_path = model_path
+ attn_implementation = best_fit_attn_implementation
+ self._is_idefics = 'idefics' in model_path.lower()
+ # Here load the "non-idefics" Mantis model.
+ if not self._is_idefics:
+ if 'fuyu' in model_path.lower():
+ self.processor = MFuyuProcessor.from_pretrained(self.model_path)
+ model = MFuyuForCausalLM.from_pretrained(
+ self.model_path,
+ device_map='cuda',
+ attn_implementation=attn_implementation,
+ torch_dtype=torch.float16
+ )
+ else:
+ self.processor = MLlavaProcessor.from_pretrained(self.model_path)
+ model = LlavaForConditionalGeneration.from_pretrained(
+ self.model_path,
+ device_map='cuda',
+ attn_implementation=attn_implementation,
+ torch_dtype=torch.float16
+ )
+ else:
+ self.processor = AutoProcessor.from_pretrained(self.model_path)
+ model = AutoModelForVision2Seq.from_pretrained(
+ self.model_path,
+ device_map='cuda',
+ torch_dtype=torch.float16
+ )
+
+ model = model.eval()
+ self.model = model.cuda()
+ kwargs_default = dict(do_sample=False, temperature=0, max_new_tokens=1024, top_p=None, num_beams=1)
+ kwargs_default.update(kwargs)
+ self.kwargs = kwargs_default
+ warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ')
+
+ self.tokenizer = self.processor.tokenizer
+ self.default_conv = default_conv
+ self.conv_templates = conv_templates
+
+ def use_custom_prompt(self, dataset):
+ assert dataset is not None
+ if DATASET_TYPE(dataset) == 'MCQ':
+ return True
+ return False
+
+ def build_prompt(self, line, dataset=None):
+ assert self.use_custom_prompt(dataset)
+ assert dataset is None or isinstance(dataset, str)
+ tgt_path = self.dump_image(line, dataset)
+
+ question = line['question']
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ if hint is not None:
+ question = hint + '\n' + question
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ for key, item in options.items():
+ question += f'\n{key}. {item}'
+ prompt = question
+
+ if len(options):
+ prompt += (
+ '\n请直接回答选项字母。' if cn_string(prompt) else
+ "\nAnswer with the option's letter from the given choices directly."
+ )
+ else:
+ prompt += '\n请直接回答问题。' if cn_string(prompt) else '\nAnswer the question directly.'
+ message = [dict(type='image', value=s) for s in tgt_path]
+ message.append(dict(type='text', value=prompt))
+ return message
+
+ def output_process(self, answer):
+ if '' in answer:
+ answer = answer.replace('', '').strip()
+ if '[/INST]' in answer:
+ answer = answer.split('[/INST]')[1].strip()
+ elif 'ASSISTANT:' in answer:
+ answer = answer.split('ASSISTANT:')[1].strip()
+ elif 'assistant\n' in answer:
+ answer = answer.split('assistant\n')[1].strip()
+ elif '<|end_header_id|>\n\n' in answer:
+ answer = answer.split('<|end_header_id|>\n\n')[2].strip()
+
+ if ' ' in answer:
+ answer = answer.split(' ')[0].strip()
+ elif '<|im_end|>' in answer:
+ answer = answer.split('<|im_end|>')[0].strip()
+ elif '<|eot_id|>' in answer:
+ answer = answer.split('<|eot_id|>')[0].strip()
+ elif '' in answer:
+ answer = answer.split('')[0].strip()
+ elif '|ENDOFTEXT|' in answer:
+ answer = answer.split('|ENDOFTEXT|')[0].strip()
+ return answer
+
+ def generate_inner(self, message, dataset=None):
+ content, images = '', []
+ ide_content, question = [], ''
+ for msg in message:
+ if msg['type'] == 'text':
+ content += msg['value']
+ question += msg['value']
+ else:
+ images.append(Image.open(msg['value']).convert('RGB'))
+ content += (self.DEFAULT_IMAGE_TOKEN + '\n')
+ ide_content.append({'type': 'image'})
+ if self._is_idefics:
+ # Follow the idefics implementation:
+ ide_content.append({'type': 'text', 'text': question})
+ prompt = [{'role': 'user', 'content': ide_content}]
+ prompt = self.processor.apply_chat_template(prompt, add_generation_prompt=True)
+ else:
+ # Follow the Mantis code base to make sure they are consistent:
+ # https://github.com/TIGER-AI-Lab/Mantis/blob/main/mantis/models/mllava/utils.py#L33
+ # Users don't need to define chat template as it is done here
+ if 'llama-3' in self.model.language_model.name_or_path.lower():
+ conv = self.conv_templates['llama_3']
+ terminators = [
+ self.processor.tokenizer.eos_token_id,
+ self.processor.tokenizer.convert_tokens_to_ids('<|eot_id|>')
+ ]
+ else:
+ conv = self.default_conv
+ terminators = [self.processor.tokenizer.eos_token_id]
+
+ # Using EOT because end of *text* is more accurate for what we're doing than end of *sentence*
+ if 'eos_token_id' not in self.kwargs:
+ self.kwargs['eos_token_id'] = terminators
+
+ conv = conv.copy()
+ conv.append_message(conv.roles[0], content)
+ conv.append_message(conv.roles[1], '')
+ assert conv.messages[-1][0] == conv.roles[1] and conv.messages[-1][1] == '', 'Format check'
+ prompt = conv.get_prompt()
+
+ inputs = self.processor(prompt, images, return_tensors='pt', truncation=True)
+ # FIXME: Fuyu model would return a list instead of a pytorch tensor. This weird behavior needs fixing.
+ if 'image_patches' in inputs.keys():
+ inputs['image_patches'] = inputs['image_patches'][0]
+ inputs = {k: v.to(self.model.device) for k, v in inputs.items()}
+ output = self.model.generate(**inputs, **self.kwargs)
+ output = output[0]
+ generated_ids = output[inputs['input_ids'].shape[-1]:]
+ answer = self.processor.decode(generated_ids, skip_special_token=True)
+ answer = self.output_process(answer)
+ return answer
diff --git a/vlmeval/vlm/mgm.py b/vlmeval/vlm/mgm.py
new file mode 100644
index 0000000000000000000000000000000000000000..fd2a15be8886d176f7748b3797401eee9b4db5c6
--- /dev/null
+++ b/vlmeval/vlm/mgm.py
@@ -0,0 +1,158 @@
+import sys
+import torch
+import os.path as osp
+import os
+import warnings
+from .base import BaseModel
+from ..smp import *
+from PIL import Image
+
+'''
+ Please follow the instructions to download ckpt.
+ https://github.com/dvlab-research/MGM?tab=readme-ov-file#pretrained-weights
+'''
+
+
+class Mini_Gemini(BaseModel):
+ INSTALL_REQ = True
+ INTERLEAVE = False
+
+ def __init__(self, model_path, root=None, conv_mode='llava_v1', **kwargs):
+ if root is None:
+ warnings.warn('Please set `root` to Mini_Gemini code directory, \
+ which is cloned from here: "https://github.com/dvlab-research/MGM?tab=readme-ov-file" ')
+ raise ValueError
+ warnings.warn('Please follow the instructions of Mini_Gemini to put the ckpt file in the right place, \
+ which can be found at https://github.com/dvlab-research/MGM?tab=readme-ov-file#structure')
+ assert model_path == 'YanweiLi/MGM-7B-HD', 'We only support MGM-7B-HD for now'
+ self.model_path = model_path
+ sys.path.append(root)
+ try:
+ from mgm.model.builder import load_pretrained_model
+ from mgm.mm_utils import get_model_name_from_path
+ except Exception as e:
+ logging.critical(
+ 'Please first install Mini_Gemini and set the root path to use Mini_Gemini, '
+ 'which is cloned from here: "https://github.com/dvlab-research/MGM?tab=readme-ov-file" '
+ )
+ raise e
+
+ VLMEvalKit_path = os.getcwd()
+ os.chdir(root)
+ warnings.warn('Please set `root` to Mini_Gemini code directory, \
+ which is cloned from here: "https://github.com/dvlab-research/MGM?tab=readme-ov-file" ')
+ model_path = osp.join(root, 'work_dirs', 'MGM', 'MGM-7B-HD')
+ try:
+ model_name = get_model_name_from_path(model_path)
+ except Exception as e:
+ logging.critical(
+ 'Please follow the instructions of Mini_Gemini to put the ckpt file in the right place, '
+ 'which can be found at https://github.com/dvlab-research/MGM?tab=readme-ov-file#structure'
+ )
+ raise e
+
+ tokenizer, model, image_processor, context_len = load_pretrained_model(model_path, None, model_name)
+ os.chdir(VLMEvalKit_path)
+ self.model = model
+ self.tokenizer = tokenizer
+ self.image_processor = image_processor
+ self.conv_mode = conv_mode
+
+ kwargs_default = dict(temperature=float(0), num_beams=1, top_p=None, max_new_tokens=1024, use_cache=True)
+ kwargs_default.update(kwargs)
+ do_sample = kwargs_default['temperature'] > 0
+ kwargs_default.update({'do_sample': do_sample})
+ self.kwargs = kwargs_default
+
+ def generate_inner(self, message, dataset=None):
+ try:
+ from mgm.constants import IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_TOKEN, \
+ DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN
+ from mgm.conversation import conv_templates
+ from mgm.mm_utils import tokenizer_image_token, process_images
+ except Exception as e:
+ logging.critical(
+ 'Please first install Mini_Gemini and set the root path to use Mini_Gemini, '
+ 'which is cloned from here: "https://github.com/dvlab-research/MGM?tab=readme-ov-file" '
+ )
+ raise e
+
+ prompt, image = self.message_to_promptimg(message, dataset=dataset)
+ image = Image.open(image)
+ prompt = DEFAULT_IM_START_TOKEN + DEFAULT_IMAGE_TOKEN + DEFAULT_IM_END_TOKEN + '\n' + prompt
+ conv = conv_templates[self.conv_mode].copy()
+ conv.append_message(conv.roles[0], prompt)
+ conv.append_message(conv.roles[1], None)
+ prompt = conv.get_prompt()
+
+ input_ids = tokenizer_image_token(prompt, self.tokenizer, IMAGE_TOKEN_INDEX, return_tensors='pt')
+ input_ids = input_ids.unsqueeze(0).cuda()
+ if hasattr(self.model.config, 'image_size_aux'):
+ if not hasattr(self.image_processor, 'image_size_raw'):
+ self.image_processor.image_size_raw = self.image_processor.crop_size.copy()
+ self.image_processor.crop_size['height'] = self.model.config.image_size_aux
+ self.image_processor.crop_size['width'] = self.model.config.image_size_aux
+ self.image_processor.size['shortest_edge'] = self.model.config.image_size_aux
+ image_tensor = process_images([image], self.image_processor, self.model.config)[0]
+ image_grid = getattr(self.model.config, 'image_grid', 1)
+ if hasattr(self.model.config, 'image_size_aux'):
+ raw_shape = [
+ self.image_processor.image_size_raw['height'] * image_grid,
+ self.image_processor.image_size_raw['width'] * image_grid
+ ]
+ image_tensor_aux = image_tensor
+ image_tensor = torch.nn.functional.interpolate(
+ image_tensor[None],
+ size=raw_shape,
+ mode='bilinear',
+ align_corners=False
+ )[0]
+ else:
+ image_tensor_aux = []
+ if image_grid >= 2:
+ raw_image = image_tensor.reshape(
+ 3, image_grid, self.image_processor.image_size_raw['height'],
+ image_grid, self.image_processor.image_size_raw['width']
+ )
+ raw_image = raw_image.permute(1, 3, 0, 2, 4)
+ raw_image = raw_image.reshape(
+ -1, 3, self.image_processor.image_size_raw['height'], self.image_processor.image_size_raw['width']
+ )
+
+ if getattr(self.model.config, 'image_global', False):
+ global_image = image_tensor
+ if len(global_image.shape) == 3:
+ global_image = global_image[None]
+ global_image = torch.nn.functional.interpolate(
+ global_image,
+ size=[
+ self.image_processor.image_size_raw['height'],
+ self.image_processor.image_size_raw['width']
+ ],
+ mode='bilinear',
+ align_corners=False
+ )
+ # [image_crops, image_global]
+ raw_image = torch.cat([raw_image, global_image], dim=0)
+ image_tensor = raw_image.contiguous()
+
+ images = image_tensor[None].to(dtype=self.model.dtype, device='cuda', non_blocking=True)
+ if len(image_tensor_aux) > 0:
+ images_aux = image_tensor_aux[None].to(dtype=self.model.dtype, device='cuda', non_blocking=True)
+ else:
+ images_aux = None
+
+ with torch.inference_mode():
+ output_ids = self.model.generate(
+ input_ids,
+ images=images,
+ images_aux=images_aux,
+ # no_repeat_ngram_size=3,
+ bos_token_id=self.tokenizer.bos_token_id, # Begin of sequence token
+ eos_token_id=self.tokenizer.eos_token_id, # End of sequence token
+ pad_token_id=self.tokenizer.pad_token_id, # Pad token
+ **self.kwargs
+ )
+
+ outputs = self.tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0].strip()
+ return outputs
diff --git a/vlmeval/vlm/minicpm_v.py b/vlmeval/vlm/minicpm_v.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b74eedd3c9a324ba726c9f70babad7c74be63c9
--- /dev/null
+++ b/vlmeval/vlm/minicpm_v.py
@@ -0,0 +1,729 @@
+import math
+import torch
+import random
+import numpy as np
+from PIL import Image
+from transformers import AutoModel, AutoTokenizer
+
+from .base import BaseModel
+from ..smp import *
+from ..dataset import DATASET_TYPE, DATASET_MODALITY
+
+import re
+
+
+class MiniCPM_V(BaseModel):
+
+ INSTALL_REQ = False
+ INTERLEAVE = False
+
+ def __init__(self, model_path='openbmb/MiniCPM-V', **kwargs):
+ assert model_path is not None
+ self.model_path = model_path
+ print(f'load from {self.model_path}')
+ self.model = AutoModel.from_pretrained(self.model_path, trust_remote_code=True)
+ self.model = self.model.to(dtype=torch.bfloat16)
+ self.model.eval().cuda()
+ self.kwargs = kwargs
+ self.tokenizer = AutoTokenizer.from_pretrained(self.model_path, trust_remote_code=True)
+ torch.cuda.empty_cache()
+ self.num_beams = 3
+
+ def use_custom_prompt(self, dataset):
+ assert dataset is not None
+ if listinstr(['MMDU', 'MME-RealWorld', 'MME-RealWorld-CN', 'MMAlignBench'], dataset):
+ # For Multi-Turn we don't have custom prompt
+ return False
+ return False
+
+ def build_prompt(self, line, dataset=None):
+ assert dataset is None or isinstance(dataset, str)
+ assert self.use_custom_prompt(dataset)
+ tgt_path = self.dump_image(line, dataset)
+
+ question = line['question']
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ options_prompt = 'Options:\n'
+ for key, item in options.items():
+ options_prompt += f'{key}. {item}\n'
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ prompt = ''
+ if hint is not None:
+ prompt += f'Hint: {hint}\n'
+ prompt += f'{question}\n'
+ if len(options):
+ prompt += options_prompt
+ prompt = 'Study the image carefully and pick the option associated with the correct answer. \
+ Focus solely on selecting the option and avoid including any other content.\n' + prompt
+ message = [dict(type='text', value=prompt)]
+ message.extend([dict(type='image', value=p) for p in tgt_path])
+
+ return message
+
+ def generate_inner(self, message, dataset=None):
+ prompt, image_path = self.message_to_promptimg(message, dataset=dataset)
+ image = Image.open(image_path).convert('RGB')
+ msgs = [{'role': 'user', 'content': prompt}]
+ if DATASET_TYPE(dataset) == 'MCQ':
+ max_new_tokens = 20
+ elif DATASET_TYPE(dataset) == 'Y/N':
+ max_new_tokens = 100
+ else:
+ max_new_tokens = 1024
+
+ default_kwargs = dict(
+ max_new_tokens=max_new_tokens,
+ sampling=False,
+ num_beams=self.num_beams
+ )
+ default_kwargs.update(self.kwargs)
+ res, _, _ = self.model.chat(
+ image=image,
+ msgs=msgs,
+ context=None,
+ tokenizer=self.tokenizer,
+ **default_kwargs
+ )
+ return res
+
+
+class MiniCPM_Llama3_V(BaseModel):
+
+ INSTALL_REQ = False
+ INTERLEAVE = True
+
+ def __init__(self, model_path='openbmb/MiniCPM-Llama3-V-2_5', **kwargs):
+ assert model_path is not None
+ self.model_path = model_path
+ print(f'load from {self.model_path}')
+ self.model = AutoModel.from_pretrained(self.model_path, trust_remote_code=True)
+ self.model = self.model.to(dtype=torch.float16)
+ self.model.eval().cuda()
+ self.kwargs = kwargs
+ self.tokenizer = AutoTokenizer.from_pretrained(self.model_path, trust_remote_code=True)
+ torch.cuda.empty_cache()
+ self.num_beams = 3
+ self.options_system_prompt = ('Carefully read the following question and select the letter corresponding '
+ 'to the correct answer. Highlight the applicable choices without giving '
+ 'explanations.')
+ self.wo_options_system_prompt = 'Carefully read the following question Answer the question directly.'
+ self.detail_system_prompt = 'Answer this question in detail.'
+ self.vqa_prompt = 'Answer the question using a single word or phrase.'
+
+ def use_custom_prompt(self, dataset):
+ if listinstr(['MCQ', 'VQA'], DATASET_TYPE(dataset)):
+ return True
+ elif dataset is not None and listinstr(['HallusionBench'], dataset):
+ return True
+ return False
+
+ def build_prompt(self, line, dataset=None):
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ tgt_path = self.dump_image(line, dataset)
+ system_prompt = ''
+
+ question = line['question']
+ if DATASET_TYPE(dataset) == 'MCQ':
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ options_prompt = 'Options:\n'
+ for key, item in options.items():
+ options_prompt += f'{key}. {item}\n'
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ prompt = ''
+ if hint is not None:
+ prompt += f'Hint: {hint}\n'
+ prompt += f'Question: {question}\n'
+ if len(options):
+ prompt += options_prompt
+ system_prompt = self.options_system_prompt + '\nPlease just indicate your choice.'
+ else:
+ system_prompt = self.wo_options_system_prompt
+ if 'MMMU' in dataset: # Corner Case
+ prompt = system_prompt + '\n' + prompt
+ system_prompt = ''
+ elif dataset is not None and listinstr(['HallusionBench'], dataset):
+ question = line['question'] + ' Yes or No?'
+ prompt = question
+ elif dataset is not None and listinstr(['MME'], dataset):
+ question = line['question'] + ' Yes or No?'
+ prompt = question
+ elif dataset is not None and listinstr(['OCRBench'], dataset):
+ system_prompt = self.vqa_prompt
+ question = line['question']
+ prompt = question
+ elif DATASET_TYPE(dataset) == 'VQA':
+ if listinstr(['LLaVABench', 'MMLongBench_DOC'], dataset):
+ system_prompt = ''
+ prompt = question
+ elif listinstr(['MMVet'], dataset):
+ system_prompt = self.detail_system_prompt
+ prompt = question
+ else:
+ system_prompt = self.vqa_prompt
+ prompt = question
+
+ msgs = []
+ if system_prompt:
+ msgs.append(dict(type='text', value=system_prompt))
+ if isinstance(tgt_path, list):
+ msgs.extend([dict(type='image', value=p) for p in tgt_path])
+ else:
+ msgs = [dict(type='image', value=tgt_path)]
+ msgs.append(dict(type='text', value=prompt))
+ return msgs
+
+ def generate_inner(self, message, dataset=None):
+ if DATASET_TYPE(dataset) == 'MCQ':
+ max_new_tokens = 200
+ elif DATASET_TYPE(dataset) == 'Y/N':
+ max_new_tokens = 3
+ else:
+ max_new_tokens = 1024
+
+ default_kwargs = dict(
+ max_new_tokens=max_new_tokens,
+ sampling=False,
+ num_beams=self.num_beams,
+ )
+ default_kwargs.update(self.kwargs)
+
+ content = []
+ for x in message:
+ if x['type'] == 'text':
+ content.append(x['value'])
+ elif x['type'] == 'image':
+ image = Image.open(x['value']).convert('RGB')
+ content.append(image)
+ msgs = [{'role': 'user', 'content': content}]
+
+ res = self.model.chat(
+ msgs=msgs,
+ context=None,
+ image=None,
+ tokenizer=self.tokenizer,
+ **default_kwargs
+ )
+
+ if isinstance(res, tuple) and len(res) > 0:
+ res = res[0]
+ return res
+
+ def chat_inner(self, message, dataset=None):
+ max_new_tokens = 1024
+
+ default_kwargs = dict(
+ max_new_tokens=max_new_tokens,
+ sampling=False,
+ num_beams=self.num_beams,
+ )
+ default_kwargs.update(self.kwargs)
+
+ msgs = []
+ for msg in message:
+ content = []
+ if len(msg['content']) == 1 and msg['content'][0]['type'] == 'text':
+ msg_new = {'role': msg['role'], 'content': msg['content'][0]['value']}
+ msgs.append(msg_new)
+ continue
+
+ for x in msg['content']:
+ if x['type'] == 'text':
+ content.append(x['value'])
+ elif x['type'] == 'image':
+ image = Image.open(x['value']).convert('RGB')
+ content.append(image)
+ msg_new = {'role': msg['role'], 'content': content}
+ msgs.append(msg_new)
+
+ res = self.model.chat(
+ msgs=msgs,
+ context=None,
+ image=None,
+ tokenizer=self.tokenizer,
+ **default_kwargs)
+
+ if isinstance(res, tuple) and len(res) > 0:
+ res = res[0]
+ return res
+
+
+class MiniCPM_V_2_6(BaseModel):
+ INSTALL_REQ = False
+ INTERLEAVE = True
+
+ def __init__(self, model_path='openbmb/MiniCPM-V-2_6', **kwargs):
+ random.seed(0)
+ np.random.seed(0)
+ torch.manual_seed(0)
+ torch.cuda.manual_seed_all(0)
+
+ assert model_path is not None
+ self.model_path = model_path
+ print(f'load from path {self.model_path}')
+ self.model = AutoModel.from_pretrained(self.model_path, trust_remote_code=True)
+ self.model = self.model.to(dtype=torch.bfloat16)
+ self.model.eval().cuda()
+
+ self.kwargs = kwargs
+ self.tokenizer = AutoTokenizer.from_pretrained(self.model_path, trust_remote_code=True)
+ torch.cuda.empty_cache()
+ self.num_beams = 3
+
+ self.options_suffix_prompt = '''\nAnswer with the option's letter from the given choices directly.'''
+ self.wo_options_system_prompt = 'Carefully read the following question Answer the question directly.'
+ self.detail_system_prompt = 'Answer this question in detail.'
+ self.vqa_prompt = 'Answer the question using a single word or phrase.'
+
+ self.multi_choice_cot_prompt = ('''Carefully read the following multichoice question, solve it step '''
+ '''by step and finally pick the option associated with the correct '''
+ '''answer in the format of "Answer: selected option\n\n''')
+ self.short_ans_cot_prompt = ('''Read the following question carefully, solve it step by step, and '''
+ '''then output the final answer in the format of "Answer: single number '''
+ '''or single word or phrase".\n\n''')
+
+ def use_custom_prompt(self, dataset=None):
+ if dataset is None:
+ return False
+ if DATASET_TYPE(dataset) in ['MCQ', 'VQA', 'Y/N']:
+ return True
+ return False
+
+ def use_cot(self, dataset=None):
+ if dataset is None:
+ return False
+ if listinstr(['MMMU', 'HallusionBench', 'OCRBench', 'ChartQA'], dataset):
+ return True
+ elif listinstr(['MathVista', 'MMVet', 'MMBench', 'MMStar', 'AI2D', 'RealWorldQA',
+ 'POPE', 'ScienceQA', 'TextVQA', 'DocVQA'], dataset):
+ return False
+ else:
+ return False
+
+ def use_upsize(self, dataset=None):
+ if dataset is None:
+ return False
+ if listinstr(['MMVet', 'MMBench', 'MMStar', 'AI2D', 'OCRBench'], dataset):
+ return True
+ else:
+ return False
+
+ def build_prompt(self, line, dataset=None):
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ tgt_path = self.dump_image(line, dataset)
+ system_prompt, prompt = '', ''
+
+ question = line['question']
+
+ if not self.use_cot(dataset):
+ if DATASET_TYPE(dataset) == 'MCQ':
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ options_prompt = 'Options:\n'
+ for key, item in options.items():
+ options_prompt += f'{key}. {item}\n'
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ if hint is not None:
+ prompt += f'Hint: {hint}\n'
+ prompt += f'Question: {question}\n'
+ if len(options):
+ prompt += options_prompt
+ prompt += self.options_suffix_prompt
+ else:
+ system_prompt = self.wo_options_system_prompt
+
+ if 'MMMU' in dataset:
+ if len(system_prompt) > 0:
+ prompt = system_prompt + '\n' + prompt
+ system_prompt = ''
+ elif dataset is not None and listinstr(['HallusionBench'], dataset):
+ question += ' Yes or No?'
+ prompt = question
+ elif dataset is not None and listinstr(['OCRBench'], dataset):
+ system_prompt = self.vqa_prompt
+ prompt = question
+ elif DATASET_TYPE(dataset) == 'VQA':
+ if listinstr(['LLaVABench'], dataset):
+ system_prompt = ''
+ elif listinstr(['MMVet'], dataset):
+ system_prompt = self.detail_system_prompt
+ else:
+ system_prompt = self.vqa_prompt
+ prompt = question
+ else:
+ prompt = question
+ else:
+ has_options = True
+ if DATASET_TYPE(dataset) == 'MCQ':
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ options_prompt = ''
+ for key, item in options.items():
+ options_prompt += f'{key}. {item}\n'
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ if hint is not None:
+ prompt += f'Hint: {hint}\n'
+ prompt += f'{question}\n'
+
+ if len(options):
+ prompt += options_prompt
+ else:
+ has_options = False
+
+ if 'MMMU' in dataset:
+ if len(system_prompt) > 0:
+ prompt = system_prompt + '\n' + prompt
+ system_prompt = ''
+ else:
+ prompt = question
+
+ if DATASET_TYPE(dataset) in ['MCQ', 'Y/N', 'VQA']:
+ if DATASET_TYPE(dataset) == 'MCQ':
+ if has_options:
+ prompt = self.multi_choice_cot_prompt + prompt
+ else:
+ prompt = self.short_ans_cot_prompt + prompt
+ elif DATASET_TYPE(dataset) == 'Y/N':
+ prompt = self.short_ans_cot_prompt + prompt
+ else:
+ prompt = self.short_ans_cot_prompt + prompt
+
+ msgs = []
+ if system_prompt:
+ msgs.append(dict(type='text', value=system_prompt))
+ if isinstance(tgt_path, list):
+ msgs.extend([dict(type='image', value=p) for p in tgt_path])
+ else:
+ msgs = [dict(type='image', value=tgt_path)]
+ msgs.append(dict(type='text', value=prompt))
+
+ return msgs
+
+ def generate_inner(self, message, dataset=None):
+ if DATASET_MODALITY(dataset) == 'VIDEO':
+ max_slice_nums = 1
+ use_image_id = False
+ max_inp_length = 2048 * 10
+ else:
+ max_slice_nums = None
+ use_image_id = True
+ max_inp_length = 8192
+
+ max_new_tokens = 2048
+ default_kwargs = dict(
+ max_new_tokens=max_new_tokens,
+ sampling=False,
+ num_beams=self.num_beams,
+ )
+ default_kwargs.update(self.kwargs)
+
+ content = []
+
+ for x in message:
+ if x['type'] == 'text':
+ content.append(x['value'])
+ elif x['type'] == 'image':
+ image = Image.open(x['value']).convert('RGB')
+ if not self.use_upsize(dataset):
+ content.append(image)
+ else:
+ img_width, img_height = image.width, image.height
+ if (img_width * img_height) >= (1344 * 1344):
+ content.append(image)
+ else:
+ ratio = math.sqrt((1344 * 1344) / (img_width * img_height))
+ max_img_width = int(img_width * ratio)
+ new_img_width = random.randint(img_width, max_img_width)
+ new_img_height = int(new_img_width / img_width * img_height)
+ resized_image = image.resize((new_img_width, new_img_height))
+ content.append(resized_image)
+ msgs = [{'role': 'user', 'content': content}]
+
+ res = self.model.chat(
+ image=None,
+ msgs=msgs,
+ context=None,
+ tokenizer=self.tokenizer,
+ max_inp_length=max_inp_length,
+ use_image_id=use_image_id,
+ max_slice_nums=max_slice_nums,
+ **default_kwargs
+ )
+
+ if isinstance(res, tuple) and len(res) > 0:
+ res = res[0]
+
+ return res
+
+
+class MiniCPM_o_2_6(BaseModel):
+ INSTALL_REQ = False
+ INTERLEAVE = True
+
+ def __init__(self, model_path='openbmb/MiniCPM-o-2_6', **kwargs):
+ random.seed(0)
+ np.random.seed(0)
+ torch.manual_seed(0)
+ torch.cuda.manual_seed_all(0)
+
+ assert model_path is not None
+ self.model_path = model_path
+ print(f'load from path {self.model_path}')
+ self.model = AutoModel.from_pretrained(
+ self.model_path,
+ trust_remote_code=True,
+ attn_implementation='sdpa',
+ torch_dtype=torch.bfloat16,
+ init_vision=True,
+ init_audio=False,
+ init_tts=False
+ )
+
+ self.model.eval().cuda()
+
+ self.kwargs = kwargs
+ self.tokenizer = AutoTokenizer.from_pretrained(self.model_path, trust_remote_code=True)
+ torch.cuda.empty_cache()
+
+ self.num_beams = int(os.getenv("NUM_BEAMS", "3"))
+
+ repetition_penalty = float(os.getenv("PENALTY", "1.2"))
+ self.repetition_penalty = repetition_penalty
+
+ self.options_suffix_prompt = '''\nAnswer with the option's letter from the given choices directly.'''
+ self.wo_options_system_prompt = 'Carefully read the following question Answer the question directly.'
+ self.detail_system_prompt = 'Answer this question in detail.'
+ self.vqa_prompt = 'Answer the question using a single word or phrase.'
+
+ self.multi_choice_cot_prompt = ('''Carefully read the following multichoice question, solve it step '''
+ '''by step and finally pick the option associated with the correct '''
+ '''answer in the format of "Answer: selected option\n\n''')
+ self.short_ans_cot_prompt = ('''Read the following question carefully, solve it step by step, and '''
+ '''then output the final answer in the format of "Answer: single number '''
+ '''or single word or phrase".\n\n''')
+
+ def use_custom_prompt(self, dataset=None):
+ if dataset is None:
+ return False
+ if listinstr(['MCQ', 'VQA', 'Y/N'], DATASET_TYPE(dataset)) and not listinstr(['Video'], DATASET_TYPE(dataset)):
+ return True
+ return False
+
+ def use_cot(self, dataset=None):
+ if dataset is None:
+ return False
+ if listinstr(['MMMU', 'MathVista', 'OCRBench', 'ChartQA', 'MathVision', 'MathVerse_MINI_Vision_Only'], dataset):
+ return True
+ elif listinstr(['MMVet', 'MMBench', 'MMStar', 'HallusionBench', 'AI2D', 'RealWorldQA',
+ 'POPE', 'ScienceQA', 'TextVQA', 'DocVQA'], dataset):
+ return False
+ else:
+ return False
+
+ def use_upsize(self, dataset=None):
+ if dataset is None:
+ return False
+ if listinstr(['MathVista', 'MMBench_TEST_CN', 'MMStar', 'AI2D', 'OCRBench', 'DynaMath'], dataset):
+ return True
+ else:
+ return False
+
+ def build_prompt(self, line, dataset=None):
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ tgt_path = self.dump_image(line, dataset)
+ system_prompt, prompt = '', ''
+
+ question = line['question']
+
+ if not self.use_cot(dataset):
+ if DATASET_TYPE(dataset) == 'MCQ':
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ options_prompt = 'Options:\n'
+ for key, item in options.items():
+ options_prompt += f'{key}. {item}\n'
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ if hint is not None:
+ prompt += f'Hint: {hint}\n'
+ prompt += f'Question: {question}\n'
+ if len(options):
+ prompt += options_prompt
+ prompt += self.options_suffix_prompt
+ else:
+ system_prompt = self.wo_options_system_prompt
+
+ if 'MMMU' in dataset:
+ if len(system_prompt) > 0:
+ prompt = system_prompt + '\n' + prompt
+ system_prompt = ''
+ elif dataset is not None and listinstr(['HallusionBench'], dataset):
+ question += ' Yes or No?'
+ prompt = question
+ elif dataset is not None and listinstr(['OCRBench'], dataset):
+ system_prompt = self.vqa_prompt
+ prompt = question
+ elif DATASET_TYPE(dataset) == 'VQA':
+ if listinstr(['LLaVABench'], dataset):
+ system_prompt = ''
+ elif listinstr(['MMVet'], dataset):
+ system_prompt = self.detail_system_prompt
+ else:
+ system_prompt = self.vqa_prompt
+ prompt = question
+ else:
+ prompt = question
+ else:
+ has_options = True
+ if DATASET_TYPE(dataset) == 'MCQ':
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ options_prompt = ''
+ for key, item in options.items():
+ options_prompt += f'{key}. {item}\n'
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ if hint is not None:
+ prompt += f'Hint: {hint}\n'
+ prompt += f'{question}\n'
+
+ if len(options):
+ prompt += options_prompt
+ else:
+ has_options = False
+
+ if 'MMMU' in dataset:
+ if len(system_prompt) > 0:
+ prompt = system_prompt + '\n' + prompt
+ system_prompt = ''
+ else:
+ prompt = question
+
+ if DATASET_TYPE(dataset) in ['MCQ', 'Y/N', 'VQA']:
+ if DATASET_TYPE(dataset) == 'MCQ':
+ if has_options:
+ prompt = self.multi_choice_cot_prompt + prompt
+ else:
+ prompt = self.short_ans_cot_prompt + prompt
+ elif DATASET_TYPE(dataset) == 'Y/N':
+ prompt = self.short_ans_cot_prompt + prompt
+ else:
+ prompt = self.short_ans_cot_prompt + prompt
+
+ msgs = []
+ if system_prompt:
+ msgs.append(dict(type='text', value=system_prompt))
+ if isinstance(tgt_path, list):
+ msgs.extend([dict(type='image', value=p) for p in tgt_path])
+ else:
+ msgs = [dict(type='image', value=tgt_path)]
+ msgs.append(dict(type='text', value=prompt))
+
+ return msgs
+
+ def extract_answer(self, res, dataset=None):
+ if dataset is None:
+ return res
+ if self.use_cot(dataset):
+ if DATASET_TYPE(dataset) == 'MCQ':
+ pattern = r'Answer:\s*([A-Ia-i])(?![A-Za-z])'
+ matches = re.findall(pattern, res, re.DOTALL)
+ if matches:
+ extracted_res = matches[-1].strip()
+ else:
+ extracted_res = res
+ return extracted_res
+ elif DATASET_TYPE(dataset) == 'VQA' and not listinstr(['OCRBench'], dataset):
+ pattern = r'Answer:\s*(.*)\s*$'
+ match = re.search(pattern, res, re.DOTALL)
+ if match:
+ extracted_res = match.group(1)
+ else:
+ extracted_res = res
+ return extracted_res
+ return res
+
+ def generate_inner(self, message, dataset=None):
+ if DATASET_MODALITY(dataset) == 'VIDEO':
+ max_slice_nums = 1
+ use_image_id = False
+ max_inp_length = 2048 * 10
+ else:
+ max_slice_nums = None
+ use_image_id = True
+ max_inp_length = 8192
+
+ max_new_tokens = 2048
+ default_kwargs = dict(
+ max_new_tokens=max_new_tokens,
+ sampling=False,
+ repetition_penalty=self.repetition_penalty,
+ num_beams=self.num_beams,
+ )
+ default_kwargs.update(self.kwargs)
+
+ content = []
+
+ if DATASET_TYPE(dataset) == 'Video-MCQ':
+ message.append(dict(type='text', value=self.options_suffix_prompt))
+
+ for x in message:
+ if x['type'] == 'text':
+ content.append(x['value'])
+ elif x['type'] == 'image':
+ image = Image.open(x['value']).convert('RGB')
+ if not self.use_upsize(dataset):
+ content.append(image)
+ else:
+ img_width, img_height = image.width, image.height
+ if (img_width * img_height) >= (1344 * 1344):
+ content.append(image)
+ else:
+ ratio = math.sqrt((1344 * 1344) / (img_width * img_height))
+ max_img_width = int(img_width * ratio)
+ new_img_width = random.randint(img_width, max_img_width)
+ new_img_height = int(new_img_width / img_width * img_height)
+ resized_image = image.resize((new_img_width, new_img_height))
+ content.append(resized_image)
+ msgs = [{'role': 'user', 'content': content}]
+
+ res = self.model.chat(
+ image=None,
+ msgs=msgs,
+ context=None,
+ tokenizer=self.tokenizer,
+ max_inp_length=max_inp_length,
+ use_image_id=use_image_id,
+ max_slice_nums=max_slice_nums,
+ **default_kwargs
+ )
+
+ if isinstance(res, tuple) and len(res) > 0:
+ res = res[0]
+
+ res = self.extract_answer(res, dataset)
+
+ return res
diff --git a/vlmeval/vlm/minigpt4.py b/vlmeval/vlm/minigpt4.py
new file mode 100644
index 0000000000000000000000000000000000000000..a4cc4b7929def6f4bf93f8caafed15eb8c4fa995
--- /dev/null
+++ b/vlmeval/vlm/minigpt4.py
@@ -0,0 +1,85 @@
+import torch
+import sys
+import os.path as osp
+import warnings
+from transformers import StoppingCriteriaList
+from .base import BaseModel
+
+
+class MiniGPT4(BaseModel):
+
+ INSTALL_REQ = True
+ INTERLEAVE = False
+
+ def __init__(self,
+ mode='v2',
+ root='/mnt/petrelfs/share_data/duanhaodong/MiniGPT-4/',
+ temperature=1,
+ max_out_len=512):
+
+ if root is None:
+ warnings.warn(
+ 'Please set root to the directory of MiniGPT-4, which is cloned from here: '
+ 'https://github.com/Vision-CAIR/MiniGPT-4. '
+ )
+
+ if mode == 'v2':
+ cfg = 'minigptv2_eval.yaml'
+ elif mode == 'v1_7b':
+ cfg = 'minigpt4_7b_eval.yaml'
+ elif mode == 'v1_13b':
+ cfg = 'minigpt4_13b_eval.yaml'
+ else:
+ raise NotImplementedError
+
+ self.mode = mode
+ self.temperature = temperature
+ self.max_out_len = max_out_len
+ self.root = root
+ this_dir = osp.dirname(__file__)
+
+ self.cfg = osp.join(this_dir, 'misc', cfg)
+ sys.path.append(self.root)
+
+ from omegaconf import OmegaConf
+ from minigpt4.common.registry import registry
+ from minigpt4.conversation.conversation import StoppingCriteriaSub, CONV_VISION_Vicuna0, CONV_VISION_minigptv2
+
+ device = torch.cuda.current_device()
+ self.device = device
+
+ cfg_path = self.cfg
+ cfg = OmegaConf.load(cfg_path)
+
+ model_cfg = cfg.model
+ model_cfg.device_8bit = device
+ model_cls = registry.get_model_class(model_cfg.arch)
+ model = model_cls.from_config(model_cfg)
+ model = model.to(device)
+ model.eval()
+ vis_processor_cfg = cfg.datasets.cc_sbu_align.vis_processor.train
+ vis_processor = registry.get_processor_class(vis_processor_cfg.name).from_config(vis_processor_cfg)
+ self.model = model
+ self.vis_processor = vis_processor
+
+ self.CONV_VISION = CONV_VISION_minigptv2 if self.mode == 'v2' else CONV_VISION_Vicuna0
+ stop_words_ids = [[835], [2277, 29937]]
+ stop_words_ids = [torch.tensor(ids).to(device) for ids in stop_words_ids]
+ self.stopping_criteria = StoppingCriteriaList([StoppingCriteriaSub(stops=stop_words_ids)])
+
+ def generate_inner(self, message, dataset=None):
+ from minigpt4.conversation.conversation import Chat
+ prompt, image_path = self.message_to_promptimg(message, dataset=dataset)
+ if self.mode == 'v2':
+ chat = Chat(self.model, self.vis_processor, device=self.device)
+ else:
+ chat = Chat(self.model, self.vis_processor, device=self.device, stopping_criteria=self.stopping_criteria)
+
+ chat_state = self.CONV_VISION.copy()
+ img_list = []
+ _ = chat.upload_img(image_path, chat_state, img_list)
+ chat.encode_img(img_list)
+ chat.ask(prompt, chat_state)
+ with torch.inference_mode():
+ msg = chat.answer(conv=chat_state, img_list=img_list)[0]
+ return msg
diff --git a/vlmeval/vlm/minimonkey.py b/vlmeval/vlm/minimonkey.py
new file mode 100644
index 0000000000000000000000000000000000000000..0983fb7593bab24765eb73827a29e64038fb62a7
--- /dev/null
+++ b/vlmeval/vlm/minimonkey.py
@@ -0,0 +1,534 @@
+import torch
+from transformers import AutoTokenizer, AutoConfig, AutoModel, CLIPImageProcessor
+import warnings
+from PIL import Image
+from .base import BaseModel
+from ..smp import *
+from ..dataset import DATASET_TYPE
+import pandas as pd
+import string
+import torch.distributed as dist
+import torchvision.transforms as T
+import transformers
+
+from torchvision.transforms.functional import InterpolationMode
+import re
+
+
+IMAGENET_MEAN = (0.485, 0.456, 0.406)
+IMAGENET_STD = (0.229, 0.224, 0.225)
+
+
+def build_transform(input_size):
+ MEAN, STD = IMAGENET_MEAN, IMAGENET_STD
+ transform = T.Compose([
+ T.Lambda(lambda img: img.convert('RGB') if img.mode != 'RGB' else img),
+ T.Resize((input_size, input_size), interpolation=InterpolationMode.BICUBIC),
+ T.ToTensor(),
+ T.Normalize(mean=MEAN, std=STD)
+ ])
+ return transform
+
+
+def find_closest_aspect_ratio(aspect_ratio, target_ratios, width, height, image_size):
+ best_ratio_diff = float('inf')
+ best_ratio = (1, 1)
+ area = width * height
+ for ratio in target_ratios:
+ target_aspect_ratio = ratio[0] / ratio[1]
+ ratio_diff = abs(aspect_ratio - target_aspect_ratio)
+ if ratio_diff < best_ratio_diff:
+ best_ratio_diff = ratio_diff
+ best_ratio = ratio
+ elif ratio_diff == best_ratio_diff:
+ if area > 0.5 * image_size * image_size * ratio[0] * ratio[1]:
+ best_ratio = ratio
+ return best_ratio
+
+
+def dynamic_preprocess(image, min_num=5, max_num=6, image_size=448, use_thumbnail=False):
+ orig_width, orig_height = image.size
+ aspect_ratio = orig_width / orig_height
+
+ # calculate the existing image aspect ratio
+ target_ratios = set(
+ (i, j) for n in range(min_num, max_num + 1) for i in range(1, n + 1) for j in range(1, n + 1) if
+ i * j <= max_num and i * j >= min_num)
+ target_ratios = sorted(target_ratios, key=lambda x: x[0] * x[1])
+
+ # find the closest aspect ratio to the target
+ target_aspect_ratio = find_closest_aspect_ratio(
+ aspect_ratio, target_ratios, orig_width, orig_height, image_size)
+
+ # calculate the target width and height
+ target_width = image_size * target_aspect_ratio[0]
+ target_height = image_size * target_aspect_ratio[1]
+ blocks = target_aspect_ratio[0] * target_aspect_ratio[1]
+
+ # resize the image
+ resized_img = image.resize((target_width, target_height))
+ processed_images = []
+ for i in range(blocks):
+ box = (
+ (i % (target_width // image_size)) * image_size,
+ (i // (target_width // image_size)) * image_size,
+ ((i % (target_width // image_size)) + 1) * image_size,
+ ((i // (target_width // image_size)) + 1) * image_size
+ )
+ # split the image
+ split_img = resized_img.crop(box)
+ processed_images.append(split_img)
+ assert len(processed_images) == blocks
+ if use_thumbnail and len(processed_images) != 1:
+ thumbnail_img = image.resize((image_size, image_size))
+ processed_images.append(thumbnail_img)
+ return processed_images, target_aspect_ratio
+
+
+def dynamic_preprocess2(image, min_num=1, max_num=6, image_size=448, use_thumbnail=False, prior_aspect_ratio=None):
+ orig_width, orig_height = image.size
+ aspect_ratio = orig_width / orig_height
+
+ # calculate the existing image aspect ratio
+ target_ratios = set(
+ (i, j) for n in range(min_num, max_num + 1) for i in range(1, n + 1) for j in range(1, n + 1) if
+ i * j <= max_num and i * j >= min_num)
+ target_ratios = sorted(target_ratios, key=lambda x: x[0] * x[1])
+
+ new_target_ratios = []
+ if prior_aspect_ratio is not None:
+ for i in target_ratios:
+ if prior_aspect_ratio[0] % i[0] != 0 or prior_aspect_ratio[1] % i[1] != 0:
+ new_target_ratios.append(i)
+ else:
+ continue
+ # find the closest aspect ratio to the target
+ target_aspect_ratio = find_closest_aspect_ratio(
+ aspect_ratio, new_target_ratios, orig_width, orig_height, image_size)
+
+ # calculate the target width and height
+ target_width = image_size * target_aspect_ratio[0]
+ target_height = image_size * target_aspect_ratio[1]
+ blocks = target_aspect_ratio[0] * target_aspect_ratio[1]
+
+ # resize the image
+ resized_img = image.resize((target_width, target_height))
+ processed_images = []
+ for i in range(blocks):
+ box = (
+ (i % (target_width // image_size)) * image_size,
+ (i // (target_width // image_size)) * image_size,
+ ((i % (target_width // image_size)) + 1) * image_size,
+ ((i // (target_width // image_size)) + 1) * image_size
+ )
+ # split the image
+ split_img = resized_img.crop(box)
+ processed_images.append(split_img)
+ assert len(processed_images) == blocks
+ if use_thumbnail and len(processed_images) != 1:
+ thumbnail_img = image.resize((image_size, image_size))
+ processed_images.append(thumbnail_img)
+ return processed_images
+
+
+def load_image(image_file, input_size=448, min_num=1, max_num=6):
+ image = Image.open(image_file).convert('RGB')
+ transform = build_transform(input_size=input_size)
+ images, target_aspect_ratio = dynamic_preprocess(
+ image, image_size=input_size, use_thumbnail=True, min_num=min_num, max_num=max_num)
+ pixel_values = [transform(image) for image in images]
+ pixel_values = torch.stack(pixel_values)
+ return pixel_values, target_aspect_ratio
+
+
+def load_image2(image_file, input_size=448, target_aspect_ratio=(1, 1), min_num=1, max_num=6):
+ image = Image.open(image_file).convert('RGB')
+ transform = build_transform(input_size=input_size)
+ images = dynamic_preprocess2(
+ image,
+ image_size=input_size,
+ prior_aspect_ratio=target_aspect_ratio,
+ use_thumbnail=True,
+ min_num=min_num,
+ max_num=max_num)
+
+ pixel_values = [transform(image) for image in images]
+ pixel_values = torch.stack(pixel_values)
+ return pixel_values
+
+
+# This function is used to split InternVL2-Llama3-76B
+def split_model(model_name):
+ import math
+ device_map = {}
+ num_gpus = torch.cuda.device_count()
+ rank, world_size = get_rank_and_world_size()
+ num_gpus = num_gpus // world_size
+
+ num_layers = {'InternVL2-8B': 32, 'InternVL2-26B': 48,
+ 'InternVL2-40B': 60, 'InternVL2-Llama3-76B': 80}[model_name]
+ # Since the first GPU will be used for ViT, treat it as 0.8 GPU.
+ num_layers_per_gpu = math.ceil(num_layers / (num_gpus - 0.2))
+ num_layers_per_gpu = [num_layers_per_gpu] * num_gpus
+ num_layers_per_gpu[0] = math.ceil(num_layers_per_gpu[0] * 0.8)
+ layer_cnt = 0
+ for i, num_layer in enumerate(num_layers_per_gpu):
+ for j in range(num_layer):
+ device_map[f'language_model.model.layers.{layer_cnt}'] = rank + world_size * i
+ layer_cnt += 1
+ device_map['vision_model'] = rank
+ device_map['mlp1'] = rank
+ device_map['language_model.model.tok_embeddings'] = rank
+ device_map['language_model.model.embed_tokens'] = rank
+ device_map['language_model.output'] = rank
+ device_map['language_model.model.norm'] = rank
+ device_map['language_model.lm_head'] = rank
+ device_map[f'language_model.model.layers.{num_layers - 1}'] = rank
+ return device_map
+
+
+# To revert changes
+class MiniMonkey(BaseModel):
+
+ INSTALL_REQ = False
+ INTERLEAVE = True
+
+ def __init__(self, model_path='mx262/MiniMokney', load_in_8bit=False, **kwargs):
+ assert model_path is not None
+ assert version_cmp(transformers.__version__, '4.36.2', 'ge')
+
+ self.model_path = model_path
+ self.tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True, use_fast=False)
+
+ # Regular expression to match the pattern 'Image' followed by a number, e.g. Image1
+ self.pattern = r'Image(\d+)'
+ # Replacement pattern to insert a hyphen between 'Image' and the number, e.g. Image-1
+ self.replacement = r'Image-\1'
+
+ # Convert InternVL2 response to dataset format
+ # e.g. Image1 -> Image-1
+
+ # Regular expression to match the pattern 'Image-' followed by a number
+ self.reverse_pattern = r'Image-(\d+)'
+ # Replacement pattern to remove the hyphen (Image-1 -> Image1)
+ self.reverse_replacement = r'Image\1'
+
+ if listinstr(['InternVL2-Llama3-76B'], model_path):
+ device_map = split_model(model_path.split('/')[-1])
+ self.model = AutoModel.from_pretrained(
+ model_path,
+ torch_dtype=torch.bfloat16,
+ load_in_8bit=load_in_8bit,
+ trust_remote_code=True,
+ low_cpu_mem_usage=True,
+ device_map=device_map).eval()
+ else:
+ device = torch.cuda.current_device()
+ self.device = device
+ self.model = AutoModel.from_pretrained(
+ model_path,
+ torch_dtype=torch.bfloat16,
+ trust_remote_code=True,
+ load_in_8bit=load_in_8bit).eval()
+ if not load_in_8bit:
+ self.model = self.model.to(device)
+
+ self.image_size = self.model.config.vision_config.image_size
+ self.kwargs = kwargs
+ warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ')
+
+ def use_custom_prompt(self, dataset):
+ if dataset is None:
+ return False
+ if listinstr(['MMDU'], dataset):
+ # For Multi-Turn we don't have custom prompt
+ return False
+ else:
+ return True
+
+ def build_multi_choice_prompt(self, line, dataset=None):
+ question = line['question']
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ if hint is not None:
+ question = hint + '\n' + question
+
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ for key, item in options.items():
+ question += f'\n{key}. {item}'
+ prompt = question
+
+ if len(options):
+ prompt += '\n请直接回答选项字母。' if cn_string(
+ prompt) else "\nAnswer with the option's letter from the given choices directly."
+ else:
+ prompt += '\n请直接回答问题。' if cn_string(prompt) else '\nAnswer the question directly.'
+
+ return prompt
+
+ def build_video_prompt(self, prompt, dataset=None, max_nframe=64):
+ for start in range(0, max_nframe, 8):
+ images_to_remove = ''.join([f'' for i in range(start + 1, start + 9)])
+ prompt = prompt.replace(images_to_remove, '')
+ for i in range(max_nframe):
+ prompt = prompt.replace(f'', f'Frame{i + 1}')
+ if listinstr(['MMBench-Video'], dataset):
+ prompt = prompt.replace('\nAnswer:', '')
+ prompt += '\nAnswer the question using a single word or phrase.'
+ elif listinstr(['Video-MME'], dataset):
+ prompt = prompt.replace('\nAnswer:', '')
+ prompt += "\nAnswer with the option's letter from the given choices directly."
+ return prompt
+
+ def build_prompt(self, line, dataset=None):
+ assert self.use_custom_prompt(dataset)
+ assert dataset is None or isinstance(dataset, str)
+ tgt_path = self.dump_image(line, dataset)
+ kwargs_default = dict(do_sample=False, max_new_tokens=512, top_p=None, num_beams=1)
+ self.kwargs = kwargs_default
+
+ if dataset is not None and listinstr(['MME'], dataset):
+ question = line['question']
+ prompt = question + ' Answer the question using a single word or phrase.'
+ elif dataset is not None and listinstr(['HallusionBench'], dataset):
+ question = line['question']
+ prompt = question + ' Please answer yes or no. Answer the question using a single word or phrase.'
+ elif dataset is not None and DATASET_TYPE(dataset) == 'MCQ':
+ prompt = self.build_multi_choice_prompt(line, dataset)
+ elif dataset is not None and DATASET_TYPE(dataset) == 'VQA':
+ if listinstr(['MathVista', 'MathVision'], dataset):
+ prompt = line['question']
+ elif listinstr(['LLaVABench'], dataset):
+ question = line['question']
+ prompt = question + '\nAnswer this question in detail.'
+ elif listinstr(['MMVet'], dataset):
+ prompt = line['question']
+ else:
+ question = line['question']
+ prompt = question + '\nAnswer the question using a single word or phrase.'
+ else:
+ prompt = line['question']
+ message = [dict(type='text', value=prompt)]
+ message.extend([dict(type='image', value=s) for s in tgt_path])
+ return message
+
+ def set_max_num(self, dataset):
+ if dataset is None:
+ self.max_num = 12
+ self.max_num2 = 7
+ self.min_num = 4
+ self.min_num2 = 3
+ return
+
+ if dataset is not None and listinstr(['ChartQA_TEST'], dataset):
+ self.max_num = 12
+ self.max_num2 = 3
+ elif dataset is not None and listinstr(['DocVQA_VAL', 'DocVQA_TEST', 'TextVQA_VAL'], dataset):
+ self.max_num = 23
+ self.max_num2 = 15
+ self.min_num = 14
+ self.min_num2 = 5
+ elif dataset is not None and listinstr(['InfoVQA_VAL', 'InfoVQA_TEST', 'SEEDBench_IMG'], dataset):
+ self.max_num = 23
+ self.max_num2 = 5
+ self.min_num = 15
+ self.min_num2 = 3
+ elif dataset is not None and listinstr(['OCRBench', 'POPE'], dataset):
+ self.max_num = 24
+ self.max_num2 = 8
+ self.min_num = 9
+ self.min_num2 = 5
+ elif dataset is not None and listinstr(['HallusionBench'], dataset):
+ self.max_num = 11
+ self.max_num2 = 6
+ self.min_num = 4
+ self.min_num2 = 2
+ elif dataset is not None and listinstr(['MME'], dataset):
+ self.max_num = 11
+ self.max_num2 = 6
+ self.min_num = 5
+ self.min_num2 = 2
+ elif dataset is not None and listinstr(['AI2D_TEST'], dataset):
+ self.max_num = 12
+ self.max_num2 = 6
+ self.min_num = 5
+ self.min_num2 = 2
+ elif dataset is not None and listinstr(['CCBench'], dataset):
+ self.max_num = 24
+ self.max_num2 = 8
+ self.min_num = 9
+ self.min_num2 = 4
+ elif dataset is not None and listinstr(['MMMU_DEV_VAL'], dataset):
+ self.max_num = 12
+ self.max_num2 = 7
+ self.min_num = 5
+ self.min_num2 = 3
+ else:
+ self.max_num = 12
+ self.max_num2 = 7
+ self.min_num = 4
+ self.min_num2 = 3
+
+ def generate_v2(self, message, dataset=None):
+ image_num = len([x for x in message if x['type'] == 'image'])
+ if image_num == 1:
+ prompt = '\n' + '\n'.join([x['value'] for x in message if x['type'] == 'text'])
+ else:
+ prompt, image_idx = '', 1
+ for x in message:
+ if x['type'] == 'text':
+ prompt += x['value']
+ elif x['type'] == 'image':
+ prompt += f''
+ image_idx += 1
+ prompt = ' '.join([f': ' for i in range(image_num)]) + '\n' + prompt
+
+ if dataset is not None and listinstr(['Video'], dataset):
+ prompt = self.build_video_prompt(prompt, dataset)
+
+ if image_num > 1:
+ image_path = [x['value'] for x in message if x['type'] == 'image']
+ num_patches_list = []
+ pixel_values_list = []
+ for image_idx, file_name in enumerate(image_path):
+ curr_pixel_values, target_aspect_ratio = load_image(
+ file_name, min_num=self.min_num, max_num=self.max_num)
+ curr_pixel_values = curr_pixel_values.cuda().to(torch.bfloat16)
+ curr_pixel_values2 = load_image2(
+ file_name, target_aspect_ratio=target_aspect_ratio, min_num=self.min_num2, max_num=self.max_num2)
+ curr_pixel_values2 = curr_pixel_values2.cuda().to(torch.bfloat16)
+ curr_pixel_values = torch.cat(
+ (curr_pixel_values[:-1], curr_pixel_values2[:-1], curr_pixel_values[-1:]), 0)
+ num_patches_list.append(curr_pixel_values.size(0))
+ pixel_values_list.append(curr_pixel_values)
+ pixel_values = torch.cat(pixel_values_list, dim=0)
+ elif image_num == 1:
+ image_path = [x['value'] for x in message if x['type'] == 'image'][0]
+ pixel_values, target_aspect_ratio = load_image(image_path, min_num=self.min_num, max_num=self.max_num)
+ pixel_values = pixel_values.cuda().to(torch.bfloat16)
+ pixel_values2 = load_image2(
+ image_path, target_aspect_ratio=target_aspect_ratio, min_num=self.min_num2, max_num=self.max_num2)
+ pixel_values2 = pixel_values2.cuda().to(torch.bfloat16)
+ pixel_values = torch.cat((pixel_values[:-1], pixel_values2[:-1], pixel_values[-1:]), 0)
+ num_patches_list = [pixel_values.size(0)]
+ else:
+ pixel_values = None
+ num_patches_list = []
+
+ with torch.no_grad():
+ response = self.model.chat(
+ self.tokenizer,
+ pixel_values=pixel_values,
+ target_aspect_ratio=(1, 1),
+ num_patches_list=num_patches_list,
+ question=prompt,
+ generation_config=self.kwargs,
+ verbose=False
+ )
+ return response
+
+ def generate_inner(self, message, dataset=None):
+ self.set_max_num(dataset)
+ return self.generate_v2(message, dataset)
+
+ def build_history(self, message):
+ # Global Variables
+ image_path = []
+ image_cnt = 0
+
+ def concat_tilist(tilist):
+ nonlocal image_cnt # Declare image_cnt as nonlocal to modify it
+ prompt = ''
+ for item in tilist:
+ # Substitute the pattern in the text
+ if item['type'] == 'text':
+ prompt += re.sub(self.pattern, self.replacement, item['value'])
+ elif item['type'] == 'image':
+ image_cnt += 1
+ prompt += '\n'
+ image_path.append(item['value'])
+ return prompt
+
+ # Only previous messages
+ assert len(message) % 2 == 0
+ history = []
+ for i in range(len(message) // 2):
+ m1, m2 = message[2 * i], message[2 * i + 1]
+ assert m1['role'] == 'user' and m2['role'] == 'assistant'
+ history.append((concat_tilist(m1['content']), concat_tilist(m2['content'])))
+
+ return history, image_path, image_cnt
+
+ def chat_inner_v2(self, message, dataset=None):
+
+ image_cnt = 0
+ if len(message) > 1:
+ history, image_path, image_cnt = self.build_history(message[:-1])
+ else:
+ history, image_path, image_cnt = None, [], 1
+ current_msg = message[-1]
+ question = ''
+
+ # If message is just text in the conversation
+ if len(current_msg['content']) == 1 and current_msg['content'][0]['type'] == 'text':
+ question = current_msg['content'][0]['value']
+ question = re.sub(self.pattern, self.replacement, question) # Fix pattern as per InternVL
+ else:
+ for msg in current_msg['content']:
+ if msg['type'] == 'text':
+ question += re.sub(self.pattern, self.replacement, msg['value'])
+ elif msg['type'] == 'image':
+ image_cnt += 1
+ question += '\n'
+ image_path.append(msg['value'])
+
+ if image_cnt > 1:
+ num_patches_list = []
+ pixel_values_list = []
+ for image_idx, file_name in enumerate(image_path):
+ curr_pixel_values, target_aspect_ratio = load_image(
+ file_name, min_num=self.min_num, max_num=self.max_num)
+ curr_pixel_values = curr_pixel_values.cuda().to(torch.bfloat16)
+ curr_pixel_values2 = load_image2(
+ file_name, target_aspect_ratio=target_aspect_ratio, min_num=self.min_num2, max_num=self.max_num2)
+ curr_pixel_values2 = curr_pixel_values2.cuda().to(torch.bfloat16)
+ curr_pixel_values = torch.cat(
+ (curr_pixel_values[:-1], curr_pixel_values2[:-1], curr_pixel_values[-1:]), 0)
+ num_patches_list.append(curr_pixel_values.size(0))
+ pixel_values_list.append(curr_pixel_values)
+ pixel_values = torch.cat(pixel_values_list, dim=0)
+ elif image_cnt == 1:
+ pixel_values, target_aspect_ratio = load_image(image_path, min_num=self.min_num, max_num=self.max_num)
+ pixel_values = pixel_values.cuda().to(torch.bfloat16)
+ pixel_values2 = load_image2(
+ image_path, target_aspect_ratio=target_aspect_ratio, min_num=self.min_num2, max_num=self.max_num2)
+ pixel_values2 = pixel_values2.cuda().to(torch.bfloat16)
+ pixel_values = torch.cat((pixel_values[:-1], pixel_values2[:-1], pixel_values[-1:]), 0)
+ num_patches_list = [pixel_values.size(0)]
+ else:
+ pixel_values = None
+ num_patches_list = []
+
+ response, history = self.model.chat(
+ self.tokenizer,
+ pixel_values=pixel_values,
+ target_aspect_ratio=target_aspect_ratio,
+ num_patches_list=num_patches_list,
+ question=question,
+ generation_config=self.kwargs,
+ history=history,
+ return_history=True
+ )
+
+ response = re.sub(self.reverse_pattern, self.reverse_replacement, response)
+
+ return response
+
+ def chat_inner(self, message, dataset=None):
+ self.set_max_num(dataset)
+ kwargs_default = dict(do_sample=False, max_new_tokens=512, top_p=None, num_beams=1)
+ self.kwargs = kwargs_default
+ return self.chat_inner_v2(message, dataset)
diff --git a/vlmeval/vlm/misc/blip2_instruct_vicuna13b.yaml b/vlmeval/vlm/misc/blip2_instruct_vicuna13b.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..a7cebe598616ab21908562301d44f2e4546ce0cf
--- /dev/null
+++ b/vlmeval/vlm/misc/blip2_instruct_vicuna13b.yaml
@@ -0,0 +1,43 @@
+ # Copyright (c) 2022, salesforce.com, inc.
+ # All rights reserved.
+ # SPDX-License-Identifier: BSD-3-Clause
+ # For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+
+model:
+ arch: instruct_vicuna13b
+ load_finetuned: False
+ load_pretrained: True
+
+ pretrained: "https://storage.googleapis.com/sfr-vision-language-research/LAVIS/models/InstructBLIP/instruct_blip_vicuna13b_trimmed.pth"
+ finetuned: ""
+
+ # vit encoder
+ image_size: 224
+ drop_path_rate: 0
+ use_grad_checkpoint: False
+ vit_precision: "fp16"
+ freeze_vit: True
+
+ # Q-Former
+ num_query_token: 32
+
+ # path to Vicuna checkpoint
+ llm_model: "Please set the path to your vicuna-13b-v1.1"
+
+ # generation configs
+ prompt: ""
+
+
+preprocess:
+ vis_processor:
+ train:
+ name: "blip2_image_train"
+ image_size: 224
+ eval:
+ name: "blip_image_eval"
+ image_size: 224
+ text_processor:
+ train:
+ name: "blip_caption"
+ eval:
+ name: "blip_caption"
diff --git a/vlmeval/vlm/misc/blip2_instruct_vicuna7b.yaml b/vlmeval/vlm/misc/blip2_instruct_vicuna7b.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..2a57a02ebeecfa5e345005456302925fb8f1c655
--- /dev/null
+++ b/vlmeval/vlm/misc/blip2_instruct_vicuna7b.yaml
@@ -0,0 +1,43 @@
+ # Copyright (c) 2022, salesforce.com, inc.
+ # All rights reserved.
+ # SPDX-License-Identifier: BSD-3-Clause
+ # For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+
+model:
+ arch: instruct_vicuna7b
+ load_finetuned: False
+ load_pretrained: True
+
+ pretrained: "https://storage.googleapis.com/sfr-vision-language-research/LAVIS/models/InstructBLIP/instruct_blip_vicuna7b_trimmed.pth"
+ finetuned: ""
+
+ # vit encoder
+ image_size: 224
+ drop_path_rate: 0
+ use_grad_checkpoint: False
+ vit_precision: "fp16"
+ freeze_vit: True
+
+ # Q-Former
+ num_query_token: 32
+
+ # path to Vicuna checkpoint
+ llm_model: "Please set the path to your vicuna-7b-v1.1"
+
+ # generation configs
+ prompt: ""
+
+
+preprocess:
+ vis_processor:
+ train:
+ name: "blip2_image_train"
+ image_size: 224
+ eval:
+ name: "blip_image_eval"
+ image_size: 224
+ text_processor:
+ train:
+ name: "blip_caption"
+ eval:
+ name: "blip_caption"
diff --git a/vlmeval/vlm/misc/minigpt4_13b_eval.yaml b/vlmeval/vlm/misc/minigpt4_13b_eval.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..ae3d08be11b36e0e78ef52274437877b1be7167c
--- /dev/null
+++ b/vlmeval/vlm/misc/minigpt4_13b_eval.yaml
@@ -0,0 +1,37 @@
+model:
+ arch: minigpt4
+ model_type: pretrain_vicuna_7b
+ max_txt_len: 160
+ end_sym: "###"
+ low_resource: True
+ prompt_template: '###Human: {} ###Assistant: '
+ ckpt: "please set this value to the path of pretrained checkpoint"
+
+ # vit encoder
+ image_size: 224
+ drop_path_rate: 0
+ use_grad_checkpoint: False
+ vit_precision: "fp16"
+ freeze_vit: True
+ freeze_qformer: True
+
+ # Q-Former
+ num_query_token: 32
+
+ # generation configs
+ prompt: ""
+
+ llama_model: "please set this value to the path of vicuna-13b-v0"
+
+datasets:
+ cc_sbu_align:
+ vis_processor:
+ train:
+ name: "blip2_image_eval"
+ image_size: 224
+ text_processor:
+ train:
+ name: "blip_caption"
+
+run:
+ task: image_text_pretrain
diff --git a/vlmeval/vlm/misc/minigpt4_7b_eval.yaml b/vlmeval/vlm/misc/minigpt4_7b_eval.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..062c93a9c3a1c56294824e2a2772ab3c3abe1932
--- /dev/null
+++ b/vlmeval/vlm/misc/minigpt4_7b_eval.yaml
@@ -0,0 +1,38 @@
+model:
+ arch: minigpt4
+ model_type: pretrain_vicuna_7b
+ max_txt_len: 160
+ end_sym: "###"
+ low_resource: True
+ prompt_template: '###Human: {} ###Assistant: '
+ ckpt: "please set this value to the path of pretrained checkpoint"
+
+ # vit encoder
+ image_size: 224
+ drop_path_rate: 0
+ use_grad_checkpoint: False
+ vit_precision: "fp16"
+ freeze_vit: True
+ freeze_qformer: True
+
+ # Q-Former
+ num_query_token: 32
+
+ # generation configs
+ prompt: ""
+
+ llama_model: "please set this value to the path of vicuna-7b-v0"
+
+
+datasets:
+ cc_sbu_align:
+ vis_processor:
+ train:
+ name: "blip2_image_eval"
+ image_size: 224
+ text_processor:
+ train:
+ name: "blip_caption"
+
+run:
+ task: image_text_pretrain
diff --git a/vlmeval/vlm/misc/minigptv2_eval.yaml b/vlmeval/vlm/misc/minigptv2_eval.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..32815e1b9de21fbfcfc4ea459e95306fd9e42d95
--- /dev/null
+++ b/vlmeval/vlm/misc/minigptv2_eval.yaml
@@ -0,0 +1,36 @@
+model:
+ arch: minigpt_v2
+ model_type: pretrain
+ max_txt_len: 160
+ end_sym: ""
+ low_resource: True
+ prompt_template: '[INST] {} [/INST]'
+ ckpt: "please set this value to the path of pretrained checkpoint"
+ lora_r: 64
+ lora_alpha: 16
+
+ # vit encoder
+ image_size: 448
+ drop_path_rate: 0
+ use_grad_checkpoint: False
+ vit_precision: "fp16"
+ freeze_vit: True
+
+ # generation configs
+ prompt: ""
+
+ # LLM
+ llama_model: "please set this value to the path of llama2-chat-7b"
+
+datasets:
+ cc_sbu_align:
+ vis_processor:
+ train:
+ name: "blip2_image_eval"
+ image_size: 448
+ text_processor:
+ train:
+ name: "blip_caption"
+
+run:
+ task: image_text_pretrain
diff --git a/vlmeval/vlm/mixsense.py b/vlmeval/vlm/mixsense.py
new file mode 100644
index 0000000000000000000000000000000000000000..154c494a630b4ea65a9155263767b6d5a29b7e6a
--- /dev/null
+++ b/vlmeval/vlm/mixsense.py
@@ -0,0 +1,46 @@
+import torch
+import transformers
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from PIL import Image
+import warnings
+
+from .base import BaseModel
+from ..smp import *
+
+
+class LLama3Mixsense(BaseModel):
+
+ INSTALL_REQ = False
+ INTERLEAVE = False
+
+ def __init__(self, model_path='Zero-Vision/Llama-3-MixSenseV1_1', **kwargs):
+ assert model_path is not None
+ transformers.logging.set_verbosity_error()
+ transformers.logging.disable_progress_bar()
+ warnings.filterwarnings('ignore')
+ self.tokenizer = AutoTokenizer.from_pretrained(
+ model_path, trust_remote_code=True
+ )
+ self.model = AutoModelForCausalLM.from_pretrained(
+ model_path, trust_remote_code=True
+ ).to('cuda').eval()
+ self.kwargs = kwargs
+
+ def generate_inner(self, message, dataset=None):
+ prompt, image_path = self.message_to_promptimg(message)
+ input_ids = self.model.text_process(prompt, self.tokenizer).to(device='cuda')
+ image = Image.open(image_path).convert('RGB')
+ image_tensor = self.model.image_process([image]).to(dtype=self.model.dtype, device='cuda')
+ # generate
+ with torch.inference_mode():
+ output_ids = self.model.generate(
+ input_ids,
+ images=image_tensor,
+ max_new_tokens=2048,
+ use_cache=True,
+ eos_token_id=[
+ self.tokenizer.eos_token_id,
+ self.tokenizer.convert_tokens_to_ids(['<|eot_id|>'])[0],
+ ],
+ )
+ return self.tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0].strip()
diff --git a/vlmeval/vlm/mmalaya.py b/vlmeval/vlm/mmalaya.py
new file mode 100644
index 0000000000000000000000000000000000000000..fa60e1977aced654748ea6f864fa9628fd42be8f
--- /dev/null
+++ b/vlmeval/vlm/mmalaya.py
@@ -0,0 +1,379 @@
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer, AutoModel
+import warnings
+from .base import BaseModel
+from PIL import Image
+from ..smp import *
+from ..dataset import DATASET_TYPE
+import pandas as pd
+import string
+import torchvision.transforms as T
+import transformers
+
+from torchvision.transforms.functional import InterpolationMode
+
+
+class MMAlaya(BaseModel):
+
+ INSTALL_REQ = False
+ INTERLEAVE = False
+
+ def __init__(self, model_path='DataCanvas/MMAlaya', **kwargs):
+ assert model_path is not None
+ self.model_path = model_path
+ self.tokenizer = AutoTokenizer.from_pretrained(
+ model_path, trust_remote_code=True
+ )
+ model = AutoModelForCausalLM.from_pretrained(
+ model_path, device_map='cpu', trust_remote_code=True
+ ).eval()
+ # need initialize tokenizer
+ model.initialize_tokenizer(self.tokenizer)
+ self.model = model.cuda()
+
+ self.kwargs = kwargs
+ warnings.warn(
+ f'Following kwargs received: {self.kwargs}, will use as generation config. '
+ )
+ torch.cuda.empty_cache()
+
+ def generate_inner(self, message, dataset=None):
+ # read image
+ prompt, image_path = self.message_to_promptimg(message, dataset=dataset)
+ image = Image.open(image_path).convert('RGB')
+ # tokenize prompt, and proprecess image
+ input_ids, image_tensor, stopping_criteria = self.model.prepare_for_inference(
+ prompt, self.tokenizer, image, return_tensors='pt'
+ )
+ with torch.inference_mode():
+ output_ids = self.model.generate(
+ inputs=input_ids.cuda(),
+ images=image_tensor.cuda(),
+ do_sample=False,
+ max_new_tokens=512,
+ num_beams=1,
+ use_cache=True,
+ stopping_criteria=[stopping_criteria],
+ )
+ # truncate input_ids in generate_ids and then decode to text
+ input_token_len = input_ids.shape[1]
+ response = self.tokenizer.batch_decode(
+ output_ids[:, input_token_len:].cpu(),
+ skip_special_tokens=True,
+ clean_up_tokenization_spaces=False,
+ )[0].strip()
+ return response
+
+
+IMAGENET_MEAN = (0.485, 0.456, 0.406)
+IMAGENET_STD = (0.229, 0.224, 0.225)
+
+
+def build_transform(input_size):
+ MEAN, STD = IMAGENET_MEAN, IMAGENET_STD
+ transform = T.Compose(
+ [
+ T.Lambda(lambda img: img.convert('RGB') if img.mode != 'RGB' else img),
+ T.Resize((input_size, input_size), interpolation=InterpolationMode.BICUBIC),
+ T.ToTensor(),
+ T.Normalize(mean=MEAN, std=STD),
+ ]
+ )
+ return transform
+
+
+def find_closest_aspect_ratio(aspect_ratio, target_ratios, width, height, image_size):
+ best_ratio_diff = float('inf')
+ best_ratio = (1, 1)
+ area = width * height
+ for ratio in target_ratios:
+ target_aspect_ratio = ratio[0] / ratio[1]
+ ratio_diff = abs(aspect_ratio - target_aspect_ratio)
+ if ratio_diff < best_ratio_diff:
+ best_ratio_diff = ratio_diff
+ best_ratio = ratio
+ elif ratio_diff == best_ratio_diff:
+ if area > 0.5 * image_size * image_size * ratio[0] * ratio[1]:
+ best_ratio = ratio
+ return best_ratio
+
+
+def dynamic_preprocess(
+ image, min_num=1, max_num=6, image_size=448, use_thumbnail=False
+):
+ orig_width, orig_height = image.size
+ aspect_ratio = orig_width / orig_height
+
+ # calculate the existing image aspect ratio
+ target_ratios = set(
+ (i, j)
+ for n in range(min_num, max_num + 1)
+ for i in range(1, n + 1)
+ for j in range(1, n + 1)
+ if i * j <= max_num and i * j >= min_num
+ )
+ target_ratios = sorted(target_ratios, key=lambda x: x[0] * x[1])
+
+ # find the closest aspect ratio to the target
+ target_aspect_ratio = find_closest_aspect_ratio(
+ aspect_ratio, target_ratios, orig_width, orig_height, image_size
+ )
+
+ # calculate the target width and height
+ target_width = image_size * target_aspect_ratio[0]
+ target_height = image_size * target_aspect_ratio[1]
+ blocks = target_aspect_ratio[0] * target_aspect_ratio[1]
+
+ # resize the image
+ resized_img = image.resize((target_width, target_height))
+ processed_images = []
+ for i in range(blocks):
+ box = (
+ (i % (target_width // image_size)) * image_size,
+ (i // (target_width // image_size)) * image_size,
+ ((i % (target_width // image_size)) + 1) * image_size,
+ ((i // (target_width // image_size)) + 1) * image_size,
+ )
+ # split the image
+ split_img = resized_img.crop(box)
+ processed_images.append(split_img)
+ assert len(processed_images) == blocks
+ if use_thumbnail and len(processed_images) != 1:
+ thumbnail_img = image.resize((image_size, image_size))
+ processed_images.append(thumbnail_img)
+ return processed_images
+
+
+def load_image(image_file, input_size=448, max_num=6, upscale=False):
+ image = Image.open(image_file).convert('RGB')
+ if upscale:
+ image = image.resize((image.width * 2, image.height * 2), Image.BILINEAR)
+ transform = build_transform(input_size=input_size)
+ images = dynamic_preprocess(
+ image, image_size=input_size, use_thumbnail=True, max_num=max_num
+ )
+ pixel_values = [transform(image) for image in images]
+ pixel_values = torch.stack(pixel_values)
+ return pixel_values
+
+
+# This function is used to split InternVL2-Llama3-76B
+def split_model(model_name):
+ import math
+ device_map = {}
+ num_gpus = torch.cuda.device_count()
+ rank, world_size = get_rank_and_world_size()
+ num_gpus = num_gpus // world_size
+ assert num_gpus >= 1
+ if num_gpus == 1:
+ return device_map
+
+ num_layers = {'InternVL2-8B': 32, 'InternVL2-26B': 48,
+ 'InternVL2-40B': 60, 'InternVL2-Llama3-76B': 80}[model_name]
+ # Since the first GPU will be used for ViT, treat it as 0.5 GPU.
+ num_layers_per_gpu = math.ceil(num_layers / (num_gpus - 0.5))
+ num_layers_per_gpu = [num_layers_per_gpu] * num_gpus
+ num_layers_per_gpu[0] = math.ceil(num_layers_per_gpu[0] * 0.5)
+ layer_cnt = 0
+ for i, num_layer in enumerate(num_layers_per_gpu):
+ for j in range(num_layer):
+ device_map[f'language_model.model.layers.{layer_cnt}'] = rank + world_size * i
+ layer_cnt += 1
+ device_map['vision_model'] = rank
+ device_map['mlp1'] = rank
+ device_map['language_model.model.tok_embeddings'] = rank
+ device_map['language_model.model.embed_tokens'] = rank
+ device_map['language_model.output'] = rank
+ device_map['language_model.model.norm'] = rank
+ device_map['language_model.lm_head'] = rank
+ device_map[f'language_model.model.layers.{num_layers - 1}'] = rank
+ return device_map
+
+
+class MMAlaya2(BaseModel):
+ """
+ This implementation fine-tunes 20 LoRA modules based on the InternVL-Chat-V1-5 model.
+ The fine-tuned LoRA modules are then merged with the InternVL-Chat-V1-5 model
+ using the PEFT model merging method, TIES.
+ The code is based on the implementation in `vlmeval/vlm/internvl_chat.py`.
+ """
+
+ INSTALL_REQ = False
+ INTERLEAVE = True
+
+ def __init__(
+ self,
+ model_path='DataCanvas/MMAlaya2',
+ load_in_8bit=False,
+ **kwargs,
+ ):
+ assert model_path is not None
+ assert version_cmp(transformers.__version__, '4.36.2', 'ge')
+
+ self.model_path = model_path
+ self.tokenizer = AutoTokenizer.from_pretrained(
+ model_path, trust_remote_code=True, use_fast=False
+ )
+
+ # Regular expression to match the pattern "Image" followed by a number, e.g. Image1
+ self.pattern = r'Image(\d+)'
+ # Replacement pattern to insert a hyphen between "Image" and the number, e.g. Image-1
+ self.replacement = r'Image-\1'
+
+ # Convert InternVL2 response to dataset format
+ # e.g. Image1 -> Image-1
+
+ # Regular expression to match the pattern "Image-" followed by a number
+ self.reverse_pattern = r'Image-(\d+)'
+ # Replacement pattern to remove the hyphen (Image-1 -> Image1)
+ self.reverse_replacement = r'Image\1'
+
+ device_map = split_model('InternVL2-26B')
+ if len(device_map) == 0:
+ device_map = {'': 'cuda'}
+
+ self.model = AutoModel.from_pretrained(
+ model_path,
+ torch_dtype=torch.bfloat16,
+ trust_remote_code=True,
+ load_in_8bit=load_in_8bit,
+ device_map=device_map
+ ).eval()
+
+ self.image_size = self.model.config.vision_config.image_size
+
+ kwargs_default = dict(
+ do_sample=False, max_new_tokens=1024, top_p=None, num_beams=1
+ )
+ kwargs_default.update(kwargs)
+ self.kwargs = kwargs_default
+ warnings.warn(
+ f'Following kwargs received: {self.kwargs}, will use as generation config. '
+ )
+
+ def use_custom_prompt(self, dataset):
+ assert dataset is not None
+ if listinstr(['MMDU', 'MME-RealWorld', 'MME-RealWorld-CN'], dataset):
+ # For Multi-Turn we don't have custom prompt
+ return False
+ else:
+ return True
+
+ def build_multi_choice_prompt(self, line, dataset=None):
+ question = line['question']
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ if hint is not None:
+ question = hint + '\n' + question
+
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ for key, item in options.items():
+ question += f'\n{key}. {item}'
+ prompt = question
+
+ if len(options):
+ prompt += (
+ '\n请直接回答选项字母。'
+ if cn_string(prompt)
+ else "\nAnswer with the option's letter from the given choices directly."
+ )
+ else:
+ prompt += (
+ '\n请直接回答问题。'
+ if cn_string(prompt)
+ else '\nAnswer the question directly.'
+ )
+
+ return prompt
+
+ def build_prompt(self, line, dataset=None):
+ assert self.use_custom_prompt(dataset)
+ assert dataset is None or isinstance(dataset, str)
+ tgt_path = self.dump_image(line, dataset)
+
+ if dataset is not None and listinstr(['MME'], dataset):
+ question = line['question']
+ prompt = question + ' Answer the question using a single word or phrase.'
+ elif dataset is not None and listinstr(['HallusionBench'], dataset):
+ question = line['question']
+ prompt = (
+ question
+ + ' Please answer yes or no. Answer the question using a single word or phrase.'
+ )
+ elif dataset is not None and DATASET_TYPE(dataset) == 'MCQ':
+ prompt = self.build_multi_choice_prompt(line, dataset)
+ elif dataset is not None and DATASET_TYPE(dataset) == 'VQA':
+ if listinstr(['MathVista', 'MathVision', 'MathVerse'], dataset):
+ prompt = line['question']
+ elif listinstr(['LLaVABench'], dataset):
+ question = line['question']
+ prompt = question + '\nAnswer this question in detail.'
+ elif listinstr(['MMVet'], dataset):
+ prompt = line['question']
+ else:
+ question = line['question']
+ prompt = question + '\nAnswer the question using a single word or phrase.'
+ else:
+ prompt = line['question']
+ message = [dict(type='text', value=prompt)]
+ message.extend([dict(type='image', value=s) for s in tgt_path])
+ return message
+
+ def set_max_num(self, dataset):
+ if dataset is not None and listinstr(['ChartQA_TEST', 'MMMU_DEV_VAL'], dataset):
+ self.max_num = 12
+ elif dataset is not None and listinstr(['DocVQA_VAL', 'DocVQA_TEST'], dataset):
+ self.max_num = 18
+ elif dataset is not None and listinstr(
+ ['InfoVQA_VAL', 'InfoVQA_TEST', 'OCRBench'], dataset
+ ):
+ self.max_num = 24
+ elif dataset is not None and listinstr(
+ ['MMBench-Video', 'Video-MME', 'Video'], dataset
+ ):
+ self.max_num = 1
+ else:
+ self.max_num = 6
+
+ def generate_inner(self, message, dataset=None):
+ self.set_max_num(dataset)
+ image_num = len([x for x in message if x['type'] == 'image'])
+ prompt = '\n'.join([x['value'] for x in message if x['type'] == 'text'])
+
+ if image_num > 1:
+ image_path = [x['value'] for x in message if x['type'] == 'image']
+ pixel_values_list = []
+ max_num = max(1, self.max_num // image_num)
+ for file_name in image_path:
+ pixel_values_list.append(load_image(file_name, max_num=max_num).cuda().to(torch.bfloat16))
+ pixel_values = torch.cat(pixel_values_list, dim=0)
+ elif image_num == 1:
+ image_path = [x['value'] for x in message if x['type'] == 'image'][0]
+ pixel_values = (
+ load_image(image_path, max_num=self.max_num).cuda().to(torch.bfloat16)
+ )
+ else:
+ pixel_values = None
+ with torch.no_grad():
+ response = self.model.chat(
+ self.tokenizer,
+ pixel_values=pixel_values,
+ question=prompt,
+ generation_config=self.kwargs,
+ # verbose=False,
+ )
+ return response
+
+
+if __name__ == '__main__':
+ model = MMAlaya2(max_new_tokens=1024, do_sample=False)
+ response = model.generate_inner(
+ [
+ {'type': 'image', 'value': './assets/apple.jpg'},
+ {'type': 'text', 'value': '请详细描述一下这张图片。'},
+ ]
+ )
+ print(response)
diff --git a/vlmeval/vlm/molmo.py b/vlmeval/vlm/molmo.py
new file mode 100644
index 0000000000000000000000000000000000000000..1227995fcd6e1699c495d55f52f9652025456561
--- /dev/null
+++ b/vlmeval/vlm/molmo.py
@@ -0,0 +1,205 @@
+import torch
+from PIL import Image
+from .base import BaseModel
+from ..smp import *
+from ..dataset import DATASET_TYPE
+
+TYPE_PROMPTS = {
+ 'Y/N':'vqa2:',
+ 'VQA':'vqa2:',
+ 'MCQ':'a_okvqa_mc:',
+}
+
+DATASET_PROMPTS = {
+ 'AI2D_TEST':'ai2_diagram:',
+ 'AI2D_TEST_NO_MASK':'ai2_diagram:',
+ 'COCO_VAL':'coco_captioning:',
+ 'ChartQA_TEST':'chart_qa:',
+ 'ChartQA_VAL':'chart_qa:',
+ 'DocVQA_VAL':'doc_qa:',
+ 'DocVQA_TEST':'doc_qa:',
+ 'InfoVQA_TEST':'info_qa:',
+ 'InfoVQA_VAL':'info_qa:',
+ 'OCRVQA_TEST':'ocr_vqa:',
+ 'OCRVQA_TESTCORE':'ocr_vqa:',
+ 'ScienceQA_VAL':'science_qa:',
+ 'ScienceQA_TEST':'science_qa:',
+ 'TableVQABench':'tabwmp_da:',
+ 'TextVQA_VAL':'text_vqa:'
+}
+
+
+class molmo(BaseModel):
+
+ INSTALL_REQ = False
+ INTERLEAVE = False
+
+ def __init__(self, model_path='allenai/Molmo-7B-D-0924', **kwargs):
+ try:
+ from transformers import AutoModelForCausalLM, AutoProcessor, GenerationConfig
+ import einops
+ except Exception as e:
+ logging.critical('Please install transformer and einops before using molmo.')
+ raise e
+
+ if '72b' not in model_path.lower():
+ self.model = AutoModelForCausalLM.from_pretrained(
+ model_path,
+ trust_remote_code=True,
+ torch_dtype=torch.bfloat16,
+ device_map='cuda')
+ else:
+ self.model = AutoModelForCausalLM.from_pretrained(
+ model_path,
+ trust_remote_code=True,
+ torch_dtype=torch.bfloat16,
+ device_map='auto')
+
+ self.processor = AutoProcessor.from_pretrained(model_path, trust_remote_code=True, torch_dtype=torch.bfloat16)
+ self.kwargs = kwargs
+ self.model_name = model_path
+ # set default maximum number of crops to 36
+ self.max_crops = kwargs.get('max_crops', 36)
+
+ def use_custom_prompt(self, dataset):
+ if DATASET_TYPE(dataset) in ['Y/N', 'MCQ', 'VQA']:
+ return True
+ return False
+
+ def build_prompt(self, line, dataset=None):
+ assert self.use_custom_prompt(dataset)
+ assert dataset is None or isinstance(dataset, str)
+ tgt_path = self.dump_image(line, dataset)
+ prefix = None
+ if dataset in ['MMMU_DEV_VAL', 'MMMU_TEST']:
+ prompt = self.build_prompt_mcq_vqa(line)
+ elif dataset in ['MathVista_MINI']:
+ prompt = self.build_prompt_mathvista(line)
+ elif dataset in ['AI2D_TEST', 'AI2D_TEST_NO_MASK']:
+ prompt = self.build_prompt_ai2d(line)
+ elif dataset is not None and listinstr(list(DATASET_PROMPTS.keys()), dataset):
+ prefix = DATASET_PROMPTS[dataset] # rest of supervised datasets are in VQA format
+ prompt = self.build_prompt_vqa(line, prefix)
+ elif dataset is not None and listinstr(['MCQ'], DATASET_TYPE(dataset)):
+ prompt = self.build_prompt_multiple_choice(line)
+ else:
+ prompt = self.build_prompt_vqa(line)
+
+ message = [dict(type='text', value=prompt)]
+ message.extend([dict(type='image', value=s) for s in tgt_path])
+
+ # interleave dataset
+ if dataset.startswith('MMMU_'):
+ from .. import MMMUDataset
+ message = MMMUDataset.split_MMMU(message)
+ return message
+
+ def build_prompt_mathvista(self, line):
+ if line['question_type'] == 'multi_choice':
+ prompt = self.build_prompt_multiple_choice(line)
+ else:
+ prompt = self.build_prompt_vqa(line)
+ return prompt
+
+ def build_prompt_ai2d(self, line):
+ def option_is_abc(line):
+ for cand in string.ascii_uppercase:
+ if cand in line and not pd.isna(line[cand]):
+ # check if option is single letter
+ if not line[cand].strip().isalpha() or len(line[cand].strip()) > 1:
+ return False
+ return True
+
+ if line['abcLabel'] and option_is_abc(line):
+ prompt = line['question']
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ for key, item in options.items():
+ prompt += f'\n{item}'
+ prompt = f"ai2_diagram_no_letter: {prompt}"
+ # prompt = self.build_prompt_multiple_choice(line, prefix='ai2_diagram_no_letter:')
+ else:
+ prompt = self.build_prompt_multiple_choice(line, prefix='ai2_diagram:')
+ return prompt
+
+ def build_prompt_mcq_vqa(self, line):
+ if line['question_type'] == 'multiple-choice':
+ prompt = self.build_prompt_multiple_choice(line)
+ else:
+ prompt = self.build_prompt_vqa(line)
+ return prompt
+
+ def build_prompt_multiple_choice(self, line, prefix=None):
+ question = line['question']
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ if hint is not None:
+ question = hint + '\n' + question
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ for key, item in options.items():
+ question += f'\n{key}: {item}'
+ if prefix is None:
+ prompt = f"{TYPE_PROMPTS['MCQ']} {question}"
+ else:
+ prompt = f"{prefix} {question}"
+
+ return prompt
+
+ def build_prompt_vqa(self, line, prefix=None):
+ question = line['question']
+ if prefix is None:
+ prompt = f"{TYPE_PROMPTS['VQA']} {question}"
+ else:
+ prompt = f"{prefix} {question}"
+ return prompt
+
+ def generate_inner(self, message, dataset=None):
+ from transformers import GenerationConfig
+ prompt, image_path = self.message_to_promptimg(message, dataset=dataset)
+
+ image = Image.open(image_path)
+ if image.mode != "RGB":
+ image = image.convert("RGB")
+
+ # process the image and text
+ max_crops = self.max_crops
+ inputs = self.processor.process(
+ images=[image],
+ text=prompt,
+ images_kwargs={
+ "max_crops": max_crops
+ }
+ )
+
+ # move inputs to the correct device and make a batch of size 1
+ inputs = {k: v.to(self.model.device).unsqueeze(0) for k, v in inputs.items()}
+
+ # generate output; maximum 200 new tokens; stop generation when <|endoftext|> is generated
+ with torch.autocast(device_type="cuda", enabled=True, dtype=torch.bfloat16):
+ output = self.model.generate_from_batch(
+ inputs,
+ GenerationConfig(max_new_tokens=200, stop_strings="<|endoftext|>"),
+ tokenizer=self.processor.tokenizer
+ )
+
+ # only get generated tokens; decode them to text
+ generated_tokens = output[0, inputs['input_ids'].size(1):]
+ generated_text = self.processor.tokenizer.decode(generated_tokens, skip_special_tokens=True).strip()
+
+ # AI2D: map direct answer to letter option
+ if dataset in ['AI2D_TEST', 'AI2D_TEST_NO_MASK']:
+ # 'ai2_diagram_no_letter: Which of the following is the magma chamber?\nK\nB\nC\nH'
+ if 'ai2_diagram_no_letter' in prompt:
+ options = prompt.split('\n')[1:]
+ answer = options.index(generated_text)
+ generated_text = chr(answer + ord('A'))
+
+ # print(dataset, prompt, generated_text, inputs['images'].size()) # uncomment to debug
+
+ return generated_text
diff --git a/vlmeval/vlm/monkey.py b/vlmeval/vlm/monkey.py
new file mode 100644
index 0000000000000000000000000000000000000000..f3804777f66f42c367287b2e9584491c6149991a
--- /dev/null
+++ b/vlmeval/vlm/monkey.py
@@ -0,0 +1,165 @@
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import warnings
+from .base import BaseModel
+from ..dataset import DATASET_TYPE
+
+
+class Monkey(BaseModel):
+
+ INSTALL_REQ = False
+ INTERLEAVE = False
+
+ def __init__(self, model_path='echo840/Monkey', **kwargs):
+ assert model_path is not None
+ self.model_path = model_path
+ self.tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
+ model = AutoModelForCausalLM.from_pretrained(model_path, device_map='cpu', trust_remote_code=True).eval()
+ self.model = model.cuda()
+ self.kwargs = kwargs
+ warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ')
+ torch.cuda.empty_cache()
+
+ def generate_vanilla(self, image_path, prompt):
+ cur_prompt = f'\n\nQuestion: {prompt}\n\nAnswer:"
+ answer = self.model.generate(
+ enc_image,
+ prompt_wtmpl,
+ eos_text="",
+ tokenizer=self.tokenizer,
+ **self.kwargs,
+ )[0]
+ cleaned_answer = re.sub("<$", "", re.sub("END$", "", answer)).strip()
+ return cleaned_answer
+
+ def use_custom_prompt(self, dataset):
+ assert dataset is not None
+ if listinstr(["MMMU"], dataset):
+ return False
+ if DATASET_TYPE(dataset) == "MCQ" or dataset in [
+ "MMVet",
+ ]:
+ return True
+
+ return False
+
+ def build_prompt(self, line, dataset=None):
+ assert dataset is None or isinstance(dataset, str)
+ assert self.use_custom_prompt(dataset)
+ tgt_path = self.dump_image(line, dataset)
+ question = line["question"]
+ if dataset == "MMVet":
+ prompt = question + "\nAnswer the question directly. "
+ elif DATASET_TYPE(dataset) == "MCQ":
+ options = {cand: line[cand] for cand in string.ascii_uppercase if cand in line and not pd.isna(line[cand])}
+ options_prompt = ""
+ for key, item in options.items():
+ options_prompt += f"{key}. {item}\n"
+
+ hint = line["hint"] if ("hint" in line and not pd.isna(line["hint"])) else None
+ prompt = f"Hint: {hint}\n" if hint is not None else ""
+ prompt += f"{question}\n"
+ prompt += (
+ f"{options_prompt}\nAnswer with the option’s letter from the given choices directly. "
+ if len(options)
+ else "Answer the question directly. "
+ )
+ else:
+ raise NotImplementedError
+
+ message = [dict(type="text", value=prompt)]
+ message.extend([dict(type="image", value=s) for s in tgt_path])
+ return message
+
+
+class Moondream2(BaseModel):
+ INSTALL_REQ = False
+ INTERLEAVE = False
+
+ def __init__(self, model_path="vikhyatk/moondream2", revision="2025-01-09", **kwargs):
+ try:
+ from transformers import AutoModelForCausalLM, AutoTokenizer
+ except Exception as e:
+ logging.critical(
+ """Please install Transformers version 4.44 by running: "pip install transformers==4.44.0",
+ please intall torchvision>=0.16."""
+ )
+ raise e
+
+ assert osp.exists(model_path) or splitlen(model_path) == 2
+
+ self.model = AutoModelForCausalLM.from_pretrained(
+ model_path,
+ trust_remote_code=True,
+ torch_dtype=torch.float16,
+ device_map={"": "cuda"},
+ revision=revision,
+ )
+
+ self.tokenizer = AutoTokenizer.from_pretrained(model_path)
+
+ default_kwargs = dict(max_new_tokens=512)
+ default_kwargs.update(kwargs)
+ self.kwargs = default_kwargs
+
+ warnings.warn(f"Following kwargs received: {self.kwargs}, will use as generation config. ")
+ torch.cuda.empty_cache()
+
+ def generate_inner(self, message, dataset=None):
+ prompt, img = self.message_to_promptimg(message)
+ enc_image = self.model.encode_image(Image.open(img))
+ print(f"prompt for {dataset} -> ", prompt)
+
+ answer = self.model.query(enc_image, prompt)["answer"]
+ cleaned_answer = answer.strip()
+
+ return cleaned_answer
+
+ def use_custom_prompt(self, dataset):
+ assert dataset is not None
+
+ if listinstr(["MMMU"], dataset):
+ return False
+ if DATASET_TYPE(dataset) == "MCQ":
+ return True
+ elif dataset in [
+ "ChartQA_TEST",
+ "TextVQA_VAL",
+ "DocVQA_VAL",
+ "POPE",
+ "RealWorldQA",
+ "TallyQA",
+ "CountbenchQA",
+ "MMVet",
+ ]:
+ return True
+ else:
+ return False
+
+ def build_prompt(self, line, dataset=None):
+ assert dataset is None or isinstance(dataset, str)
+ assert self.use_custom_prompt(dataset)
+ tgt_path = self.dump_image(line, dataset)
+ question = line["question"]
+
+ if dataset == "ChartQA_TEST":
+ prompt = (
+ "Analyze the chart carefully, consider both visual features and data values,"
+ " and provide a precise answer without any additional explanation or formatting. "
+ + question
+ )
+ elif dataset == "TextVQA_VAL":
+ prompt = (
+ "Read the text in the image and provide a brief lowercase answer. "
+ "Respond 'unanswerable' only if there is no plausible answer. "
+ + question
+ )
+ elif dataset == "DocVQA_VAL":
+ prompt = question + " The answer should be a short text span taken verbatim from the document."
+ elif dataset == "POPE":
+ prompt = f"{question}\nAnswer yes or no."
+ elif dataset == "RealWorldQA":
+ prompt = question
+ elif dataset == "TallyQA" or dataset == "CountbenchQA":
+ prompt = (
+ "Look at the image carefully and count the objects. "
+ "Answer with just a number, without any additional text. "
+ + question
+ )
+
+ elif dataset == "MMVet":
+ prompt = question + "\nAnswer the question directly. "
+ elif DATASET_TYPE(dataset) == "MCQ":
+ options = {cand: line[cand] for cand in string.ascii_uppercase if cand in line and not pd.isna(line[cand])}
+ options_prompt = ""
+ for key, item in options.items():
+ options_prompt += f"{key}. {item}\n"
+
+ hint = line["hint"] if ("hint" in line and not pd.isna(line["hint"])) else None
+ prompt = f"Hint: {hint}\n" if hint is not None else ""
+ prompt += f"{question}\n"
+ prompt += (
+ f"{options_prompt}\nAnswer with the option’s letter from the given choices directly. "
+ if len(options)
+ else "Answer the question directly. "
+ )
+ else:
+ raise NotImplementedError
+
+ message = [dict(type="text", value=prompt)]
+ message.extend([dict(type="image", value=s) for s in tgt_path])
+ return message
diff --git a/vlmeval/vlm/mplug_owl2.py b/vlmeval/vlm/mplug_owl2.py
new file mode 100644
index 0000000000000000000000000000000000000000..30d6adc72dbdacc02c45c409d2890ce49988358c
--- /dev/null
+++ b/vlmeval/vlm/mplug_owl2.py
@@ -0,0 +1,126 @@
+import sys
+import torch
+from PIL import Image
+from .base import BaseModel
+from ..smp import *
+from ..dataset import DATASET_TYPE
+
+
+class mPLUG_Owl2(BaseModel):
+
+ INSTALL_REQ = True
+ INTERLEAVE = False
+
+ def __init__(self, model_path='MAGAer13/mplug-owl2-llama2-7b', **kwargs):
+ try:
+ from mplug_owl2.model.builder import load_pretrained_model
+ from mplug_owl2.mm_utils import get_model_name_from_path
+ except Exception as e:
+ logging.critical('Please install mPLUG_Owl2 before using mPLUG_Owl2. ')
+ raise e
+
+ model_name = get_model_name_from_path(model_path)
+ tokenizer, model, image_processor, context_len = load_pretrained_model(
+ model_path, None, model_name, load_8bit=False, load_4bit=False, device='cpu')
+
+ self.model = model.cuda()
+ self.device = self.model.device
+ self.image_processor = image_processor
+ tokenizer.padding_side = 'left'
+ tokenizer.pad_token_id = tokenizer.eos_token_id
+ self.tokenizer = tokenizer
+ self.context_len = context_len
+
+ kwargs_default = dict(
+ max_new_tokens=512, do_sample=False, num_beams=1,
+ min_new_tokens=1, length_penalty=1, num_return_sequences=1)
+ kwargs_default.update(kwargs)
+ self.kwargs = kwargs_default
+ warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ')
+
+ def use_custom_prompt(self, dataset):
+ assert dataset is not None
+ if listinstr(['MMMU'], dataset):
+ return False
+ if DATASET_TYPE(dataset) == 'MCQ' or dataset == 'MMVet':
+ return True
+ return False
+
+ def build_prompt(self, line, dataset=None):
+ assert dataset is None or isinstance(dataset, str)
+ assert self.use_custom_prompt(dataset)
+ tgt_path = self.dump_image(line, dataset)
+ question = line['question']
+ if dataset == 'MMVet':
+ prompt = question + '\nAnswer the question directly. '
+ elif DATASET_TYPE(dataset) == 'MCQ':
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ options_prompt = ''
+ for key, item in options.items():
+ options_prompt += f'{key}. {item}\n'
+
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ prompt = f'Hint: {hint}\n' if hint is not None else ''
+ prompt += f'{question}\n'
+ prompt += (
+ f'{options_prompt}\nAnswer with the option’s letter from the given choices directly. '
+ if len(options) else 'Answer the question directly. '
+ )
+ else:
+ raise NotImplementedError
+
+ message = [dict(type='text', value=prompt)]
+ message.extend([dict(type='image', value=s) for s in tgt_path])
+ return message
+
+ def generate_inner(self, message, dataset=None):
+ from mplug_owl2.constants import IMAGE_TOKEN_INDEX
+ from mplug_owl2.mm_utils import process_images, tokenizer_image_token
+ kwargs = cp.deepcopy(self.kwargs)
+ if dataset in ['MMVet', 'LLaVABench']:
+ kwargs['length_penalty'] = 0
+ elif dataset is not None and DATASET_TYPE(dataset) == 'VQA':
+ kwargs['length_penalty'] = 0
+ elif dataset is not None and DATASET_TYPE(dataset) == 'MCQ':
+ kwargs['max_new_tokens'] = 10
+ num_images = len([x for x in message if x['type'] == 'image'])
+ assert num_images >= 0
+ prompt_full = 'USER: '
+ images = []
+ if num_images == 1:
+ prompt, image = self.message_to_promptimg(message, dataset=dataset)
+ prompt_full += f'<|image|>{prompt} \nASSISTANT: '
+ images.append(image)
+ else:
+ for msg in message:
+ if msg['type'] == 'image':
+ images.append(msg['value'])
+ prompt_full += '<|image|>'
+ elif msg['type'] == 'text':
+ prompt_full += msg['value']
+ prompt_full += '\nASSISTANT: '
+
+ def preproc_image(fname):
+ image = Image.open(fname).convert('RGB')
+ max_edge = max(image.size)
+ image = image.resize((max_edge, max_edge))
+ return image
+ images = [preproc_image(fname) for fname in images]
+ image_tensor = process_images(images, self.image_processor)
+ image_tensor = image_tensor.to(self.device, dtype=torch.float16)
+ input_ids = tokenizer_image_token(
+ prompt_full, self.tokenizer, IMAGE_TOKEN_INDEX, return_tensors='pt').unsqueeze(0).to(self.device)
+
+ with torch.inference_mode():
+ output_ids = self.model.generate(
+ input_ids=input_ids,
+ images=image_tensor,
+ output_hidden_states=True,
+ use_cache=True,
+ **kwargs)
+ answer = self.tokenizer.decode(output_ids[0, input_ids.shape[1]:]).strip()
+ return answer.split('')[0]
diff --git a/vlmeval/vlm/mplug_owl3.py b/vlmeval/vlm/mplug_owl3.py
new file mode 100644
index 0000000000000000000000000000000000000000..3f5295cdbfab5918bf45c8493da2007d467bdb2d
--- /dev/null
+++ b/vlmeval/vlm/mplug_owl3.py
@@ -0,0 +1,336 @@
+import torch
+from .base import BaseModel
+from ..smp import *
+from ..dataset import DATASET_TYPE
+from torchvision import transforms
+from transformers import AutoTokenizer, AutoModel
+
+import io
+import random
+import numpy as np
+import math
+
+
+def get_frame_indices(num_frames, vlen, sample='rand', fix_start=None, input_fps=1, max_num_frames=-1):
+ if sample in ['rand', 'middle']:
+ acc_samples = min(num_frames, vlen)
+ # split the video into `acc_samples` intervals, and sample from each interval.
+ intervals = np.linspace(start=0, stop=vlen, num=acc_samples + 1).astype(int)
+ ranges = []
+ for idx, interv in enumerate(intervals[:-1]):
+ ranges.append((interv, intervals[idx + 1] - 1))
+ if sample == 'rand':
+ try:
+ frame_indices = [random.choice(range(x[0], x[1])) for x in ranges]
+ except:
+ frame_indices = np.random.permutation(vlen)[:acc_samples]
+ frame_indices.sort()
+ frame_indices = list(frame_indices)
+ elif fix_start is not None:
+ frame_indices = [x[0] + fix_start for x in ranges]
+ elif sample == 'middle':
+ frame_indices = [(x[0] + x[1]) // 2 for x in ranges]
+ else:
+ raise NotImplementedError
+
+ if len(frame_indices) < num_frames: # padded with last frame
+ padded_frame_indices = [frame_indices[-1]] * num_frames
+ padded_frame_indices[:len(frame_indices)] = frame_indices
+ frame_indices = padded_frame_indices
+
+ elif 'fps' in sample: # fps0.5, sequentially sample frames at 0.5 fps
+ output_fps = float(sample[3:])
+ duration = float(vlen) / input_fps
+ delta = 1 / output_fps # gap between frames, this is also the clip length each frame represents
+ frame_seconds = np.arange(0 + delta / 2, duration + delta / 2, delta)
+ frame_indices = np.around(frame_seconds * input_fps).astype(int)
+ frame_indices = [e for e in frame_indices if e < vlen]
+ if max_num_frames > 0 and len(frame_indices) > max_num_frames:
+ frame_indices = frame_indices[:max_num_frames]
+ # frame_indices = np.linspace(0 + delta / 2, duration + delta / 2, endpoint=False, num=max_num_frames)
+ elif 'interval' in sample:
+ if num_frames == 1:
+ frame_indices = [random.randint(0, vlen - 1)]
+ else:
+ # transform FPS
+ interval = 8
+ clip_length = num_frames * interval * input_fps / 30
+ max_idx = max(vlen - clip_length, 0)
+ start_idx = random.uniform(0, max_idx)
+ end_idx = start_idx + clip_length - 1
+
+ frame_indices = torch.linspace(start_idx, end_idx, num_frames)
+ frame_indices = torch.clamp(frame_indices, 0, vlen - 1).long().tolist()
+ else:
+ raise ValueError
+ return frame_indices
+
+
+def get_frame_indices_start_end(num_frames, vlen, fps, start_time, end_time):
+ start_idx = max(int(fps * start_time), 0) if start_time is not None and not math.isnan(start_time) else 0
+ end_idx = min(int(fps * end_time), vlen) if end_time is not None and not math.isnan(end_time) else vlen
+ clip_len = end_idx - start_idx
+
+ acc_samples = min(num_frames, clip_len)
+ # split the video into `acc_samples` intervals, and sample from each interval.
+ intervals = np.linspace(start=start_idx, stop=end_idx, num=acc_samples + 1).astype(int)
+ ranges = []
+ for idx, interv in enumerate(intervals[:-1]):
+ ranges.append((interv, intervals[idx + 1] - 1))
+
+ try:
+ frame_indices = [random.choice(range(x[0], x[1])) for x in ranges]
+ except:
+ frame_indices = np.random.permutation(list(range(start_idx, end_idx)))[:acc_samples]
+ frame_indices.sort()
+ frame_indices = list(frame_indices)
+
+ if len(frame_indices) < num_frames: # padded with last frame
+ padded_frame_indices = [frame_indices[-1]] * num_frames
+ padded_frame_indices[:len(frame_indices)] = frame_indices
+ frame_indices = padded_frame_indices
+
+ return frame_indices
+
+
+def read_frames_decord(
+ video_path, width=None, height=None,
+ num_frames=8, sample='rand', fix_start=None,
+ max_num_frames=-1, start_time=None, end_time=None
+):
+ import decord
+ decord.bridge.set_bridge('torch')
+ if video_path.lower().endswith('.webm'):
+ # a workaround for webm, large/auto num_threads will cause error.
+ num_threads = 2
+ else:
+ num_threads = 0
+
+ if width is not None and height is not None:
+ video_reader = decord.VideoReader(video_path, width=width, height=height, num_threads=num_threads)
+ else:
+ video_reader = decord.VideoReader(video_path, num_threads=num_threads)
+ vlen = len(video_reader)
+ fps = video_reader.get_avg_fps()
+ if start_time and end_time:
+ frame_indices = get_frame_indices_start_end(
+ num_frames, vlen, fps, start_time, end_time
+ )
+ else:
+ frame_indices = get_frame_indices(
+ num_frames, vlen, sample=sample, fix_start=fix_start,
+ input_fps=fps, max_num_frames=max_num_frames
+ )
+ frames = video_reader.get_batch(frame_indices)
+ if isinstance(frames, torch.Tensor):
+ frames = frames.numpy() # (T, H, W, C), torch.uint8
+ else:
+ print(frames.shape)
+ frames = frames.asnumpy()
+ timestamp = {
+ 'num_frames': len(frame_indices),
+ 'timestamp': ', '.join([str(round(f / fps, 1)) for f in frame_indices])
+ }
+ return frames, timestamp
+
+
+class mPLUG_Owl3(BaseModel):
+ # No separate model module is required, but the dependencies must be met.
+ # https://github.com/X-PLUG/mPLUG-Owl/blob/main/mPLUG-Owl3/requirements.txt
+ INSTALL_REQ = True
+ INTERLEAVE = True
+ INSTALL_REQ_TXT = 'https://github.com/X-PLUG/mPLUG-Owl/blob/main/mPLUG-Owl3/requirements.txt'
+
+ def __init__(self, model_path=None, **kwargs):
+ assert model_path is not None
+ self.tokenizer = AutoTokenizer.from_pretrained(
+ model_path
+ )
+
+ self.model = AutoModel.from_pretrained(
+ model_path,
+ attn_implementation='sdpa',
+ torch_dtype=torch.half,
+ trust_remote_code=True
+ )
+ self.model.eval().cuda()
+ self.processor = self.model.init_processor(self.tokenizer)
+ self.logger = get_logger('mPLUG_Owl3')
+ if self.INSTALL_REQ:
+ self.logger.info(
+ f'Please remember to meet the requirements first\n'
+ f'Here: {self.INSTALL_REQ_TXT}'
+ )
+
+ def use_custom_prompt(self, dataset):
+ assert dataset is not None
+ if listinstr(['MMMU'], dataset):
+ return False
+ if listinstr(['MVBench', 'MMVet'], dataset):
+ return True
+ return False
+
+ def save_video_into_images(self, line, num_frames=16, dataset_class=None):
+ video_url = {
+ 'video': osp.join(line['prefix'], line['video']),
+ 'num_frames': num_frames,
+ 'bound': line.get('bound', None)
+ }
+ if osp.isdir(video_url['video']):
+ frame_paths = []
+ max_frame = len(os.listdir(video_url['video']))
+ fps = 3
+ if video_url['bound']:
+ start, end = line['start'], line['end']
+ else:
+ start, end = -100000, 100000
+ start_idx = max(1, round(start * fps))
+ end_idx = min(round(end * fps), max_frame)
+ seg_size = float(end_idx - start_idx) / num_frames
+ frame_indices = np.array([
+ int(start_idx + (seg_size / 2) + np.round(seg_size * idx))
+ for idx in range(num_frames)
+ ])
+
+ for frame_index in frame_indices:
+ img = os.path.join(video_url['video'], f'{frame_index:05d}.jpg')
+ frame_paths.append(img)
+
+ return frame_paths
+
+ if isinstance(video_url, dict):
+ if video_url['bound']:
+ start_time = line['start']
+ end_time = line['end']
+ else:
+ start_time = None
+ end_time = None
+ num_frames = video_url.get('num_frames', num_frames)
+ video_url = video_url['video']
+ else:
+ start_time = None
+ end_time = None
+ video_url = str(video_url)
+
+ if not osp.exists(video_url): # for MVBench_MP4
+ video_url = osp.join(dataset_class.data_root, video_url)
+ video, timestamp = read_frames_decord(
+ video_url, num_frames=num_frames, sample='middle', start_time=start_time, end_time=end_time
+ )
+
+ to_pil = transforms.ToPILImage()
+ frames = [to_pil(video[ti]) for ti in range(video.shape[0])]
+ lmu_root = LMUDataRoot()
+ frame_root = osp.join(lmu_root, 'images', dataset_class.dataset_name, 'mplug_owl3')
+ frame_root = osp.join(frame_root, video_url.split('/')[-1].split('.')[0])
+ os.makedirs(frame_root, exist_ok=True)
+ frame_tmpl = 'frame-{}-of-{}.jpg'
+ frame_paths = [osp.join(frame_root, frame_tmpl.format(i, num_frames)) for i in range(1, num_frames + 1)]
+ for im, pth in zip(frames, frame_paths):
+ if not osp.exists(pth):
+ im.save(pth)
+
+ return frame_paths
+
+ # Currently same to mPLUG_Owl2
+ def build_prompt(self, line, dataset=None, num_frames=16, video_llm=False):
+ if not isinstance(dataset, str):
+ dataset_class = dataset
+ dataset = dataset_class.dataset_name
+ assert dataset is None or isinstance(dataset, str)
+ assert self.use_custom_prompt(dataset)
+ if dataset_class.MODALITY == 'VIDEO':
+ if listinstr(['MVBench'], dataset):
+ tgt_path = self.save_video_into_images(line, num_frames, dataset_class)
+ else:
+ tgt_path = dataset_class.save_video_into_images(line, num_frames)
+ if type(line['candidates']) is not list:
+ line['candidates'] = eval(line['candidates'])
+ for idx, c in enumerate(line['candidates']):
+ line[chr(ord('A') + idx)] = c
+ else:
+ tgt_path = self.dump_image(line, dataset)
+ question = line['question']
+ if dataset == 'MMVet':
+ prompt = question + '\nAnswer the question directly. '
+ elif listinstr(['MCQ', 'Video-MCQ'], DATASET_TYPE(dataset)):
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ options_prompt = ''
+ for key, item in options.items():
+ options_prompt += f'{key}. {item}\n'
+
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ prompt = f'Hint: {hint}\n' if hint is not None else ''
+ prompt += f'{question}\n'
+ prompt += (
+ f'{options_prompt}\nAnswer with the option’s letter from the given choices directly. '
+ if len(options) else 'Answer the question directly. '
+ )
+ else:
+ raise NotImplementedError
+
+ message = [dict(type='text', value=prompt)]
+ message.extend([dict(type='image', value=s) for s in tgt_path])
+ return message
+
+ def preproc_image(self, fname, dataset=None):
+ from PIL import Image
+ image = Image.open(fname).convert('RGB')
+ # resize to max_size
+ max_size = 448 * 16
+ if max(image.size) > max_size and not listinstr(['MVBench'], dataset):
+ w, h = image.size
+ if w > h:
+ new_w = max_size
+ new_h = int(h * max_size / w)
+ else:
+ new_h = max_size
+ new_w = int(w * max_size / h)
+ image = image.resize((new_w, new_h), resample=Image.BICUBIC)
+ return image
+
+ def generate_inner(self, message, dataset=None):
+ num_images = len([x for x in message if x['type'] == 'image'])
+ assert num_images >= 0
+
+ images = []
+ prompt_full = ''
+
+ for msg in message:
+ if msg['type'] == 'image':
+ images.append(msg['value'])
+ prompt_full += '<|image|>'
+ elif msg['type'] == 'text':
+ prompt_full += msg['value']
+
+ needed_messages = [
+ {'role': 'user', 'content': prompt_full},
+ {'role': 'assistant', 'content': ''}
+ ]
+
+ images = [self.preproc_image(fname, dataset) for fname in images]
+
+ inputs = self.processor(needed_messages, images=images, videos=None, cut_enable=False)
+
+ inputs.to('cuda')
+ if listinstr(['MVBench'], dataset):
+ inputs.update({
+ 'tokenizer': self.tokenizer,
+ 'max_new_tokens': 100,
+ 'decode_text': True,
+ 'do_sample': True,
+ 'top_k': 1,
+ })
+ else:
+ inputs.update({
+ 'tokenizer': self.tokenizer,
+ 'max_new_tokens': 1024,
+ 'decode_text': True,
+ })
+
+ g = self.model.generate(**inputs)
+ return g[0]
diff --git a/vlmeval/vlm/nvlm.py b/vlmeval/vlm/nvlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..619341aeb4d79380894da649ef4b694a0a15cf69
--- /dev/null
+++ b/vlmeval/vlm/nvlm.py
@@ -0,0 +1,148 @@
+import torch
+from transformers import AutoTokenizer, AutoModel
+import math
+from PIL import Image
+import torchvision.transforms as T
+from torchvision.transforms.functional import InterpolationMode
+
+from .base import BaseModel
+from ..smp import *
+from ..dataset import DATASET_TYPE
+
+
+IMAGENET_MEAN = (0.485, 0.456, 0.406)
+IMAGENET_STD = (0.229, 0.224, 0.225)
+
+
+def split_model():
+ device_map = {}
+
+ num_gpus = torch.cuda.device_count()
+ rank, world_size = get_rank_and_world_size()
+ num_gpus = num_gpus // world_size
+ num_layers = 80
+ # Since the first GPU will be used for ViT, treat it as half a GPU.
+ num_layers_per_gpu = math.ceil(num_layers / (num_gpus - 0.5))
+ num_layers_per_gpu = [num_layers_per_gpu] * num_gpus
+ num_layers_per_gpu[0] = math.ceil(num_layers_per_gpu[0] * 0.5)
+ layer_cnt = 0
+
+ for i, num_layer in enumerate(num_layers_per_gpu):
+ for j in range(num_layer):
+ device_map[f'language_model.model.layers.{layer_cnt}'] = rank + i * world_size
+ layer_cnt += 1
+
+ device_map['vision_model'] = rank
+ device_map['mlp1'] = rank
+ device_map['language_model.model.embed_tokens'] = rank
+ device_map['language_model.model.norm'] = rank
+ device_map['language_model.model.rotary_emb'] = rank
+ device_map['language_model.lm_head'] = rank
+ device_map[f'language_model.model.layers.{num_layers - 1}'] = rank
+ return device_map
+
+
+def build_transform(input_size):
+ MEAN, STD = IMAGENET_MEAN, IMAGENET_STD
+ transform = T.Compose([
+ T.Lambda(lambda img: img.convert('RGB') if img.mode != 'RGB' else img),
+ T.Resize((input_size, input_size), interpolation=InterpolationMode.BICUBIC),
+ T.ToTensor(),
+ T.Normalize(mean=MEAN, std=STD)
+ ])
+ return transform
+
+
+def find_closest_aspect_ratio(aspect_ratio, target_ratios, width, height, image_size):
+ best_ratio_diff = float('inf')
+ best_ratio = (1, 1)
+ area = width * height
+ for ratio in target_ratios:
+ target_aspect_ratio = ratio[0] / ratio[1]
+ ratio_diff = abs(aspect_ratio - target_aspect_ratio)
+ if ratio_diff < best_ratio_diff:
+ best_ratio_diff = ratio_diff
+ best_ratio = ratio
+ elif ratio_diff == best_ratio_diff:
+ if area > 0.5 * image_size * image_size * ratio[0] * ratio[1]:
+ best_ratio = ratio
+ return best_ratio
+
+
+def dynamic_preprocess(image, min_num=1, max_num=12, image_size=448, use_thumbnail=False):
+ orig_width, orig_height = image.size
+ aspect_ratio = orig_width / orig_height
+
+ # calculate the existing image aspect ratio
+ target_ratios = set(
+ (i, j) for n in range(min_num, max_num + 1) for i in range(1, n + 1) for j in range(1, n + 1) if
+ i * j <= max_num and i * j >= min_num)
+ target_ratios = sorted(target_ratios, key=lambda x: x[0] * x[1])
+
+ # find the closest aspect ratio to the target
+ target_aspect_ratio = find_closest_aspect_ratio(
+ aspect_ratio, target_ratios, orig_width, orig_height, image_size)
+
+ # calculate the target width and height
+ target_width = image_size * target_aspect_ratio[0]
+ target_height = image_size * target_aspect_ratio[1]
+ blocks = target_aspect_ratio[0] * target_aspect_ratio[1]
+
+ # resize the image
+ resized_img = image.resize((target_width, target_height))
+ processed_images = []
+ for i in range(blocks):
+ box = (
+ (i % (target_width // image_size)) * image_size,
+ (i // (target_width // image_size)) * image_size,
+ ((i % (target_width // image_size)) + 1) * image_size,
+ ((i // (target_width // image_size)) + 1) * image_size
+ )
+ # split the image
+ split_img = resized_img.crop(box)
+ processed_images.append(split_img)
+ assert len(processed_images) == blocks
+ if use_thumbnail and len(processed_images) != 1:
+ thumbnail_img = image.resize((image_size, image_size))
+ processed_images.append(thumbnail_img)
+ return processed_images
+
+
+def load_image(image_file, input_size=448, max_num=12):
+ image = Image.open(image_file).convert('RGB')
+ transform = build_transform(input_size=input_size)
+ images = dynamic_preprocess(image, image_size=input_size, use_thumbnail=True, max_num=max_num)
+ pixel_values = [transform(image) for image in images]
+ pixel_values = torch.stack(pixel_values)
+ return pixel_values
+
+
+class NVLM(BaseModel):
+
+ INSTALL_REQ = False
+ INTERLEAVE = False
+
+ def __init__(self, model_path='nvidia/NVLM-D-72B', **kwargs):
+ assert model_path is not None
+ self.model_path = model_path
+ self.tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True, use_fast=False)
+ kwargs_default = dict(max_new_tokens=1024, do_sample=False)
+ kwargs_default.update(kwargs)
+ self.kwargs = kwargs_default
+
+ self.model = AutoModel.from_pretrained(
+ model_path,
+ torch_dtype=torch.bfloat16,
+ low_cpu_mem_usage=True,
+ use_flash_attn=False,
+ trust_remote_code=True,
+ device_map=split_model()).eval()
+
+ logging.info(f'Following kwargs received: {self.kwargs}, will use as generation config. ')
+ torch.cuda.empty_cache()
+
+ def generate_inner(self, message, dataset=None):
+ prompt, image_path = self.message_to_promptimg(message, dataset=dataset)
+ pixel_values = load_image(image_path, max_num=6).to(torch.bfloat16).cuda()
+ response = self.model.chat(self.tokenizer, pixel_values, prompt, self.kwargs)
+ return response.strip()
diff --git a/vlmeval/vlm/ola/__init__.py b/vlmeval/vlm/ola/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4d18f2e981ee64b83dc7dc51e278724c4c5e8222
--- /dev/null
+++ b/vlmeval/vlm/ola/__init__.py
@@ -0,0 +1 @@
+from .ola_model import Ola
diff --git a/vlmeval/vlm/ola/ola/arguments.py b/vlmeval/vlm/ola/ola/arguments.py
new file mode 100644
index 0000000000000000000000000000000000000000..199c5d5b7912fefbe3882a0b6f774e31a5f80cfc
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/arguments.py
@@ -0,0 +1,65 @@
+import transformers
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class ModelArguments:
+ model_name_or_path: Optional[str] = field(default="facebook/opt-125m")
+ version: Optional[str] = field(default="v0")
+ freeze_backbone: bool = field(default=False)
+ tune_speech_projector: bool = field(default=False)
+ tune_speech_encoder: bool = field(default=False)
+ tune_speech_generator_only: bool = field(default=False)
+ speech_encoder_type: Optional[str] = field(default=None)
+ speech_encoder: Optional[str] = field(default=None)
+ pretrain_speech_projector: Optional[str] = field(default=None)
+ speech_projector_type: Optional[str] = field(default='linear')
+ speech_encoder_ds_rate: int = 5
+ speech_encoder_hidden_size: int = 1280
+
+
+@dataclass
+class DataArguments:
+ data_path: str = field(default=None,
+ metadata={"help": "Path to the training data."})
+ is_multimodal: bool = False
+ input_type: str = field(default="mel")
+ speech_normalize: bool = False
+ mel_size: int = 128
+ has_tgt_units: bool = False
+
+
+@dataclass
+class TrainingArguments(transformers.TrainingArguments):
+ cache_dir: Optional[str] = field(default=None)
+ optim: str = field(default="adamw_torch")
+ freeze_speech_projector: bool = field(default=False)
+ model_max_length: int = field(
+ default=512,
+ metadata={
+ "help":
+ "Maximum sequence length. Sequences will be right padded (and possibly truncated)."
+ },
+ )
+ double_quant: bool = field(
+ default=True,
+ metadata={"help": "Compress the quantization statistics through double quantization."}
+ )
+ quant_type: str = field(
+ default="nf4",
+ metadata={"help": "Quantization data type to use. Should be one of `fp4` or `nf4`."}
+ )
+ bits: int = field(
+ default=16,
+ metadata={"help": "How many bits to use."}
+ )
+ lora_enable: bool = False
+ lora_r: int = 64
+ lora_alpha: int = 16
+ lora_dropout: float = 0.05
+ lora_weight_path: str = ""
+ lora_bias: str = "none"
+ speech_projector_lr: Optional[float] = None
+ group_by_modality_length: bool = field(default=False)
\ No newline at end of file
diff --git a/vlmeval/vlm/ola/ola/constants.py b/vlmeval/vlm/ola/ola/constants.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b903d94f9122dc8b657383f8604555aad819400
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/constants.py
@@ -0,0 +1,14 @@
+CONTROLLER_HEART_BEAT_EXPIRATION = 30
+WORKER_HEART_BEAT_INTERVAL = 15
+
+LOGDIR = "."
+
+# Model Constants
+IGNORE_INDEX = -100
+SPEECH_TOKEN_INDEX = -200
+DEFAULT_SPEECH_TOKEN = ""
+IMAGE_TOKEN_INDEX= -300
+DEFAULT_IMAGE_TOKEN = ""
+DEFAULT_IMAGE_PATCH_TOKEN = ""
+DEFAULT_IM_START_TOKEN = ""
+DEFAULT_IM_END_TOKEN = ""
\ No newline at end of file
diff --git a/vlmeval/vlm/ola/ola/conversation.py b/vlmeval/vlm/ola/ola/conversation.py
new file mode 100644
index 0000000000000000000000000000000000000000..4797ded2469369d02ae6085d0b41588d102d6784
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/conversation.py
@@ -0,0 +1,137 @@
+import dataclasses
+from enum import auto, Enum
+from typing import List, Any, Union, Tuple
+import base64
+from io import BytesIO
+from PIL import Image
+
+
+class SeparatorStyle(Enum):
+ """Different separator style."""
+ TWO = auto()
+ PLAIN = auto()
+ CHATML = auto()
+ LLAMA_2 = auto()
+ LLAMA_3 = auto()
+ QWEN2 = auto()
+
+
+@dataclasses.dataclass
+class Conversation:
+ """A class that keeps all conversation history."""
+ system: str
+ roles: List[str]
+ messages: List[List[str]]
+ offset: int
+ sep_style: SeparatorStyle = SeparatorStyle.PLAIN
+ sep: str = "###"
+ sep2: str = None
+ version: str = "Unknown"
+
+ tokenizer_id: str = ""
+ tokenizer: Any = None
+ # Stop criteria (the default one is EOS token)
+ stop_str: Union[str, List[str]] = None
+ # Stops generation if meeting any token in this list
+ stop_token_ids: List[int] = None
+
+ skip_next: bool = False
+
+ def get_prompt(self):
+ messages = self.messages
+
+ if self.sep_style == SeparatorStyle.TWO:
+ seps = [self.sep, self.sep2]
+ ret = self.system + seps[0]
+ for i, (role, message) in enumerate(messages):
+ if message:
+ if type(message) is tuple:
+ message = message[0]
+ ret += role + ": " + message + seps[i % 2]
+ else:
+ ret += role + ":"
+ elif self.sep_style == SeparatorStyle.QWEN2:
+ start = '<|im_start|>'
+ end = '<|im_end|>\n'
+ ret = start + 'system\n' + self.system + end
+ for i, (role, message) in enumerate(messages):
+ if message:
+ if type(message) is tuple:
+ message, _, _ = message
+
+ if message.endswith('<|endoftext|>'):
+ message = message.replace('<|endoftext|>', '')
+ ret += start + role + "\n" + message + end + '<|endoftext|>'
+ else:
+ assert not '<|endoftext|>' in message, f"Invalid message: {message}"
+ ret += start + role + "\n" + message + end
+ else:
+ ret += start + role + "\n"
+ else:
+ raise ValueError(f"Invalid style: {self.sep_style}")
+
+ return ret
+
+ def append_message(self, role, message):
+ self.messages.append([role, message])
+
+ def to_gradio_chatbot(self):
+ ret = []
+ for i, (role, msg) in enumerate(self.messages[self.offset:]):
+ if i % 2 == 0:
+ if type(msg) is tuple:
+ msg, speech = msg
+ ret.append([msg, None])
+ else:
+ ret.append([msg, None])
+ else:
+ ret[-1][-1] = msg
+ return ret
+
+ def copy(self):
+ return Conversation(
+ system=self.system,
+ roles=self.roles,
+ messages=[[x, y] for x, y in self.messages],
+ offset=self.offset,
+ sep_style=self.sep_style,
+ sep=self.sep,
+ sep2=self.sep2,
+ version=self.version)
+
+ def dict(self):
+ if len(self.get_images()) > 0:
+ return {
+ "system": self.system,
+ "roles": self.roles,
+ "messages": [[x, y[0] if type(y) is tuple else y] for x, y in self.messages],
+ "offset": self.offset,
+ "sep": self.sep,
+ "sep2": self.sep2,
+ }
+ return {
+ "system": self.system,
+ "roles": self.roles,
+ "messages": self.messages,
+ "offset": self.offset,
+ "sep": self.sep,
+ "sep2": self.sep2,
+ }
+
+conv_qwen_v1 = Conversation(
+ system="You are a helpful assistant.",
+ roles=("user", "assistant"),
+ version="v1",
+ messages=(),
+ offset=0,
+ sep_style=SeparatorStyle.QWEN2,
+)
+
+default_conversation = conv_qwen_v1
+conv_templates = {
+ 'v1_qwen2': conv_qwen_v1,
+}
+
+
+if __name__ == "__main__":
+ print(default_conversation.get_prompt())
diff --git a/vlmeval/vlm/ola/ola/datasets/__init__.py b/vlmeval/vlm/ola/ola/datasets/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/vlmeval/vlm/ola/ola/datasets/preprocess.py b/vlmeval/vlm/ola/ola/datasets/preprocess.py
new file mode 100644
index 0000000000000000000000000000000000000000..f5f5243b2d578674130595336476103e8788dd18
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/datasets/preprocess.py
@@ -0,0 +1,220 @@
+import copy
+import torch
+import transformers
+import tokenizers
+
+from typing import Dict, Sequence
+
+from ...ola.constants import IGNORE_INDEX, DEFAULT_SPEECH_TOKEN, IMAGE_TOKEN_INDEX
+from ...ola import conversation as conversation_lib
+from ...ola.model import *
+from ...ola.arguments import DataArguments
+from ...ola.constants import SPEECH_TOKEN_INDEX
+
+from packaging import version
+
+IS_TOKENIZER_GREATER_THAN_0_14 = version.parse(tokenizers.__version__) >= version.parse('0.14')
+
+
+def tokenizer_speech_token(prompt, tokenizer, speech_token_index=SPEECH_TOKEN_INDEX, return_tensors=None):
+ prompt_chunks = [tokenizer(chunk).input_ids for chunk in prompt.split('')]
+
+ def insert_separator(X, sep):
+ return [ele for sublist in zip(X, [sep]*len(X)) for ele in sublist][:-1]
+
+ input_ids = []
+ offset = 0
+ if len(prompt_chunks) > 0 and len(prompt_chunks[0]) > 0 and prompt_chunks[0][0] == tokenizer.bos_token_id:
+ offset = 1
+ input_ids.append(prompt_chunks[0][0])
+
+ for x in insert_separator(prompt_chunks, [speech_token_index] * (offset + 1)):
+ input_ids.extend(x[offset:])
+
+ if return_tensors is not None:
+ if return_tensors == 'pt':
+ return torch.tensor(input_ids, dtype=torch.long)
+ raise ValueError(f'Unsupported tensor type: {return_tensors}')
+ return input_ids
+
+
+def preprocess_multimodal(
+ sources: Sequence[str],
+ data_args: DataArguments
+) -> Dict:
+ is_multimodal = data_args.is_multimodal
+ if not is_multimodal:
+ return sources
+
+ for source in sources:
+ for sentence in source:
+ if DEFAULT_SPEECH_TOKEN in sentence['value']:
+ sentence['value'] = sentence['value'].replace(DEFAULT_SPEECH_TOKEN, '').strip()
+ sentence['value'] = DEFAULT_SPEECH_TOKEN + '\n' + sentence['value']
+ sentence['value'] = sentence['value'].strip()
+
+ return sources
+
+def tokenizer_image_token(prompt, tokenizer, image_token_index=IMAGE_TOKEN_INDEX, return_tensors=None):
+ prompt_chunks = [tokenizer(chunk).input_ids for chunk in prompt.split('')]
+
+ def insert_separator(X, sep):
+ return [ele for sublist in zip(X, [sep]*len(X)) for ele in sublist][:-1]
+
+ input_ids = []
+ offset = 0
+ if len(prompt_chunks) > 0 and len(prompt_chunks[0]) > 0 and prompt_chunks[0][0] == tokenizer.bos_token_id:
+ offset = 1
+ input_ids.append(prompt_chunks[0][0])
+
+ for x in insert_separator(prompt_chunks, [image_token_index] * (offset + 1)):
+ input_ids.extend(x[offset:])
+
+ if return_tensors is not None:
+ if return_tensors == 'pt':
+ return torch.tensor(input_ids, dtype=torch.long)
+ raise ValueError(f'Unsupported tensor type: {return_tensors}')
+ return input_ids
+
+def tokenizer_speech_image_token(prompt, tokenizer, image_token_index=IMAGE_TOKEN_INDEX, speech_token_idx=SPEECH_TOKEN_INDEX, return_tensors=None):
+ prompt_chunks = [tokenizer(chunk).input_ids for chunk in prompt.split('')]
+
+ def insert_separator(X, sep):
+ return [ele for sublist in zip(X, [sep]*len(X)) for ele in sublist][:-1]
+
+ input_ids = []
+ offset = 0
+ if len(prompt_chunks) > 0 and len(prompt_chunks[0]) > 0 and prompt_chunks[0][0] == tokenizer.bos_token_id:
+ offset = 1
+ input_ids.append(prompt_chunks[0][0])
+
+ for x in insert_separator(prompt_chunks, [speech_token_idx, image_token_index] * (offset + 1)):
+ input_ids.extend(x[offset:])
+
+ if return_tensors is not None:
+ if return_tensors == 'pt':
+ return torch.tensor(input_ids, dtype=torch.long)
+ raise ValueError(f'Unsupported tensor type: {return_tensors}')
+ return input_ids
+
+def tokenizer_speech_question_image_token(prompt, tokenizer, image_token_index=IMAGE_TOKEN_INDEX, speech_token_idx=SPEECH_TOKEN_INDEX, return_tensors=None):
+ prompt_chunks = [tokenizer(chunk).input_ids for chunk in prompt.split("\nUser's question in speech: \n")]
+
+ def insert_separator(X, sep):
+ return [ele for sublist in zip(X, [sep]*len(X)) for ele in sublist][:-1]
+
+ input_ids = []
+ offset = 0
+ if len(prompt_chunks) > 0 and len(prompt_chunks[0]) > 0 and prompt_chunks[0][0] == tokenizer.bos_token_id:
+ offset = 1
+ input_ids.append(prompt_chunks[0][0])
+
+ nl_tokens = tokenizer("\n").input_ids[0]
+ special_chunks = [image_token_index, nl_tokens]
+ special_chunks.extend(tokenizer("User's question in speech: ").input_ids)
+ special_chunks.extend([speech_token_idx, nl_tokens])
+
+ for x in insert_separator(prompt_chunks, special_chunks):
+ input_ids.extend(x[offset:])
+
+ import pdb;pdb.set_trace()
+ if return_tensors is not None:
+ if return_tensors == 'pt':
+ return torch.tensor(input_ids, dtype=torch.long)
+ raise ValueError(f'Unsupported tensor type: {return_tensors}')
+ return input_ids
+
+def preprocess_v1(
+ sources,
+ tokenizer: transformers.PreTrainedTokenizer,
+ has_speech: bool = False
+) -> Dict:
+ conv = conversation_lib.default_conversation.copy()
+ roles = {"human": conv.roles[0], "gpt": conv.roles[1]}
+
+ # Apply prompt templates
+ conversations = []
+ for i, source in enumerate(sources):
+ if roles[source[0]["from"]] != conv.roles[0]:
+ # Skip the first one if it is not from human
+ source = source[1:]
+
+ conv.messages = []
+ for j, sentence in enumerate(source):
+ role = roles[sentence["from"]]
+ assert role == conv.roles[j % 2], f"{i}"
+ conv.append_message(role, sentence["value"])
+ conversations.append(conv.get_prompt())
+
+ # Tokenize conversations
+
+ if has_speech:
+ input_ids = torch.stack([tokenizer_speech_token(prompt, tokenizer, return_tensors='pt') for prompt in conversations], dim=0)
+ else:
+ input_ids = tokenizer(
+ conversations,
+ return_tensors="pt",
+ padding="longest",
+ max_length=tokenizer.model_max_length,
+ truncation=True,
+ ).input_ids
+
+ targets = input_ids.clone()
+
+ assert conv.sep_style == conversation_lib.SeparatorStyle.TWO
+
+ # Mask targets
+ sep = conv.sep + conv.roles[1] + ": "
+ for conversation, target in zip(conversations, targets):
+ total_len = int(target.ne(tokenizer.pad_token_id).sum())
+
+ rounds = conversation.split(conv.sep2)
+ cur_len = 1
+ target[:cur_len] = IGNORE_INDEX
+ for i, rou in enumerate(rounds):
+ if rou == "":
+ break
+
+ parts = rou.split(sep)
+ if len(parts) != 2:
+ break
+ parts[0] += sep
+
+ if has_speech:
+ round_len = len(tokenizer_speech_token(rou, tokenizer))
+ instruction_len = len(tokenizer_speech_token(parts[0], tokenizer)) - 2
+ else:
+ round_len = len(tokenizer(rou).input_ids)
+ instruction_len = len(tokenizer(parts[0]).input_ids) - 2
+
+ # FIXME: tokenizer bug
+ if i != 0 and not tokenizer.legacy and IS_TOKENIZER_GREATER_THAN_0_14:
+ round_len -= 1
+ instruction_len -= 1
+
+ target[cur_len : cur_len + instruction_len] = IGNORE_INDEX
+
+ cur_len += round_len
+ target[cur_len:] = IGNORE_INDEX
+
+ if cur_len < tokenizer.model_max_length:
+ if cur_len != total_len:
+ target[:] = IGNORE_INDEX
+ print(
+ f"WARNING: tokenization mismatch: {cur_len} vs. {total_len}."
+ f" (ignored)"
+ )
+
+ return dict(
+ input_ids=input_ids,
+ labels=targets,
+ )
+
+def preprocess(
+ sources: Sequence[str],
+ tokenizer: transformers.PreTrainedTokenizer,
+ has_speech: bool = False
+) -> Dict:
+ if conversation_lib.default_conversation.version.startswith("v1"):
+ return preprocess_v1(sources, tokenizer, has_speech=has_speech)
+ raise NotImplementedError
\ No newline at end of file
diff --git a/vlmeval/vlm/ola/ola/mm_utils.py b/vlmeval/vlm/ola/ola/mm_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d7af6aa03226c9a0ed8b3ecad1a51b50d3e775d
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/mm_utils.py
@@ -0,0 +1,177 @@
+from PIL import Image
+import base64
+import math
+import ast
+
+import torch
+from transformers import StoppingCriteria
+import os
+import io
+
+if 'HIGHRES_BASE' in os.environ:
+ # highresxpatch
+ HIGHRES_BASE = os.environ['HIGHRES_BASE']
+ highres_base, highres_ps = HIGHRES_BASE.split('x')
+ highres_base = int(highres_base)
+ highres_ps = int(highres_ps)
+ print(f"HIGHRES_BASE is set as {HIGHRES_BASE}, {highres_base}, {highres_ps}")
+else:
+ HIGHRES_BASE = None
+
+if 'MAXRES' in os.environ:
+ # highresxpatch
+ MAXRES = int(os.environ['MAXRES'])
+ print(f"MAXRES is set as {MAXRES}")
+else:
+ MAXRES = 1536
+
+if 'MINRES' in os.environ:
+ # highresxpatch
+ MINRES = int(os.environ['MINRES'])
+ print(f"MINRES is set as {MINRES}")
+else:
+ MINRES = 0
+
+if 'PAD2STRIDE' in os.environ:
+ # highresxpatch
+ PAD2STRIDE = True
+ print(f"PAD2STRIDE is set")
+else:
+ PAD2STRIDE = False
+
+if 'LOWRES_RESIZE' in os.environ:
+ LOWRES_RESIZE = os.environ['LOWRES_RESIZE']
+ print(f"LOWRES_RESIZE is set as {LOWRES_RESIZE}")
+ if 'x' in LOWRES_RESIZE:
+ size, ps = LOWRES_RESIZE.split('x')
+ size = int(size)
+ ps = int(ps)
+ LOWRES_RESIZE = (size, ps)
+ else:
+ LOWRES_RESIZE = int(LOWRES_RESIZE)
+else:
+ LOWRES_RESIZE = None
+
+
+def pad_image(image, target_resolution, value=0):
+ """
+ Resize and pad an image to a target resolution while maintaining aspect ratio.
+
+ Args:
+ image (PIL.Image.Image): The input image.
+ target_resolution (tuple): The target resolution (width, height) of the image.
+
+ Returns:
+ PIL.Image.Image: The resized and padded image.
+ """
+ original_width, original_height = image.size
+ target_width, target_height = target_resolution
+ # Create a new image with the target size and paste the resized image onto it
+ new_image = Image.new('RGB', (target_width, target_height), (value, value, value))
+ paste_x = (target_width - original_width) // 2
+ paste_y = (target_height - original_height) // 2
+ new_image.paste(image, (paste_x, paste_y))
+ return new_image
+
+def resize_images(image, patch_size=14, base_size=896):
+ h, w = image.size
+ if base_size == 0:
+ if h * w > MAXRES * MAXRES:
+ scale = MAXRES * MAXRES / (h * w)
+ scale = math.sqrt(scale)
+ elif h * w < MINRES * MINRES:
+ scale = MINRES * MINRES / (h * w)
+ scale = math.sqrt(scale)
+ else:
+ scale = None
+ else:
+ scale = base_size * base_size / (h * w)
+ scale = math.sqrt(scale)
+
+
+ if scale is not None:
+ new_h = int(h * scale / patch_size) * patch_size
+ new_w = int(w * scale / patch_size) * patch_size
+ new_h = max(new_h, patch_size)
+ new_w = max(new_w, patch_size)
+ image = image.resize((new_h, new_w))
+ elif PAD2STRIDE:
+ if h % patch_size == 0:
+ new_h = h
+ else:
+ new_h = (h // patch_size + 1) * patch_size
+
+ if w % patch_size == 0:
+ new_w = w
+ else:
+ new_w = (w // patch_size + 1) * patch_size
+ image = pad_image(image, (new_h, new_w), value=127)
+ else:
+ scale = 1.0
+ new_h = int(h * scale / patch_size) * patch_size
+ new_w = int(w * scale / patch_size) * patch_size
+ new_h = max(new_h, patch_size)
+ new_w = max(new_w, patch_size)
+ image = image.resize((new_h, new_w))
+
+ return image
+
+def process_anyres_highres_image_genli(image, processor):
+ h, w = image.size
+ if h < 32 and w < 32:
+ min_size = min(h, w)
+ ratio = 64 / min_size
+ image = image.resize((int(h * ratio), int(w * ratio)))
+ elif h < 32:
+ ratio = 64 / h
+ image = image.resize((int(h * ratio), int(w * ratio)))
+ elif w < 32:
+ ratio = 64 / w
+ image = image.resize((int(h * ratio), int(w * ratio)))
+ if HIGHRES_BASE is not None:
+ image = resize_images(image, patch_size=highres_ps, base_size=highres_base)
+
+ if LOWRES_RESIZE is not None:
+ image_original_resize = resize_images(image, patch_size=LOWRES_RESIZE[1], base_size=LOWRES_RESIZE[0])
+ else:
+ image_original_resize = image.resize((384, 384))
+
+ image_patches = processor.preprocess(image_original_resize, return_tensors='pt')['pixel_values'][0]
+ image_padded = processor.preprocess(image, return_tensors='pt')['pixel_values'][0]
+ return image_patches.unsqueeze(0), image_padded.unsqueeze(0)
+
+
+
+def get_model_name_from_path(model_path):
+ model_path = model_path.strip("/")
+ model_paths = model_path.split("/")
+ if model_paths[-1].startswith('checkpoint-'):
+ return model_paths[-2] + "_" + model_paths[-1]
+ else:
+ return model_paths[-1]
+
+
+class KeywordsStoppingCriteria(StoppingCriteria):
+ def __init__(self, keywords, tokenizer, input_ids):
+ self.keywords = keywords
+ self.keyword_ids = []
+ for keyword in keywords:
+ cur_keyword_ids = tokenizer(keyword).input_ids
+ if len(cur_keyword_ids) > 1 and cur_keyword_ids[0] == tokenizer.bos_token_id:
+ cur_keyword_ids = cur_keyword_ids[1:]
+ self.keyword_ids.append(torch.tensor(cur_keyword_ids))
+ self.tokenizer = tokenizer
+ self.start_len = input_ids.shape[1]
+
+ def __call__(self, output_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
+ assert output_ids.shape[0] == 1, "Only support batch size 1 (yet)" # TODO
+ offset = min(output_ids.shape[1] - self.start_len, 3)
+ self.keyword_ids = [keyword_id.to(output_ids.device) for keyword_id in self.keyword_ids]
+ for keyword_id in self.keyword_ids:
+ if output_ids[0, -keyword_id.shape[0]:] == keyword_id:
+ return True
+ outputs = self.tokenizer.batch_decode(output_ids[:, -offset:], skip_special_tokens=True)[0]
+ for keyword in self.keywords:
+ if keyword in outputs:
+ return True
+ return False
diff --git a/vlmeval/vlm/ola/ola/model/__init__.py b/vlmeval/vlm/ola/ola/model/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7599857d36358a738f92ab2b534918dbcd4a7b45
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/model/__init__.py
@@ -0,0 +1 @@
+from .language_model.ola_qwen import OlaQwenForCausalLM, OlaConfigQwen
\ No newline at end of file
diff --git a/vlmeval/vlm/ola/ola/model/builder.py b/vlmeval/vlm/ola/ola/model/builder.py
new file mode 100644
index 0000000000000000000000000000000000000000..15feaf9b4f64343f6c5a531bb7222d247eb1a9e3
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/model/builder.py
@@ -0,0 +1,91 @@
+import os
+import warnings
+import shutil
+
+from transformers import AutoTokenizer, AutoModelForCausalLM, AutoConfig, BitsAndBytesConfig
+import torch
+from ...ola.model import *
+from ...ola.model.speech_encoder.builder import build_speech_encoder
+
+def load_pretrained_model(model_path, model_base, is_lora=False, s2s=False, load_8bit=False, load_4bit=False, device="cuda", use_flash_attn=False, **kwargs):
+ if load_8bit:
+ kwargs['load_in_8bit'] = True
+ elif load_4bit:
+ kwargs['load_in_4bit'] = True
+ kwargs['quantization_config'] = BitsAndBytesConfig(
+ load_in_4bit=True,
+ bnb_4bit_compute_dtype=torch.float16,
+ bnb_4bit_use_double_quant=True,
+ bnb_4bit_quant_type='nf4'
+ )
+ else:
+ kwargs['torch_dtype'] = torch.bfloat16
+
+ if use_flash_attn:
+ kwargs['attn_implementation'] = 'flash_attention_2'
+
+ model_cls = OlaQwenForCausalLM
+
+ # Load OmniSpeech model
+ if is_lora:
+ assert model_base is not None, "model_base is required for LoRA models."
+ from ola.model.language_model.ola_qwen import OlaConfigQwen
+ lora_cfg_pretrained = OlaConfigQwen.from_pretrained(model_path)
+ tokenizer = AutoTokenizer.from_pretrained(model_base, use_fast=False)
+ print('Loading OmniSpeech from base model...')
+ model = model_cls.from_pretrained(model_base, low_cpu_mem_usage=False, config=lora_cfg_pretrained, **kwargs)
+ print('Loading additional OmniSpeech weights...')
+ if os.path.exists(os.path.join(model_path, 'non_lora_trainables.bin')):
+ non_lora_trainables = torch.load(os.path.join(model_path, 'non_lora_trainables.bin'), map_location='cpu')
+ non_lora_trainables = {(k[11:] if k.startswith('base_model.') else k): v for k, v in non_lora_trainables.items()}
+ if any(k.startswith('model.model.') for k in non_lora_trainables):
+ non_lora_trainables = {(k[6:] if k.startswith('model.') else k): v for k, v in non_lora_trainables.items()}
+ model.load_state_dict(non_lora_trainables, strict=False)
+
+ from peft import PeftModel
+ print('Loading LoRA weights...')
+ model = PeftModel.from_pretrained(model, model_path)
+ print('Merging LoRA weights...')
+ model = model.merge_and_unload()
+ print('Model is loaded...')
+ elif model_base is not None:
+ print('Loading OmniSpeech from base model...')
+ tokenizer = AutoTokenizer.from_pretrained(model_base, use_fast=False)
+ cfg_pretrained = AutoConfig.from_pretrained(model_path)
+ model = model_cls.from_pretrained(model_base, low_cpu_mem_usage=False, config=cfg_pretrained, **kwargs)
+
+ speech_projector_weights = torch.load(os.path.join(model_path, 'speech_projector.bin'), map_location='cpu')
+ speech_projector_weights = {k: v.to(torch.float16) for k, v in speech_projector_weights.items()}
+ model.load_state_dict(speech_projector_weights, strict=False)
+ model = model.to(device=device)
+ else:
+ tokenizer = AutoTokenizer.from_pretrained(model_path, use_fast=False)
+ model = model_cls.from_pretrained(
+ model_path,
+ low_cpu_mem_usage=False,
+ **kwargs
+ )
+ model = model.to(device=device)
+
+ model.get_model().speech_encoder = build_speech_encoder(model.config)
+ model.get_model().speech_encoder.to(device=device, dtype=torch.float16)
+
+ image_processor = None
+ model.resize_token_embeddings(len(tokenizer))
+ vision_tower = model.get_vision_tower()
+ print("Loading vision tower...")
+ if not vision_tower.is_loaded:
+ vision_tower.load_model(device_map=device)
+ if device != "auto":
+ vision_tower.to(device="cuda", dtype=torch.bfloat16)
+ else:
+ vision_tower.to(device="cuda:0", dtype=torch.bfloat16)
+ image_processor = vision_tower.image_processor
+ print("Loading vision tower succeeded.")
+
+ if hasattr(model.config, "max_sequence_length"):
+ context_len = model.config.max_sequence_length
+ else:
+ context_len = 16384
+
+ return tokenizer, model, image_processor, context_len
diff --git a/vlmeval/vlm/ola/ola/model/language_model/ola_qwen.py b/vlmeval/vlm/ola/ola/model/language_model/ola_qwen.py
new file mode 100644
index 0000000000000000000000000000000000000000..fd88538c53603ef929abc3dee892e109e2cd0844
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/model/language_model/ola_qwen.py
@@ -0,0 +1,237 @@
+from typing import List, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+
+import transformers
+from transformers import AutoConfig, AutoModelForCausalLM
+
+
+from transformers.modeling_outputs import CausalLMOutputWithPast
+from transformers.generation.utils import GenerateOutput
+
+from ..ola_arch import OlaMetaModel, OlaMetaForCausalLM
+from transformers import Qwen2Config, Qwen2Model, Qwen2ForCausalLM
+
+
+class OlaConfigQwen(Qwen2Config):
+ model_type = "ola_qwen"
+
+
+class OlaQwenModel(OlaMetaModel, Qwen2Model):
+ config_class = OlaConfigQwen
+
+ def __init__(self, config: Qwen2Config):
+ super(OlaQwenModel, self).__init__(config)
+
+
+class OlaQwenForCausalLM(Qwen2ForCausalLM, OlaMetaForCausalLM):
+ config_class = OlaConfigQwen
+
+ def __init__(self, config):
+ super(Qwen2ForCausalLM, self).__init__(config)
+
+ config.rope_scaling = None
+ self.model = OlaQwenModel(config)
+ self.vocab_size = config.vocab_size
+ self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_model(self):
+ return self.model
+
+ def forward(
+ self,
+ input_ids: torch.LongTensor = None,
+ attention_mask: Optional[torch.Tensor] = None,
+ position_ids: Optional[torch.LongTensor] = None,
+ past_key_values: Optional[List[torch.FloatTensor]] = None,
+ inputs_embeds: Optional[torch.FloatTensor] = None,
+ labels: Optional[torch.LongTensor] = None,
+ use_cache: Optional[bool] = None,
+ output_attentions: Optional[bool] = None,
+ output_hidden_states: Optional[bool] = None,
+ speech: Optional[torch.FloatTensor] = None,
+ speech_lengths: Optional[torch.LongTensor] = None,
+ speech_chunks: Optional[torch.LongTensor] = None,
+ speech_wav: Optional[torch.FloatTensor] = None,
+ images: Optional[torch.FloatTensor] = None,
+ images_highres: Optional[List[torch.FloatTensor]] = None,
+ image_sizes: Optional[List[List[int]]] = None,
+ modalities: Optional[List[str]] = ["image"],
+ return_dict: Optional[bool] = None,
+ cache_position: Optional[torch.LongTensor] = None,
+ ) -> Union[Tuple, CausalLMOutputWithPast]:
+
+ if inputs_embeds is None:
+ (
+ input_ids,
+ position_ids,
+ attention_mask,
+ past_key_values,
+ inputs_embeds,
+ labels
+ ) = self.prepare_inputs_labels_for_speech_vision_text(
+ input_ids,
+ position_ids,
+ attention_mask,
+ past_key_values,
+ labels,
+ speech,
+ speech_lengths,
+ speech_chunks,
+ speech_wav,
+ images,
+ modalities,
+ image_sizes,
+ images_highres
+ )
+
+ if labels is None:
+ return super().forward(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ past_key_values=past_key_values,
+ inputs_embeds=inputs_embeds,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict
+ )
+ else:
+ return self.forward_llm_efficient(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ past_key_values=past_key_values,
+ inputs_embeds=inputs_embeds,
+ labels=labels,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict
+ )
+
+
+ def forward_llm_efficient(self, input_ids, attention_mask, position_ids, past_key_values, inputs_embeds, labels, use_cache, output_attentions, output_hidden_states, return_dict):
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+ # decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)
+ outputs = self.model(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ past_key_values=past_key_values,
+ inputs_embeds=inputs_embeds,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ hidden_states = outputs[0]
+ hidden_dim = hidden_states.size(-1)
+ shift_labels = labels[..., 1:].contiguous().reshape(-1)
+ shift_hidden_states = hidden_states[..., :-1, :].contiguous().reshape(-1, hidden_dim)
+ assert shift_labels.size(0) == shift_hidden_states.size(0)
+ mask = shift_labels > -1
+ assert mask.float().sum() > 0
+ shift_labels = shift_labels[mask]
+ shift_hidden_states = shift_hidden_states[mask, :]
+ logits = self.lm_head(shift_hidden_states)
+ logits = logits.float()
+ loss_fct = nn.CrossEntropyLoss()
+ loss = loss_fct(logits, shift_labels)
+
+
+ if not return_dict:
+ output = (logits,) + outputs[1:]
+ return (loss,) + output if loss is not None else output
+
+
+ return CausalLMOutputWithPast(
+ loss=loss,
+ logits=logits,
+ past_key_values=outputs.past_key_values,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+ @torch.no_grad()
+ def generate(
+ self,
+ inputs: Optional[torch.Tensor] = None,
+ speech: Optional[torch.Tensor] = None,
+ speech_lengths: Optional[torch.Tensor] = None,
+ speech_chunks: Optional[torch.Tensor] = None,
+ speech_wav: Optional[torch.FloatTensor] = None,
+ images: Optional[torch.Tensor] = None,
+ images_highres: Optional[List[torch.FloatTensor]] = None,
+ image_sizes: Optional[torch.Tensor] = None,
+ modalities: Optional[List[str]] = ["image"],
+ **kwargs,
+ ) -> Union[GenerateOutput, torch.LongTensor]:
+ position_ids = kwargs.pop("position_ids", None)
+ attention_mask = kwargs.pop("attention_mask", None)
+ if "inputs_embeds" in kwargs:
+ raise NotImplementedError("`inputs_embeds` is not supported")
+
+ (
+ inputs,
+ position_ids,
+ attention_mask,
+ _,
+ inputs_embeds,
+ _
+ ) = self.prepare_inputs_labels_for_speech_vision_text(
+ inputs,
+ position_ids,
+ attention_mask,
+ None,
+ None,
+ speech,
+ speech_lengths,
+ speech_chunks,
+ speech_wav,
+ images,
+ modalities,
+ image_sizes,
+ images_highres
+ )
+
+ return super().generate(
+ position_ids=position_ids,
+ attention_mask=attention_mask,
+ inputs_embeds=inputs_embeds,
+ **kwargs
+ )
+
+ def prepare_inputs_for_generation(self, input_ids, past_key_values=None,
+ inputs_embeds=None, **kwargs):
+ speech = kwargs.pop("speech", None)
+ speech_lengths = kwargs.pop("speech_lengths", None)
+ speech_chunks = kwargs.pop("speech_chunks", None)
+ images = kwargs.pop("images", None)
+ image_sizes = kwargs.pop("image_sizes", None)
+ inputs = super().prepare_inputs_for_generation(
+ input_ids, past_key_values=past_key_values, inputs_embeds=inputs_embeds, **kwargs
+ )
+ if speech is not None:
+ inputs['speech'] = speech
+ inputs['speech_lengths'] = speech_lengths
+ inputs['speech_chunks'] = speech_chunks
+ if images is not None:
+ inputs["images"] = images
+ if image_sizes is not None:
+ inputs["image_sizes"] = image_sizes
+ return inputs
+
+AutoConfig.register("ola_qwen", OlaConfigQwen)
+AutoModelForCausalLM.register(OlaConfigQwen, OlaQwenForCausalLM)
diff --git a/vlmeval/vlm/ola/ola/model/multimodal_encoder/builder.py b/vlmeval/vlm/ola/ola/model/multimodal_encoder/builder.py
new file mode 100644
index 0000000000000000000000000000000000000000..154a20b1732a9766d01c3b784691de8596b49120
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/model/multimodal_encoder/builder.py
@@ -0,0 +1,9 @@
+import os
+from .oryx_vit import SigLIPViTAnysizeWrapper
+
+def build_vision_tower(vision_tower_cfg, **kwargs):
+ vision_tower = getattr(vision_tower_cfg, 'vision_tower', getattr(vision_tower_cfg, 'mm_vision_tower', None))
+ is_absolute_path_exists = os.path.exists(vision_tower)
+ print(f"Buiding OryxViTWrapper from {vision_tower}...")
+ # path = vision_tower.split(":")[1]
+ return SigLIPViTAnysizeWrapper(vision_tower, path=vision_tower, args=vision_tower_cfg, **kwargs)
\ No newline at end of file
diff --git a/vlmeval/vlm/ola/ola/model/multimodal_encoder/oryx_vit.py b/vlmeval/vlm/ola/ola/model/multimodal_encoder/oryx_vit.py
new file mode 100644
index 0000000000000000000000000000000000000000..cdd85882505f2347eb13e4d7a39701203110ec1d
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/model/multimodal_encoder/oryx_vit.py
@@ -0,0 +1,1041 @@
+import math
+import warnings
+from dataclasses import dataclass
+from functools import partial
+from typing import (
+ Callable,
+ Dict,
+ Final,
+ List,
+ Literal,
+ Optional,
+ Sequence,
+ Set,
+ Tuple,
+ Type,
+ Union,
+)
+
+from torch.utils.checkpoint import checkpoint
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+try:
+ from timm.layers import (
+ AttentionPoolLatent,
+ DropPath,
+ LayerType,
+ Mlp,
+ PatchDropout,
+ PatchEmbed,
+ resample_abs_pos_embed,
+ )
+ from timm.models._manipulate import checkpoint_seq, named_apply
+except:
+ print('Wrong timm version')
+
+from flash_attn import flash_attn_func, flash_attn_varlen_func
+
+from typing import Optional
+
+import logging
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+import deepspeed
+import os
+if 'LOAD_VISION_EARLY' in os.environ:
+ print("LOAD_VISION_EARLY is set")
+ LOAD_VISION_EARLY = True
+else:
+ LOAD_VISION_EARLY = False
+
+if 'FORCE_NO_DOWNSAMPLE' in os.environ:
+ print("FORCE_NO_DOWNSAMPLE is set")
+ FORCE_NO_DOWNSAMPLE = True
+else:
+ FORCE_NO_DOWNSAMPLE = False
+
+def _no_grad_trunc_normal_(tensor, mean, std, a, b):
+ # Cut & paste from PyTorch official master until it's in a few official releases - RW
+ # Method based on https://people.sc.fsu.edu/~jburkardt/presentations/truncated_normal.pdf
+ def norm_cdf(x):
+ # Computes standard normal cumulative distribution function
+ return (1.0 + math.erf(x / math.sqrt(2.0))) / 2.0
+
+ if (mean < a - 2 * std) or (mean > b + 2 * std):
+ warnings.warn(
+ "mean is more than 2 std from [a, b] in nn.init.trunc_normal_. "
+ "The distribution of values may be incorrect.",
+ stacklevel=2,
+ )
+
+ with torch.no_grad():
+ # Values are generated by using a truncated uniform distribution and
+ # then using the inverse CDF for the normal distribution.
+ # Get upper and lower cdf values
+ l = norm_cdf((a - mean) / std) # noqa: E741
+ u = norm_cdf((b - mean) / std)
+
+ # Uniformly fill tensor with values from [l, u], then translate to
+ # [2l-1, 2u-1].
+ tensor.uniform_(2 * l - 1, 2 * u - 1)
+
+ # Use inverse cdf transform for normal distribution to get truncated
+ # standard normal
+ tensor.erfinv_()
+
+ # Transform to proper mean, std
+ tensor.mul_(std * math.sqrt(2.0))
+ tensor.add_(mean)
+
+ # Clamp to ensure it's in the proper range
+ tensor.clamp_(min=a, max=b)
+ return tensor
+
+
+def trunc_normal_(tensor, mean=0.0, std=1.0, a=-2.0, b=2.0):
+ # type: (torch.Tensor, float, float, float, float) -> torch.Tensor
+ r"""The original timm.models.layers.weight_init.trunc_normal_ can not handle bfloat16 yet, here we first
+ convert the tensor to float32, apply the trunc_normal_() in float32, and then convert it back to its orignal dtype.
+ Fills the input Tensor with values drawn from a truncated normal distribution. The values are effectively drawn
+ from the normal distribution :math:`\mathcal{N}(\text{mean}, \text{std}^2)`
+ with values outside :math:`[a, b]` redrawn until they are within
+ the bounds. The method used for generating the random values works
+ best when :math:`a \leq \text{mean} \leq b`.
+ Args:
+ tensor: an n-dimensional `torch.Tensor`
+ mean: the mean of the normal distribution
+ std: the standard deviation of the normal distribution
+ a: the minimum cutoff value
+ b: the maximum cutoff value
+ Examples:
+ >>> w = torch.empty(3, 5)
+ >>> nn.init.trunc_normal_(w)
+ """
+
+ with torch.no_grad():
+ dtype = tensor.dtype
+ tensor_fp32 = tensor.float()
+ tensor_fp32 = _no_grad_trunc_normal_(tensor_fp32, mean, std, a, b)
+ tensor_dtype = tensor_fp32.to(dtype=dtype)
+ tensor.copy_(tensor_dtype)
+
+
+def init_weights(self):
+ if self.pos_embed is not None:
+ trunc_normal_(self.pos_embed, std=self.pos_embed.shape[1] ** -0.5)
+ trunc_normal_(self.latent, std=self.latent_dim**-0.5)
+
+
+def init_weights_vit_timm(module: nn.Module, name: str = "") -> None:
+ """ViT weight initialization, original timm impl (for reproducibility)"""
+ if isinstance(module, nn.Linear):
+ trunc_normal_(module.weight, std=0.02)
+ if module.bias is not None:
+ nn.init.zeros_(module.bias)
+ elif hasattr(module, "init_weights"):
+ module.init_weights()
+
+
+class Attention(nn.Module):
+ fused_attn: Final[bool]
+
+ def __init__(
+ self,
+ dim: int,
+ num_heads: int = 8,
+ qkv_bias: bool = False,
+ qk_norm: bool = False,
+ attn_drop: float = 0.0,
+ proj_drop: float = 0.0,
+ norm_layer: nn.Module = nn.LayerNorm,
+ ) -> None:
+ super().__init__()
+ assert dim % num_heads == 0, "dim should be divisible by num_heads"
+ self.num_heads = num_heads
+ self.head_dim = dim // num_heads
+ self.scale = self.head_dim**-0.5
+ # self.fused_attn = use_fused_attn()
+ self.fused_attn = True
+
+ self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+ self.q_norm = norm_layer(self.head_dim) if qk_norm else nn.Identity()
+ self.k_norm = norm_layer(self.head_dim) if qk_norm else nn.Identity()
+ self.attn_drop = nn.Dropout(attn_drop)
+ self.proj = nn.Linear(dim, dim)
+ self.proj_drop = nn.Dropout(proj_drop) if proj_drop > 0.0 else nn.Identity()
+
+ def forward(self, x: torch.Tensor, cu_slens=None) -> torch.Tensor:
+ B, N, C = x.shape
+ qkv = (
+ self.qkv(x)
+ .reshape(B, N, 3, self.num_heads, self.head_dim)
+ .permute(2, 0, 3, 1, 4)
+ )
+ q, k, v = qkv.unbind(0)
+ q, k = self.q_norm(q), self.k_norm(k)
+
+ if cu_slens is not None:
+ q = q.permute(0, 2, 1, 3) # B, num_heads, N, C -> B, N, num_heads, C
+ k = k.permute(0, 2, 1, 3)
+ v = v.permute(0, 2, 1, 3)
+ max_seqlen = torch.max(cu_slens[1:] - cu_slens[:-1]).item()
+ x = flash_attn_varlen_func(
+ q.squeeze(0),
+ k.squeeze(0),
+ v.squeeze(0),
+ cu_seqlens_q=cu_slens,
+ cu_seqlens_k=cu_slens,
+ max_seqlen_q=max_seqlen,
+ max_seqlen_k=max_seqlen,
+ softmax_scale=self.scale,
+ causal=False,
+ )
+
+ x = x.reshape(B, N, -1)
+ x = self.proj(x)
+ x = self.proj_drop(x)
+
+ else:
+ q = q.permute(0, 2, 1, 3) # B, num_heads, N, C -> B, N, num_heads, C
+ k = k.permute(0, 2, 1, 3)
+ v = v.permute(0, 2, 1, 3)
+ x = flash_attn_func(q, k, v, softmax_scale=self.scale) # -> b, n, h, c
+
+ x = x.reshape(B, N, -1)
+ x = self.proj(x)
+ x = self.proj_drop(x)
+ # if self.fused_attn:
+ # x = F.scaled_dot_product_attention(
+ # q,
+ # k,
+ # v,
+ # dropout_p=self.attn_drop.p if self.training else 0.0,
+ # )
+ # else:
+ # q = q * self.scale
+ # attn = q @ k.transpose(-2, -1)
+ # attn = attn.softmax(dim=-1)
+ # attn = self.attn_drop(attn)
+ # x = attn @ v
+
+ # x = x.transpose(1, 2).reshape(B, N, C)
+ # x = self.proj(x)
+ # x = self.proj_drop(x)
+ return x
+
+
+class LayerScale(nn.Module):
+ def __init__(
+ self,
+ dim: int,
+ init_values: float = 1e-5,
+ inplace: bool = False,
+ ) -> None:
+ super().__init__()
+ self.inplace = inplace
+ self.gamma = nn.Parameter(init_values * torch.ones(dim))
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ return x.mul_(self.gamma) if self.inplace else x * self.gamma
+
+
+class Block(nn.Module):
+ def __init__(
+ self,
+ dim: int,
+ num_heads: int,
+ mlp_ratio: float = 4.0,
+ qkv_bias: bool = False,
+ qk_norm: bool = False,
+ proj_drop: float = 0.0,
+ attn_drop: float = 0.0,
+ init_values: Optional[float] = None,
+ drop_path: float = 0.0,
+ act_layer: nn.Module = nn.GELU,
+ norm_layer: nn.Module = nn.LayerNorm,
+ mlp_layer: nn.Module = Mlp,
+ ) -> None:
+ super().__init__()
+ self.norm1 = norm_layer(dim)
+ self.attn = Attention(
+ dim,
+ num_heads=num_heads,
+ qkv_bias=qkv_bias,
+ qk_norm=qk_norm,
+ attn_drop=attn_drop,
+ proj_drop=proj_drop,
+ norm_layer=norm_layer,
+ )
+ self.ls1 = (
+ LayerScale(dim, init_values=init_values) if init_values else nn.Identity()
+ )
+ self.drop_path1 = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()
+
+ self.norm2 = norm_layer(dim)
+ self.mlp = mlp_layer(
+ in_features=dim,
+ hidden_features=int(dim * mlp_ratio),
+ act_layer=act_layer,
+ drop=proj_drop,
+ )
+ self.ls2 = (
+ LayerScale(dim, init_values=init_values) if init_values else nn.Identity()
+ )
+ self.drop_path2 = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()
+
+ def forward(self, x: torch.Tensor, cu_slens=None) -> torch.Tensor:
+ x = x + self.drop_path1(self.ls1(self.attn(self.norm1(x), cu_slens=cu_slens)))
+ x = x + self.drop_path2(self.ls2(self.mlp(self.norm2(x))))
+ return x
+
+
+class VisionTransformer(nn.Module):
+ """Vision Transformer
+
+ A PyTorch impl of : `An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale`
+ - https://arxiv.org/abs/2010.11929
+ """
+
+ dynamic_img_size: Final[bool]
+
+ def __init__(
+ self,
+ img_size: Union[int, Tuple[int, int]] = 224,
+ patch_size: Union[int, Tuple[int, int]] = 16,
+ in_chans: int = 3,
+ num_classes: int = 1000,
+ global_pool: Literal["", "avg", "token", "map"] = "token",
+ embed_dim: int = 768,
+ depth: int = 12,
+ num_heads: int = 12,
+ mlp_ratio: float = 4.0,
+ qkv_bias: bool = True,
+ qk_norm: bool = False,
+ init_values: Optional[float] = None,
+ class_token: bool = True,
+ no_embed_class: bool = False,
+ reg_tokens: int = 0,
+ pre_norm: bool = False,
+ fc_norm: Optional[bool] = None,
+ dynamic_img_size: bool = False,
+ dynamic_img_pad: bool = False,
+ drop_rate: float = 0.0,
+ pos_drop_rate: float = 0.0,
+ patch_drop_rate: float = 0.0,
+ proj_drop_rate: float = 0.0,
+ attn_drop_rate: float = 0.0,
+ drop_path_rate: float = 0.0,
+ weight_init: Literal["skip", "jax", "jax_nlhb", "moco", ""] = "",
+ embed_layer: Callable = PatchEmbed,
+ norm_layer: Optional[LayerType] = None,
+ act_layer: Optional[LayerType] = None,
+ strict_img_size: bool = False,
+ block_fn: Type[nn.Module] = Block,
+ mlp_layer: Type[nn.Module] = Mlp,
+ ignore_head: bool = False,
+ add_patch2x2: bool = False,
+ ) -> None:
+ """
+ Args:
+ img_size: Input image size.
+ patch_size: Patch size.
+ in_chans: Number of image input channels.
+ num_classes: Mumber of classes for classification head.
+ global_pool: Type of global pooling for final sequence (default: 'token').
+ embed_dim: Transformer embedding dimension.
+ depth: Depth of transformer.
+ num_heads: Number of attention heads.
+ mlp_ratio: Ratio of mlp hidden dim to embedding dim.
+ qkv_bias: Enable bias for qkv projections if True.
+ init_values: Layer-scale init values (layer-scale enabled if not None).
+ class_token: Use class token.
+ no_embed_class: Don't include position embeddings for class (or reg) tokens.
+ reg_tokens: Number of register tokens.
+ fc_norm: Pre head norm after pool (instead of before), if None, enabled when global_pool == 'avg'.
+ drop_rate: Head dropout rate.
+ pos_drop_rate: Position embedding dropout rate.
+ attn_drop_rate: Attention dropout rate.
+ drop_path_rate: Stochastic depth rate.
+ weight_init: Weight initialization scheme.
+ embed_layer: Patch embedding layer.
+ norm_layer: Normalization layer.
+ act_layer: MLP activation layer.
+ block_fn: Transformer block layer.
+ """
+ super().__init__()
+ assert global_pool in ("", "avg", "token", "map")
+ assert class_token or global_pool != "token"
+ use_fc_norm = global_pool == "avg" if fc_norm is None else fc_norm
+ # norm_layer = get_norm_layer(norm_layer) or partial(nn.LayerNorm, eps=1e-6)
+ # act_layer = get_act_layer(act_layer) or nn.GELU
+ norm_layer = partial(nn.LayerNorm, eps=1e-6)
+ act_layer = nn.GELU
+
+ self.num_classes = num_classes
+ self.global_pool = global_pool
+ self.num_features = self.embed_dim = (
+ embed_dim # num_features for consistency with other models
+ )
+ self.num_prefix_tokens = 1 if class_token else 0
+ self.num_prefix_tokens += reg_tokens
+ self.num_reg_tokens = reg_tokens
+ self.has_class_token = class_token
+ self.no_embed_class = (
+ no_embed_class # don't embed prefix positions (includes reg)
+ )
+ self.dynamic_img_size = dynamic_img_size
+ self.grad_checkpointing = False
+ self.ignore_head = ignore_head
+
+ embed_args = {}
+ if dynamic_img_size:
+ # flatten deferred until after pos embed
+ embed_args.update(dict(strict_img_size=False, output_fmt="NHWC"))
+ self.patch_embed = embed_layer(
+ img_size=img_size,
+ patch_size=patch_size,
+ in_chans=in_chans,
+ embed_dim=embed_dim,
+ bias=not pre_norm, # disable bias if pre-norm is used (e.g. CLIP)
+ dynamic_img_pad=dynamic_img_pad,
+ strict_img_size=strict_img_size,
+ **embed_args,
+ )
+ num_patches = self.patch_embed.num_patches
+
+ self.cls_token = (
+ nn.Parameter(torch.zeros(1, 1, embed_dim)) if class_token else None
+ )
+ self.reg_token = (
+ nn.Parameter(torch.zeros(1, reg_tokens, embed_dim)) if reg_tokens else None
+ )
+ embed_len = (
+ num_patches if no_embed_class else num_patches + self.num_prefix_tokens
+ )
+ self.pos_embed = nn.Parameter(torch.randn(1, embed_len, embed_dim) * 0.02)
+
+
+ # deepspeed.zero.register_external_parameter(self, self.pos_embed)
+ # deepspeed.zero.register_external_parameter(self, self.patch_embed.proj.weight)
+ # deepspeed.zero.register_external_parameter(self, self.patch_embed.proj.bias)
+ # print(self.patch_embed.state_dict().keys())
+
+
+ self.pos_drop = nn.Dropout(p=pos_drop_rate)
+ if patch_drop_rate > 0:
+ self.patch_drop = PatchDropout(
+ patch_drop_rate,
+ num_prefix_tokens=self.num_prefix_tokens,
+ )
+ else:
+ self.patch_drop = nn.Identity()
+ self.norm_pre = norm_layer(embed_dim) if pre_norm else nn.Identity()
+
+ dpr = [
+ x.item() for x in torch.linspace(0, drop_path_rate, depth)
+ ] # stochastic depth decay rule
+ self.blocks = nn.Sequential(
+ *[
+ block_fn(
+ dim=embed_dim,
+ num_heads=num_heads,
+ mlp_ratio=mlp_ratio,
+ qkv_bias=qkv_bias,
+ qk_norm=qk_norm,
+ init_values=init_values,
+ proj_drop=proj_drop_rate,
+ attn_drop=attn_drop_rate,
+ drop_path=dpr[i],
+ norm_layer=norm_layer,
+ act_layer=act_layer,
+ mlp_layer=mlp_layer,
+ )
+ for i in range(depth)
+ ]
+ )
+
+
+ if add_patch2x2:
+ if add_patch2x2 == 'v2':
+ self.downsample = nn.Sequential(
+ nn.Conv2d(embed_dim, embed_dim*2, kernel_size=2, stride=2),
+ nn.GELU(),
+ nn.Conv2d(embed_dim*2, embed_dim*4, 1)
+ )
+ else:
+ mid_dim = embed_dim * 2
+ self.downsample = nn.Sequential(
+ nn.Conv2d(embed_dim, mid_dim, kernel_size=2, stride=2),
+ nn.GELU(),
+ nn.Conv2d(mid_dim, mid_dim, 1)
+ )
+
+ else:
+ self.downsample = None
+
+
+ # self.norm = norm_layer(embed_dim) if not use_fc_norm else nn.Identity()
+
+ # # Classifier Head
+ # if global_pool == "map":
+ # AttentionPoolLatent.init_weights = init_weights
+ # self.attn_pool = AttentionPoolLatent(
+ # self.embed_dim,
+ # num_heads=num_heads,
+ # mlp_ratio=mlp_ratio,
+ # norm_layer=norm_layer,
+ # )
+ # else:
+ # self.attn_pool = None
+ # self.fc_norm = norm_layer(embed_dim) if use_fc_norm else nn.Identity()
+ # self.head_drop = nn.Dropout(drop_rate)
+ # self.head = (
+ # nn.Linear(self.embed_dim, num_classes) if num_classes > 0 else nn.Identity()
+ # )
+
+ # if weight_init != "skip":
+ # self.init_weights(weight_init)
+
+ def init_weights(self, mode: Literal["jax", "jax_nlhb", "moco", ""] = "") -> None:
+ assert mode in ("jax", "jax_nlhb", "moco", "")
+ # head_bias = -math.log(self.num_classes) if "nlhb" in mode else 0.0
+ trunc_normal_(self.pos_embed, std=0.02)
+ if self.cls_token is not None:
+ nn.init.normal_(self.cls_token, std=1e-6)
+ named_apply(init_weights_vit_timm, self)
+
+ @torch.jit.ignore
+ def no_weight_decay(self) -> Set:
+ return {"pos_embed", "cls_token", "dist_token"}
+
+ @torch.jit.ignore
+ def group_matcher(self, coarse: bool = False) -> Dict:
+ return dict(
+ stem=r"^cls_token|pos_embed|patch_embed", # stem and embed
+ blocks=[(r"^blocks\.(\d+)", None), (r"^norm", (99999,))],
+ )
+
+ @torch.jit.ignore
+ def set_grad_checkpointing(self, enable: bool = True) -> None:
+ self.grad_checkpointing = enable
+
+ @torch.jit.ignore
+ def get_classifier(self) -> nn.Module:
+ return self.head
+
+ def reset_classifier(self, num_classes: int, global_pool=None) -> None:
+ self.num_classes = num_classes
+ if global_pool is not None:
+ assert global_pool in ("", "avg", "token", "map")
+ if global_pool == "map" and self.attn_pool is None:
+ assert (
+ False
+ ), "Cannot currently add attention pooling in reset_classifier()."
+ elif global_pool != "map " and self.attn_pool is not None:
+ self.attn_pool = None # remove attention pooling
+ self.global_pool = global_pool
+ self.head = (
+ nn.Linear(self.embed_dim, num_classes) if num_classes > 0 else nn.Identity()
+ )
+
+ def rescale_positional_embedding(self, out_size):
+ h, w = out_size
+ pos_embed_shape = int((self.pos_embed.shape[1]) ** 0.5)
+ if (h, w) == (pos_embed_shape, pos_embed_shape):
+ return self.pos_embed
+ rescaled_positional_embedding = \
+ self.pos_embed.new_zeros(1, h*w, self.pos_embed.shape[2])
+ pe_2d = self.pos_embed[0].T.contiguous().view(1, -1, pos_embed_shape, pos_embed_shape)
+ pe_2d = F.interpolate(pe_2d, out_size, mode='bilinear', align_corners=False).view(-1, h*w)
+ rescaled_positional_embedding[0] = pe_2d.T.contiguous()
+ return rescaled_positional_embedding
+
+ def _pos_embed(self, x: torch.Tensor) -> torch.Tensor:
+ if self.dynamic_img_size:
+ B, H, W, C = x.shape
+ pos_embed = resample_abs_pos_embed(
+ self.pos_embed,
+ (H, W),
+ num_prefix_tokens=0 if self.no_embed_class else self.num_prefix_tokens,
+ )
+ x = x.view(B, -1, C)
+ else:
+ pos_embed = self.pos_embed
+
+ to_cat = []
+ if self.cls_token is not None:
+ to_cat.append(self.cls_token.expand(x.shape[0], -1, -1))
+ if self.reg_token is not None:
+ to_cat.append(self.reg_token.expand(x.shape[0], -1, -1))
+
+ if self.no_embed_class:
+ # deit-3, updated JAX (big vision)
+ # position embedding does not overlap with class token, add then concat
+ x = x + pos_embed
+ if to_cat:
+ x = torch.cat(to_cat + [x], dim=1)
+ else:
+ # original timm, JAX, and deit vit impl
+ # pos_embed has entry for class token, concat then add
+ if to_cat:
+ x = torch.cat(to_cat + [x], dim=1)
+ x = x + pos_embed
+
+ return self.pos_drop(x)
+
+ def _intermediate_layers(
+ self,
+ x: torch.Tensor,
+ n: Union[int, Sequence] = 1,
+ ) -> List[torch.Tensor]:
+ outputs, num_blocks = [], len(self.blocks)
+ take_indices = set(
+ range(num_blocks - n, num_blocks) if isinstance(n, int) else n
+ )
+
+ # forward pass
+ x = self.patch_embed(x)
+ x = self._pos_embed(x)
+ x = self.patch_drop(x)
+ x = self.norm_pre(x)
+ for i, blk in enumerate(self.blocks):
+ x = blk(x)
+ if i in take_indices:
+ outputs.append(x)
+
+ return outputs
+
+ def get_intermediate_layers(
+ self,
+ x: torch.Tensor,
+ n: Union[int, Sequence] = 1,
+ reshape: bool = False,
+ return_prefix_tokens: bool = False,
+ norm: bool = False,
+ ) -> Tuple[Union[torch.Tensor, Tuple[torch.Tensor]]]:
+ """Intermediate layer accessor (NOTE: This is a WIP experiment).
+ Inspired by DINO / DINOv2 interface
+ """
+ # take last n blocks if n is an int, if in is a sequence, select by matching indices
+ outputs = self._intermediate_layers(x, n)
+ if norm:
+ outputs = [self.norm(out) for out in outputs]
+ prefix_tokens = [out[:, 0 : self.num_prefix_tokens] for out in outputs]
+ outputs = [out[:, self.num_prefix_tokens :] for out in outputs]
+
+ if reshape:
+ grid_size = self.patch_embed.grid_size
+ outputs = [
+ out.reshape(x.shape[0], grid_size[0], grid_size[1], -1)
+ .permute(0, 3, 1, 2)
+ .contiguous()
+ for out in outputs
+ ]
+
+ if return_prefix_tokens:
+ return tuple(zip(outputs, prefix_tokens))
+ return tuple(outputs)
+
+ def forward_features_list(self, x_list):
+ x_all = []
+ image_sizes = []
+ for x in x_list:
+ bs, _, h, w = x.shape
+
+ # fix patch size=14 in datasets
+ pad_h = (self.patch_embed.patch_size[0] - h % self.patch_embed.patch_size[0]) % self.patch_embed.patch_size[0]
+ pad_w = (self.patch_embed.patch_size[1] - w % self.patch_embed.patch_size[1]) % self.patch_embed.patch_size[1]
+ x = F.pad(x, (0, pad_w, 0, pad_h))
+
+ bs, _, h, w = x.shape
+
+ h = h // self.patch_embed.patch_size[0]
+ w = w // self.patch_embed.patch_size[1]
+
+ x = self.patch_embed(x)
+ # x = self._pos_embed(x)
+ x = x + self.rescale_positional_embedding(out_size=(h, w))
+ x = self.patch_drop(x)
+ x = self.norm_pre(x)
+ x_all.append(x)
+ image_sizes.append((h, w))
+
+ slen = [xi.size(1) for xi in x_all]
+ x = torch.cat(x_all, dim=1)
+
+ cu_indices = [0, ]
+ for i in slen:
+ cu_indices.append(cu_indices[-1] + i)
+
+ cu_slens = torch.tensor(cu_indices, dtype=torch.int32).to(x.device)
+ for idx, blk in enumerate(self.blocks):
+ if self.grad_checkpointing and not torch.jit.is_scripting():
+ x = checkpoint(blk, x, cu_slens, use_reentrant=True)
+ else:
+ x = blk(x, cu_slens=cu_slens)
+ feats = x.split(slen, dim=1) #[(1, slen, c)]
+
+ if self.downsample is not None:
+ new_feats = []
+ new_sizes = []
+ for f, s in zip(feats, image_sizes):
+ h, w = s
+ b, n, c = f.size()
+ f = f.reshape(b, h, w, c).permute(0, 3, 1, 2)
+ f = self.downsample(f)
+ b, c, h, w = f.size()
+ f = f.permute(0, 2, 3, 1).reshape(b, h*w, c)
+ new_feats.append(f)
+ new_sizes.append((h, w))
+ return new_feats, new_sizes
+
+
+ return feats, image_sizes
+
+ def forward_features(self, x: torch.Tensor) -> torch.Tensor:
+ bs, _, h, w = x.shape
+ h = h // self.patch_embed.patch_size[0]
+ w = w // self.patch_embed.patch_size[1]
+
+ x = self.patch_embed(x)
+ # x = self._pos_embed(x)
+ x = x + self.rescale_positional_embedding(out_size=(h, w))
+ x = self.patch_drop(x)
+ x = self.norm_pre(x)
+ if self.grad_checkpointing and not torch.jit.is_scripting():
+ x = checkpoint_seq(self.blocks, x)
+ else:
+ x = self.blocks(x)
+
+ if self.downsample is not None:
+ b, n, c = x.size()
+ x = x.reshape(b, h, w, c).permute(0, 3, 1, 2)
+ x = self.downsample(x)
+ b, c, h, w = x.size()
+ x = x.permute(0, 2, 3, 1).reshape(b, h*w, c)
+ new_feats = x
+ new_sizes = (h, w)
+ return new_feats, new_sizes
+
+ return x, (h, w)
+
+ def forward_head(self, x: torch.Tensor, pre_logits: bool = False) -> torch.Tensor:
+ x = self.norm(x)
+ if self.attn_pool is not None:
+ x = self.attn_pool(x)
+ elif self.global_pool == "avg":
+ x = x[:, self.num_prefix_tokens :].mean(dim=1)
+ elif self.global_pool:
+ x = x[:, 0] # class token
+ x = self.fc_norm(x)
+ x = self.head_drop(x)
+ return x if pre_logits else self.head(x)
+
+ def forward(self, x, cal_attn_pool=False):
+ if type(x) is list:
+ x, image_sizes = self.forward_features_list(x)
+ return x, image_sizes, None
+ else:
+ x, image_sizes = self.forward_features(x)
+ return x, image_sizes, None
+
+@dataclass
+class SigLIPVisionCfg:
+ width: int = 1152
+ layers: Union[Tuple[int, int, int, int], int] = 27
+ heads: int = 16
+ patch_size: int = 14
+ image_size: Union[Tuple[int, int], int] = 336
+ global_pool: str = "map"
+ mlp_ratio: float = 3.7362
+ class_token: bool = False
+ num_classes: int = 0
+ use_checkpoint: bool = False
+
+
+SigLIP_MODEL_CONFIG = {
+ "siglip_so400m_patch14_384": {
+ "image_size": 384,
+ "patch_size": 14,
+ "width": 1152,
+ "layers": 27,
+ "heads": 16,
+ "mlp_ratio": 3.7362,
+ "global_pool": "map",
+ "use_checkpoint": False,
+ },
+ "siglip_so400m_patch16_384": {
+ "image_size": 384,
+ "patch_size": 16,
+ "width": 1152,
+ "layers": 27,
+ "heads": 16,
+ "mlp_ratio": 3.7362,
+ "global_pool": "map",
+ "use_checkpoint": False,
+ },
+ "siglip_so400m_patch14_224": {
+ "image_size": 224,
+ "patch_size": 14,
+ "width": 1152,
+ "layers": 27,
+ "heads": 16,
+ "mlp_ratio": 3.7362,
+ "global_pool": "map",
+ "use_checkpoint": False,
+ },
+ "siglip_large_patch16_384": {
+ "image_size": 384,
+ "patch_size": 16,
+ "width": 1024,
+ "layers": 24,
+ "heads": 16,
+ "mlp_ratio": 4,
+ "global_pool": "map",
+ "use_checkpoint": False,
+ },
+}
+
+
+def resize_evaclip_pos_embed(model: VisionTransformer, interpolation: str = 'bicubic'):
+ # interpolate position embedding
+ orig_size = 24
+ new_size = 128
+ pos_tokens = model.pos_embed
+ pos_tokens = pos_tokens.reshape(-1, orig_size, orig_size, model.embed_dim).permute(0, 3, 1, 2)
+ pos_tokens = torch.nn.functional.interpolate(
+ pos_tokens, size=(new_size, new_size), mode=interpolation, align_corners=False)
+ pos_tokens = pos_tokens.permute(0, 2, 3, 1).flatten(1, 2)
+ model.pos_embed = nn.Parameter(pos_tokens, requires_grad=True)
+ return model
+
+def create_siglip_vit(
+ model_name: str = "siglip_so400m_patch14_384",
+ image_size: int = 384,
+ select_layer: int = -1,
+ path: str = "",
+ gradient_checkpointing: bool = False,
+ **kwargs,
+):
+ assert (
+ model_name in SigLIP_MODEL_CONFIG.keys()
+ ), f"model name should be in {SigLIP_MODEL_CONFIG.keys()}"
+
+ vision_cfg = SigLIPVisionCfg(**SigLIP_MODEL_CONFIG[model_name])
+
+ if select_layer <= 0:
+ layers = min(vision_cfg.layers, vision_cfg.layers + select_layer + 1)
+ else:
+ layers = min(vision_cfg.layers, select_layer)
+
+
+
+ if 'patch2x2' or 'patch4x4' in path:
+ add_patch2x2 = True
+ else:
+ add_patch2x2 = False
+
+ if 'patch4x4pool' in path or 'patch2x2from4x4' in path:
+ add_patch2x2 = 'v2'
+
+ if FORCE_NO_DOWNSAMPLE:
+ add_patch2x2 = False
+
+ model = VisionTransformer(
+ img_size=2048,
+ patch_size=16,
+ embed_dim=vision_cfg.width,
+ depth=layers,
+ num_heads=vision_cfg.heads,
+ mlp_ratio=vision_cfg.mlp_ratio,
+ class_token=vision_cfg.class_token,
+ global_pool=vision_cfg.global_pool,
+ dynamic_img_pad=False,
+ strict_img_size=False,
+ ignore_head=kwargs.get("ignore_head", False),
+ weight_init=kwargs.get("weight_init", "skip"),
+ num_classes=0,
+ add_patch2x2=add_patch2x2
+ )
+
+ print("#### Skip loading vision backbone")
+
+ if gradient_checkpointing:
+ model.set_grad_checkpointing(True)
+ return model
+
+from transformers import CLIPImageProcessor
+import torch.distributed as dist
+
+class SigLIPViTAnysizeWrapper(nn.Module):
+ def __init__(self, vision_tower, path, args, delay_load=False):
+ super().__init__()
+
+ self.is_loaded = False
+
+ self.vision_tower_name = vision_tower
+ self.args = args
+ self.path = path
+
+ self.select_layer = -1
+ if self.select_layer < -1: self.select_layer += 1
+ self.select_feature = getattr(args, 'mm_vision_select_feature', 'patch')
+
+ self.output_dim = 1152
+
+ if not delay_load or LOAD_VISION_EARLY:
+ self.load_model()
+ elif getattr(args, "unfreeze_mm_vision_tower", False):
+ # TODO: better detector is needed.
+ print(f"The checkpoint seems to contain `vision_tower` weights: `unfreeze_mm_vision_tower`: True.")
+ self.load_model()
+
+ def load_model(self, device_map=None):
+ if self.is_loaded:
+ print('{} is already loaded, `load_model` called again, skipping.'.format(self.vision_tower_name))
+ return
+
+ self.image_processor = CLIPImageProcessor.from_pretrained("openai/clip-vit-large-patch14")
+ if self.args.mm_projector_type == "conv_mlp" or self.args.mm_projector_type == "multipath_conv_mlp" or self.args.mm_projector_type == "multipath_conv_mlp_woconv":
+ self.image_processor.crop_size['height'] = 384
+ self.image_processor.crop_size['width'] = 384
+ self.image_processor.size['shortest_edge'] = 384
+ print("Resizeing clip processor to 384...")
+ self.image_processor.image_mean = [0.5, 0.5, 0.5]
+ self.image_processor.image_std = [0.5, 0.5, 0.5]
+ print("Loading vision model...")
+
+ self.vision_tower = create_siglip_vit(path=self.path, model_name='siglip_so400m_patch16_384',
+ gradient_checkpointing=False)
+ for p in self.vision_tower.parameters():
+ p.requires_grad = False
+ self.vision_tower.eval()
+ self.is_loaded = True
+
+ def train(self, mode = True):
+ self.training = mode
+
+ if self.is_loaded:
+ self.vision_tower.eval()
+
+ def split_images(self, images, split_res=512, base_size=32):
+ split_images = []
+ sub_images_info = []
+ for image in images:
+ now_sub_images = []
+ _, c, h, w = image.shape
+ if h * w <= split_res * split_res:
+ split_images.append(image)
+ sub_images_info.append(
+ (
+ 1, 1, 1, h // base_size, w // base_size, [(0, h // base_size, 0, w // base_size)]
+ )
+ )
+ continue
+ nsplit_h = math.ceil(h / split_res)
+ nsplit_w = math.ceil(w / split_res)
+ sub_h = int(h / nsplit_h / base_size) * base_size
+ sub_w = int(w / nsplit_w / base_size) * base_size
+ crop_infos = []
+ for i in range(nsplit_h):
+ for j in range(nsplit_w):
+ begin_h = i * sub_h
+ begin_w = j * sub_w
+
+ if i == nsplit_h - 1:
+ end_h = h
+ else:
+ end_h = (i + 1) * sub_h
+
+ if j == nsplit_w - 1:
+ end_w = w
+ else:
+ end_w = (j + 1) * sub_w
+
+ assert (end_h - begin_h) % base_size == 0 and (end_w - begin_w) % base_size == 0
+
+ sub_image = image[:, :, begin_h:end_h, begin_w:end_w]
+ now_sub_images.append(sub_image)
+ crop_infos.append(
+ (begin_h // base_size, end_h // base_size, begin_w // base_size, end_w // base_size)
+ )
+
+ split_images += now_sub_images
+ sub_images_info.append(
+ (
+ len(now_sub_images), nsplit_h, nsplit_w, h // base_size, w // base_size, crop_infos
+ )
+ )
+
+ return split_images, sub_images_info
+
+
+ def unsplit_images(self, features, sizes, sub_images_info):
+ new_features = []
+ for feature, size in zip(features, sizes):
+ h, w = size
+ new_features.append(
+ feature.reshape(1, h, w, -1)
+ )
+
+ fused_images = []
+ images_sizes = []
+ sub_count = 0
+ for n_split, nsplit_h, nsplit_w, total_h, total_w, crop_infos in sub_images_info:
+ sub_features = new_features[sub_count:sub_count+n_split]
+ sub_count += n_split
+
+ total_feature = new_features[0].new_zeros(1, total_h, total_w, self.hidden_size)
+ for feature, (begin_h, end_h, begin_w, end_w) in zip(sub_features, crop_infos):
+ total_feature[:, begin_h:end_h, begin_w:end_w] += feature
+
+ fused_images.append(total_feature.reshape(1, total_h * total_w, self.hidden_size))
+ images_sizes.append((total_h, total_w))
+
+ return fused_images, images_sizes
+
+
+
+ def forward_func(self, images, force_fix_size=False, cal_attn_pool=False):
+ if type(images) is list:
+ xs = [x.to(self.dtype) for x in images]
+ image_features, img_size, cls_token = self.vision_tower(xs, cal_attn_pool=cal_attn_pool)
+ image_features = [x.to(images[0].dtype) for x in image_features]
+
+ else:
+ image_forward_outs, img_size, cls_token = self.vision_tower(images.to(self.dtype), cal_attn_pool=cal_attn_pool)
+ image_features = image_forward_outs.to(images.dtype)
+
+ return image_features, img_size, cls_token
+
+ def forward(self, images, cal_attn_pool=False):
+ with torch.no_grad():
+ image_features, img_size, cls_token = self.forward_func(images, cal_attn_pool=cal_attn_pool)
+ return image_features, img_size
+
+
+ @property
+ def dummy_feature(self):
+ return torch.zeros(1, 1152, device=self.device, dtype=self.dtype)
+
+ @property
+ def dtype(self):
+ return self.vision_tower.pos_embed.dtype
+
+ @property
+ def device(self):
+ return self.vision_tower.pos_embed.device
+
+ @property
+ def hidden_size(self):
+ return self.output_dim
+
+ @property
+ def config(self):
+ return type('LLaVAConfigWrapper', (), {
+ # 'image_size': 224,
+ 'patch_size': 16,
+ })()
diff --git a/vlmeval/vlm/ola/ola/model/multimodal_projector/builder.py b/vlmeval/vlm/ola/ola/model/multimodal_projector/builder.py
new file mode 100644
index 0000000000000000000000000000000000000000..ef3a0af08d75fadabdb0807e0ee0d4fd2d4dc4d9
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/model/multimodal_projector/builder.py
@@ -0,0 +1,182 @@
+import torch
+import torch.nn as nn
+import re
+
+import math
+
+from .pooler_projector import NormalizedDwPooler
+import os
+import math
+
+
+if 'REGIONAL_POOL' in os.environ:
+ REGIONAL_POOL = os.environ['REGIONAL_POOL']
+else:
+ REGIONAL_POOL = '2x'
+print(f"REGIONAL_POOL is set as {REGIONAL_POOL}")
+
+class IdentityMap(nn.Module):
+ def __init__(self):
+ super().__init__()
+
+ def forward(self, x, *args, **kwargs):
+ return x
+
+ @property
+ def config(self):
+ return {"mm_projector_type": 'identity'}
+
+
+class SimpleResBlock(nn.Module):
+ def __init__(self, channels):
+ super().__init__()
+ self.pre_norm = nn.LayerNorm(channels)
+
+ self.proj = nn.Sequential(
+ nn.Linear(channels, channels),
+ nn.GELU(),
+ nn.Linear(channels, channels)
+ )
+ def forward(self, x):
+ x = self.pre_norm(x)
+ return x + self.proj(x)
+
+class OlaMLP(nn.Module):
+ def __init__(self, in_channels, out_channels, twoview=False):
+ super().__init__()
+
+ self.proj1 = nn.Linear(in_channels, out_channels)
+ self.proj2 = nn.Linear(out_channels, out_channels)
+ self.act = nn.GELU()
+ self.pooler = NormalizedDwPooler(out_channels)
+
+ embed_std = 1 / math.sqrt(out_channels)
+ self.image_newline = nn.Parameter(
+ torch.randn(out_channels) * embed_std
+ )
+ self.image_begin = nn.Parameter(
+ torch.randn(out_channels) * embed_std
+ )
+ self.image_end = nn.Parameter(
+ torch.randn(out_channels) * embed_std
+ )
+
+ if twoview:
+ self.image_sep = nn.Parameter(
+ torch.randn(out_channels) * embed_std
+ )
+
+ def forward(self, x, size=(16,16), x2=None, size2=(16, 16), modalities='image'):
+
+ if modalities in ['image', 'text']:
+ h, w = size
+ dtype = x.dtype
+ x = x.reshape(x.shape[0], h, w, -1)
+ x = self.proj1(x)
+ x = self.pooler(x, forward_type=REGIONAL_POOL)
+ x = self.act(x)
+ x = self.proj2(x)
+
+
+ b, h, w, c = x.shape
+ x = torch.cat([
+ x,
+ self.image_newline.reshape(1, 1, 1, c).expand(b, h, 1, c).to(dtype)
+ ], dim=2)
+ x = x.reshape(b, -1, c)
+
+ if x2 is not None:
+ h2, w2 = size2
+ x2 = x2.reshape(x2.shape[0], h2, w2, -1)
+ x2 = self.proj1(x2)
+ x2 = self.pooler(x2, forward_type=REGIONAL_POOL)
+ x2 = self.act(x2)
+ x2 = self.proj2(x2)
+
+ b2, h2, w2, c2 = x2.shape
+ x2 = torch.cat([
+ x2,
+ self.image_newline.reshape(1, 1, 1, c).expand(b, h2, 1, c).to(dtype)
+ ], dim=2)
+ x2 = x2.reshape(b, -1, c)
+ sep = self.image_sep.reshape(1, 1, -1).expand(b, 1, c2).to(dtype)
+ if os.environ.get('USE_HIGHRES_ONLY', '0') == '1':
+ x = x2
+ else:
+ x = torch.cat([x, sep, x2], dim=1)
+
+ begin = self.image_begin.reshape(1, 1, -1).expand(b, 1, c).to(dtype)
+ end = self.image_end.reshape(1, 1, -1).expand(b, 1, c).to(dtype)
+ x = torch.cat([begin, x, end], dim=1)
+ return x
+ elif modalities in ['video']:
+ # x2 is the true feature, ignore x
+ h, w = size
+ dtype = x.dtype
+ x = x.reshape(x.shape[0], h, w, -1)
+ x1 = self.proj1(x)
+ x1 = self.pooler(x1, forward_type=REGIONAL_POOL)
+ x1 = self.proj2(x1).mean() * 0.0
+
+ h2, w2 = size2
+ x2 = x2.reshape(x2.shape[0], h2, w2, -1)
+ x2 = self.proj1(x2)
+ x2 = self.pooler(x2, forward_type=REGIONAL_POOL)
+ x2 = self.act(x2)
+ x2 = self.proj2(x2)
+
+ b2, h2, w2, c = x2.shape
+ x2 = torch.cat([
+ x2,
+ self.image_newline.reshape(1, 1, 1, c).expand(b2, h2, 1, c).to(dtype)
+ ], dim=2)
+
+ x2 = x2.reshape(b2, -1, c)
+
+ sep = self.image_sep.reshape(1, 1, -1).expand(b2, 1, c).to(dtype)
+ x2 = torch.cat([x2, sep], dim=1)
+
+ x2 = x2.flatten(0, 1)
+
+ begin = self.image_begin.reshape(1, -1).expand(1, c).to(dtype)
+ end = self.image_end.reshape(1, -1).expand(1, c).to(dtype)
+ x2 = torch.cat([begin, x2, end], dim=0)
+ x2 = x2.unsqueeze(0)
+ return x2
+ else:
+ raise ValueError(f'Unknown modalities: {modalities}')
+
+def build_vision_projector(config, delay_load=False, **kwargs):
+ projector_type = getattr(config, 'mm_projector_type', 'linear')
+
+ if projector_type == 'linear':
+ return nn.Linear(config.mm_hidden_size, config.hidden_size)
+
+ elif projector_type == 'ola_mlp':
+ return OlaMLP(config.mm_hidden_size, config.hidden_size, twoview=True)
+
+ mlp_gelu_match = re.match(r'^mlp(\d+)x_gelu$', projector_type)
+ if mlp_gelu_match:
+ mlp_depth = int(mlp_gelu_match.group(1))
+ modules = [nn.Linear(config.mm_hidden_size, config.hidden_size)]
+ for _ in range(1, mlp_depth):
+ modules.append(nn.GELU())
+ modules.append(nn.Linear(config.hidden_size, config.hidden_size))
+ return nn.Sequential(*modules)
+
+ mlp_gelu_resnet_match = re.match(r'^mlp(\d+)x_res(\d+)x_gelu$', projector_type)
+ if mlp_gelu_resnet_match:
+ mlp_depth = int(mlp_gelu_resnet_match.group(1))
+ res_depth = int(mlp_gelu_resnet_match.group(2))
+ modules = [nn.Linear(config.mm_hidden_size, config.hidden_size)]
+ for _ in range(1, mlp_depth):
+ modules.append(nn.GELU())
+ modules.append(nn.Linear(config.hidden_size, config.hidden_size))
+ for _ in range(res_depth):
+ modules.append(SimpleResBlock(config.hidden_size))
+ return nn.Sequential(*modules)
+
+ if projector_type == 'identity':
+ return IdentityMap()
+
+ raise ValueError(f'Unknown projector type: {projector_type}')
diff --git a/vlmeval/vlm/ola/ola/model/multimodal_projector/pooler_projector.py b/vlmeval/vlm/ola/ola/model/multimodal_projector/pooler_projector.py
new file mode 100644
index 0000000000000000000000000000000000000000..9677a562792d9f86c239f67fd8b349ea888d0223
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/model/multimodal_projector/pooler_projector.py
@@ -0,0 +1,68 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import math
+
+from transformers.models.clip.modeling_clip import CLIPVisionModel
+import os
+
+
+class PoolerProjector(nn.Module):
+ def __init__(self, config, vision_cfg):
+ super().__init__()
+ self._config = config
+ self.hw = vision_cfg.image_size // vision_cfg.patch_size
+
+ self.conv_pool = nn.Conv2d(
+ config.mm_hidden_size, config.hidden_size,
+ kernel_size=2, stride=2
+ )
+
+ self.proj = nn.Sequential(
+ nn.GELU(),
+ nn.Linear(config.hidden_size, config.hidden_size),
+ )
+
+ def forward(self, x, *args, **kwargs):
+ height = width = self.hw
+ assert height * width == x.shape[1]
+ x = x.view(x.shape[0], height, width, -1).permute(0, 3, 1, 2)
+ x = self.conv_pool(x)
+ x = x.flatten(2).transpose(1, 2)
+ x = self.proj(x)
+ return x
+
+ @property
+ def config(self):
+ return {"mm_projector_type": 'pooler'}
+
+
+class NormalizedDwPooler(nn.Module):
+ def __init__(self, dim):
+ super().__init__()
+ self.dim = dim
+ self.predictor = nn.Sequential(
+ nn.Linear(dim*2, dim),
+ nn.GELU(),
+ nn.Linear(dim, dim),
+ )
+
+ def forward(self, x, forward_type='2x'):
+ B, H, W, C = x.shape
+
+ if forward_type == '2x':
+ new_x = x.reshape(B, H//2, 2, W//2, 2, C).permute(0, 1, 3, 2, 4, 5).reshape(B, H//2, W//2, 4, C)
+ pooled_x = new_x.mean(-2, keepdim=True).expand(-1, -1, -1, 4, -1)
+ fused_x = torch.cat([new_x, pooled_x], dim=-1)
+ elif forward_type == '1x':
+ new_x = x.reshape(B, H, W, 1, C)
+ fused_x = torch.cat([new_x, new_x], dim=-1)
+ elif forward_type == '4x':
+ new_x = x.reshape(B, H//4, 4, W//4, 4, C).permute(0, 1, 3, 2, 4, 5).reshape(B, H//4, W//4, 16, C)
+ pooled_x = new_x.mean(-2, keepdim=True).expand(-1, -1, -1, 16, -1)
+ fused_x = torch.cat([new_x, pooled_x], dim=-1)
+
+ score = self.predictor(fused_x)
+ normalized_score = F.softmax(score, dim=-2)
+ new_x = (new_x * normalized_score).sum(dim=-2)
+ return new_x
diff --git a/vlmeval/vlm/ola/ola/model/multimodal_resampler/builder.py b/vlmeval/vlm/ola/ola/model/multimodal_resampler/builder.py
new file mode 100644
index 0000000000000000000000000000000000000000..91d77fc4cdf217fa84fa19e7faf08638407d8ea7
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/model/multimodal_resampler/builder.py
@@ -0,0 +1,24 @@
+import torch
+
+from .perceiver import DynamicCompressor
+
+class IdentityMap(torch.nn.Module):
+ def __init__(self):
+ super().__init__()
+
+ def forward(self, x, *args, **kwargs):
+ return x
+
+ @property
+ def config(self):
+ return {"mm_resampler_type": None}
+
+def build_vision_resampler(model_args, delay_load=False, **kwargs):
+ # import pdb;pdb.set_trace()
+ resampler_type = getattr(model_args, 'mm_resampler_type', None)
+ if resampler_type == 'dynamic_compressor':
+ return DynamicCompressor(model_args, **kwargs)
+ elif resampler_type is None:
+ return IdentityMap()
+ else:
+ raise ValueError(f'Unknown resampler type: {resampler_type}')
diff --git a/vlmeval/vlm/ola/ola/model/multimodal_resampler/perceiver.py b/vlmeval/vlm/ola/ola/model/multimodal_resampler/perceiver.py
new file mode 100644
index 0000000000000000000000000000000000000000..6515482b6ef1ec5b1d255183ee6ab0fdc4575c11
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/model/multimodal_resampler/perceiver.py
@@ -0,0 +1,73 @@
+import torch
+import torch.nn as nn
+import math
+import torch.nn.functional as F
+import os
+
+class DynamicCompressor(nn.Module):
+ def __init__(self, model_args, vision_tower):
+ super().__init__()
+
+ self.out_channels = vision_tower.hidden_size
+ self.mid_channel = 256
+
+ self.vlm_query_projector = nn.Linear(self.out_channels, self.mid_channel)
+ self.vlm_key_projector = nn.Linear(self.out_channels, self.mid_channel)
+
+ def downsample(self, x):
+ return F.avg_pool2d(x, 2, 2)
+
+ def downsample_4(self, x):
+ return F.avg_pool2d(x, 4, 4)
+
+ def forward(self, image_features, forward_type, image_size=None):
+ if image_size is None:
+ ori_W = int(math.sqrt(image_features.shape[1]))
+ ori_H = int(ori_W)
+ else:
+ ori_H, ori_W = image_size
+ T, N, C = image_features.shape
+ image_features = image_features.view(T, ori_H, ori_W, C).permute(0, 3, 1, 2) # T, C, H, W
+
+ if forward_type == 'video':
+ image_features_pool = self.downsample(image_features)
+ image_feature_attn = image_features.reshape(T, C, ori_H // 2, 2, ori_W // 2, 2).permute(0, 2, 4, 3, 5, 1).reshape(T, ori_H // 2 * ori_W // 2, 4, C)
+ new_image_size = (ori_H // 2, ori_W // 2)
+ elif forward_type == 'image' or forward_type == 'text':
+ image_features_pool = image_features
+ image_feature_attn = image_features.reshape(T, C, ori_H, 1, ori_W, 1).permute(0, 2, 4, 3, 5, 1).reshape(T, ori_H * ori_W, 1, C)
+ new_image_size = (ori_H, ori_W)
+ elif forward_type == 'video_long':
+ image_features_pool = self.downsample_4(image_features)
+ image_feature_attn = image_features.reshape(T, C, ori_H // 4, 4, ori_W // 4, 4).permute(0, 2, 4, 3, 5, 1).reshape(T, ori_H // 4 * ori_W // 4, 16, C)
+ new_image_size = (ori_H // 4, ori_W // 4)
+ else:
+ raise NotImplementedError
+
+ image_features_pool = image_features_pool.flatten(2).permute(0, 2, 1) # T, H*W, C
+ new_t, new_p, _ = image_features_pool.shape
+
+ image_query = self.vlm_query_projector(image_features_pool).reshape(new_t*new_p, self.mid_channel)
+ image_key = self.vlm_key_projector(image_feature_attn).reshape(new_t*new_p, -1, self.mid_channel)
+
+ image_value = image_feature_attn.reshape(new_t*new_p, -1, self.out_channels)
+ # import pdb;pdb.set_trace()
+
+ image_attn = image_query[:,None] @ (image_key.transpose(-1,-2) / (image_key.shape[-1]**0.5))
+ image_attn = image_attn.nan_to_num()
+ attn_feat = (image_attn.softmax(-1) @ image_value).mean(1).reshape(new_t, new_p, C)
+
+ image_features_pool = image_features_pool + attn_feat
+
+ return image_features_pool, new_image_size
+
+ @property
+ def config(self):
+ return {
+ 'mm_resampler_type': 'dynamic_compressor',
+ 'mm_out_channels': self.out_channels,
+ }
+
+ @property
+ def hidden_size(self):
+ return self.out_channels
diff --git a/vlmeval/vlm/ola/ola/model/ola_arch.py b/vlmeval/vlm/ola/ola/model/ola_arch.py
new file mode 100644
index 0000000000000000000000000000000000000000..5eb4e3b8cb81861eb467f02a43e2e256059c2f6b
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/model/ola_arch.py
@@ -0,0 +1,418 @@
+from abc import ABC, abstractmethod
+
+import torch
+
+from .speech_encoder.builder import build_speech_encoder
+from .speech_projector.builder import build_speech_projector
+from ...ola.constants import IGNORE_INDEX, SPEECH_TOKEN_INDEX
+from ...ola.utils import lengths_to_padding_mask
+
+from .multimodal_encoder.builder import build_vision_tower
+from .multimodal_resampler.builder import build_vision_resampler
+from .multimodal_projector.builder import build_vision_projector
+
+from ...ola.constants import IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_PATCH_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN
+
+class OlaMetaModel:
+
+ def __init__(self, config):
+ super(OlaMetaModel, self).__init__(config)
+
+ if hasattr(config, "speech_encoder"):
+ self.speech_encoder = build_speech_encoder(config)
+ self.speech_projector = build_speech_projector(config)
+
+ if hasattr(config, "mm_vision_tower"):
+ self.vision_tower = build_vision_tower(config, delay_load=True)
+ self.vision_resampler = build_vision_resampler(config, vision_tower=self.vision_tower)
+ self.mm_projector = build_vision_projector(config, vision_cfg=self.vision_tower.config)
+
+ def get_speech_encoder(self):
+ speech_encoder = getattr(self, 'speech_encoder', None)
+ if type(speech_encoder) is list:
+ speech_encoder = speech_encoder[0]
+ return speech_encoder
+
+ def get_vision_tower(self):
+ vision_tower = getattr(self, 'vision_tower', None)
+ if type(vision_tower) is list:
+ vision_tower = vision_tower[0]
+ return vision_tower
+
+ def initialize_speech_modules(self, model_args, fsdp=None):
+ self.config.speech_encoder = getattr(model_args, "speech_encoder", None)
+ self.config.speech_encoder_type = getattr(model_args, "speech_encoder_type", None)
+ self.config.speech_projector_type = getattr(model_args, 'speech_projector_type', 'linear')
+ self.config.speech_encoder_ds_rate = getattr(model_args, 'speech_encoder_ds_rate', 5)
+ self.config.speech_encoder_hidden_size = getattr(model_args, 'speech_encoder_hidden_size', 1280)
+
+ if self.get_speech_encoder() is None:
+ speech_encoder = build_speech_encoder(self.config)
+ if fsdp is not None and len(fsdp) > 0:
+ self.speech_encoder = [speech_encoder]
+ else:
+ self.speech_encoder = speech_encoder
+
+ if getattr(self, 'speech_projector', None) is None:
+ self.speech_projector = build_speech_projector(self.config)
+ else:
+ # In case it is frozen by LoRA
+ for p in self.speech_projector.parameters():
+ p.requires_grad = True
+
+ if model_args.pretrain_speech_projector is not None:
+ pretrain_speech_projector_weights = torch.load(model_args.pretrain_speech_projector, map_location='cpu')
+ def get_w(weights, keyword):
+ return {k.split(keyword + '.')[1]: v for k, v in weights.items() if keyword in k}
+ print('Loading pretrain speech projector weights')
+
+ msg = self.speech_projector.load_state_dict(get_w(pretrain_speech_projector_weights, 'speech_projector'), strict=False)
+ print(msg)
+
+ def initialize_vision_modules(self, model_args, fsdp=None):
+ vision_tower = model_args.vision_tower
+ mm_vision_select_layer = model_args.mm_vision_select_layer
+ mm_vision_select_feature = model_args.mm_vision_select_feature
+ pretrain_mm_mlp_adapter = model_args.pretrain_mm_mlp_adapter
+
+ self.config.mm_vision_tower = vision_tower
+
+ if self.get_vision_tower() is None:
+ vision_tower = build_vision_tower(model_args)
+ vision_resampler = build_vision_resampler(model_args, vision_tower=vision_tower)
+ ## Get the mm_spatial_pool_mode and mm_spatial_pool_stride
+ for k, v in vision_resampler.config.items():
+ setattr(self.config, k, v)
+
+ if fsdp is not None and len(fsdp) > 0:
+ self.vision_tower = [vision_tower]
+ self.vision_resampler = [vision_resampler]
+ else:
+ self.vision_tower = vision_tower
+ self.vision_resampler = vision_resampler
+ else:
+ if fsdp is not None and len(fsdp) > 0:
+ vision_resampler = self.vision_resampler[0]
+ vision_tower = self.vision_tower[0]
+ else:
+ vision_resampler = self.vision_resampler
+ vision_tower = self.vision_tower
+ vision_tower.load_model()
+
+ # In case it is frozen by LoRA
+ for p in self.vision_resampler.parameters():
+ p.requires_grad = True
+
+ self.config.use_mm_proj = True
+ self.config.mm_projector_type = getattr(model_args, 'mm_projector_type', 'linear')
+ self.config.mm_hidden_size = getattr(vision_resampler, 'hidden_size', vision_tower.hidden_size)
+
+ self.config.mm_vision_select_layer = mm_vision_select_layer
+ self.config.mm_vision_select_feature = mm_vision_select_feature
+
+ if getattr(self, 'mm_projector', None) is None:
+ self.mm_projector = build_vision_projector(self.config, vision_cfg=vision_tower.config)
+ else:
+ for p in self.mm_projector.parameters():
+ p.requires_grad = True
+
+ if pretrain_mm_mlp_adapter is not None:
+ mm_projector_weights = torch.load(pretrain_mm_mlp_adapter, map_location='cpu')
+ def get_w(weights, keyword):
+ return {k.split(keyword + '.')[1]: v for k, v in weights.items() if keyword in k}
+
+ self.mm_projector.load_state_dict(get_w(mm_projector_weights, 'mm_projector'))
+ print('Loading pretrain mm projector weights')
+ incompatible_keys = self.vision_resampler.load_state_dict(get_w(mm_projector_weights, 'vision_resampler'), strict=False)
+ print(incompatible_keys)
+
+class OlaMetaForCausalLM(ABC):
+
+ @abstractmethod
+ def get_model(self):
+ pass
+
+ def get_speech_encoder(self):
+ return self.get_model().get_speech_encoder()
+
+ def get_vision_tower(self):
+ return self.get_model().get_vision_tower()
+
+ def get_speech_projector(self):
+ return self.get_model().speech_projector
+
+ def encode_speech(self, speech, speech_lengths, speech_wav):
+ # import pdb; pdb.set_trace()
+ speech_encoder_type = self.config.speech_encoder_type
+ speech_encoder = self.get_speech_encoder()
+ if "whisper" in speech_encoder_type.lower():
+ encoder_outs = speech_encoder(speech.permute(0, 2, 1))
+ speech_lengths = (speech_lengths + 1) // 2
+ else:
+ encoder_outs = speech_encoder(speech.permute(0, 2, 1), raw_wav=speech_wav)
+ speech_lengths = (speech_lengths + 1) // 2
+ speech_projector_type = self.config.speech_projector_type
+ speech_projector = self.get_speech_projector()
+ if speech_projector_type == "linear":
+ encoder_outs = speech_projector(encoder_outs)
+ speech_lengths = speech_lengths // speech_projector.k
+ else:
+ raise ValueError(f'Unknown speech projector: {speech_projector_type}')
+ # speech_features = [encoder_outs[i, :speech_lengths[i]] for i in range(len(encoder_outs))]
+ return encoder_outs
+
+ def prepare_inputs_labels_for_speech_vision_text(
+ self, input_ids, position_ids, attention_mask, past_key_values, labels,
+ speech, speech_lengths, speech_chunks, speech_wav, images, modalities, image_sizes=None, images_highres=None
+ ):
+ speech_encoder = self.get_speech_encoder()
+ vision_tower = self.get_vision_tower()
+
+ if speech_encoder is None or input_ids.shape[1] == 1:
+ return input_ids, position_ids, attention_mask, past_key_values, None, labels
+
+ if vision_tower is None or input_ids.shape[1] == 1:
+ return input_ids, position_ids, attention_mask, past_key_values, None, labels
+ # encode speech
+ if not isinstance(speech, list):
+ speech = torch.split(speech, speech_chunks.tolist(), dim=0)
+ speech_lengths = torch.split(speech_lengths, speech_chunks.tolist(), dim=0)
+ speech_wav = torch.split(speech_wav, speech_chunks.tolist(), dim=0)
+ speech_features = []
+ for idx in range(len(speech)):
+ speech_features.append(self.encode_speech(speech[idx], speech_lengths[idx], speech_wav[idx]))
+
+ # encode vision
+ if isinstance(modalities, str):
+ modalities = [modalities]
+
+ video_idx_in_batch = []
+ for modal in range(len(modalities)):
+ if 'video' in modalities[modal]:
+ video_idx_in_batch.append(modal)
+
+ # Fix training with deepspeed zero3
+ num_modality = len(modalities)
+ # try:
+ # world_size = dist.get_world_size()
+ # tensor_in = torch.zeros(1, dtype=torch.int64, device=images[0].device).fill_(num_modality)
+ # tensor_out = torch.zeros(world_size, dtype=torch.int64, device=images[0].device)
+ # dist.all_gather_into_tensor(tensor_out, tensor_in)
+ # max_num_modality = tensor_out.max().item()
+ # except:
+ # max_num_modality = num_modality
+ aimg = images[-1]
+ lowres_img = []
+ for idx, img_feat in enumerate(images):
+ if idx in video_idx_in_batch:
+ img_feat = aimg.new(1, 3, 128, 128).fill_(0)
+ lowres_img.append(img_feat)
+
+ # Fix training with deepspeed zero3
+ # if max_num_modality > num_modality:
+ # for _ in range(max_num_modality - num_modality):
+ # lowres_img.append(aimg.new(1, 3, 64, 64).fill_(0))
+ # images_highres.append(aimg.new(1, 3, 64, 64).fill_(0))
+ # modalities.append('image')
+ lowres_img_features, lowres_img_sizes = self.get_model().get_vision_tower()(lowres_img)
+ highres_img_features = []
+ highres_img_sizes = []
+ for idx, img_feat in enumerate(images_highres):
+ if img_feat.ndim == 5:
+ img_feat = img_feat.squeeze(1)
+ highres_img_feature, highres_img_size = self.get_model().get_vision_tower()(img_feat)
+ highres_img_features.append(highres_img_feature)
+ highres_img_sizes.append(highres_img_size)
+ image_features = []
+ for idx in range(len(modalities)):
+ img_feat = self.get_model().mm_projector(lowres_img_features[idx],
+ lowres_img_sizes[idx],
+ highres_img_features[idx],
+ highres_img_sizes[idx],
+ modalities[idx])
+ image_features.append(img_feat.flatten(0, 1))
+
+ # if max_num_modality > num_modality:
+ # image_features = image_features[:num_modality]
+ # modalities = modalities[:num_modality]
+
+ _labels = labels
+ _position_ids = position_ids
+ _attention_mask = attention_mask
+ if attention_mask is None:
+ attention_mask = torch.ones_like(input_ids, dtype=torch.bool)
+ else:
+ attention_mask = attention_mask.bool()
+ if position_ids is None:
+ position_ids = torch.arange(0, input_ids.shape[1], dtype=torch.long, device=input_ids.device)
+ if labels is None:
+ labels = torch.full_like(input_ids, IGNORE_INDEX)
+
+ # remove the padding using attention_mask -- FIXME
+ _input_ids = input_ids
+ input_ids = [cur_input_ids[cur_attention_mask] for cur_input_ids, cur_attention_mask in zip(input_ids, attention_mask)]
+ labels = [cur_labels[cur_attention_mask] for cur_labels, cur_attention_mask in zip(labels, attention_mask)]
+
+ new_input_embeds = []
+ new_labels = []
+ cur_speech_idx = 0
+ cur_image_idx = 0
+ for batch_idx, cur_input_ids in enumerate(input_ids):
+
+ num_speech = (cur_input_ids == SPEECH_TOKEN_INDEX).sum()
+ num_images = (cur_input_ids == IMAGE_TOKEN_INDEX).sum()
+
+ num_speech_images = (cur_input_ids == IMAGE_TOKEN_INDEX).sum() + (cur_input_ids == SPEECH_TOKEN_INDEX).sum()
+
+ if num_speech_images == 0:
+ cur_speech_features = speech_features[cur_speech_idx]
+ cur_images_features = image_features[cur_image_idx]
+ cur_input_embeds_1 = self.get_model().embed_tokens(cur_input_ids)
+ cur_input_embeds = torch.cat([cur_input_embeds_1, cur_speech_features[0:0], cur_images_features[0:0]], dim=0)
+ new_input_embeds.append(cur_input_embeds)
+ new_labels.append(labels[batch_idx])
+ cur_speech_idx += 1
+ cur_image_idx += 1
+ continue
+
+ speech_image_token_indices = [-1] + torch.where((cur_input_ids == SPEECH_TOKEN_INDEX) | (cur_input_ids == IMAGE_TOKEN_INDEX))[0].tolist() + [cur_input_ids.shape[0]]
+
+ cur_input_ids_nospeech_image = []
+ cur_labels = labels[batch_idx]
+ cur_labels_nospeech_image = []
+ for i in range(len(speech_image_token_indices) - 1):
+ cur_input_ids_nospeech_image.append(cur_input_ids[speech_image_token_indices[i]+1:speech_image_token_indices[i+1]])
+ cur_labels_nospeech_image.append(cur_labels[speech_image_token_indices[i]+1:speech_image_token_indices[i+1]])
+ split_sizes = [x.shape[0] for x in cur_labels_nospeech_image]
+ cur_input_embeds = self.get_model().embed_tokens(torch.cat(cur_input_ids_nospeech_image))
+ cur_input_embeds_no_speech_image = torch.split(cur_input_embeds, split_sizes, dim=0)
+ cur_new_input_embeds = []
+ cur_new_labels = []
+
+ for i in range(num_speech_images + 1):
+ cur_new_input_embeds.append(cur_input_embeds_no_speech_image[i])
+ cur_new_labels.append(cur_labels_nospeech_image[i])
+ if i < num_speech_images:
+ if i < num_images:
+ cur_images_features = image_features[cur_image_idx]
+ cur_image_idx += 1
+ cur_new_input_embeds.append(cur_images_features)
+ cur_new_labels.append(torch.full((cur_images_features.shape[0],), IGNORE_INDEX, device=cur_labels.device, dtype=cur_labels.dtype))
+ else:
+ cur_speech_features = speech_features[cur_speech_idx]
+ cur_speech_idx += 1
+ cur_new_input_embeds.append(cur_speech_features)
+ cur_new_labels.append(torch.full((cur_speech_features.shape[0],), IGNORE_INDEX, device=cur_labels.device, dtype=cur_labels.dtype))
+
+ cur_new_input_embeds = [x.to(self.device) for x in cur_new_input_embeds]
+
+ cur_new_input_embeds = torch.cat(cur_new_input_embeds)
+ cur_new_labels = torch.cat(cur_new_labels)
+
+ if num_images == 0:
+ cur_new_input_embeds = torch.cat([cur_new_input_embeds, image_features[cur_image_idx][0:0]], dim=0)
+ cur_image_idx += 1
+
+ if num_speech == 0:
+ cur_new_input_embeds = torch.cat([cur_new_input_embeds, speech_features[cur_speech_idx][0:0]], dim=0)
+ cur_speech_idx += 1
+
+ new_input_embeds.append(cur_new_input_embeds)
+ new_labels.append(cur_new_labels)
+
+ # Truncate sequences to max length as speech features can make the sequence longer
+ tokenizer_model_max_length = getattr(self.config, 'tokenizer_model_max_length', None)
+ if tokenizer_model_max_length is not None:
+ new_input_embeds = [x[:tokenizer_model_max_length] for x in new_input_embeds]
+ new_labels = [x[:tokenizer_model_max_length] for x in new_labels]
+
+ # Combine them
+ max_len = max(x.shape[0] for x in new_input_embeds)
+ batch_size = len(new_input_embeds)
+
+ new_input_embeds_padded = []
+ new_labels_padded = torch.full((batch_size, max_len), IGNORE_INDEX, dtype=new_labels[0].dtype, device=new_labels[0].device)
+ attention_mask = torch.zeros((batch_size, max_len), dtype=attention_mask.dtype, device=attention_mask.device)
+ position_ids = torch.zeros((batch_size, max_len), dtype=position_ids.dtype, device=position_ids.device)
+
+ for i, (cur_new_embed, cur_new_labels) in enumerate(zip(new_input_embeds, new_labels)):
+ cur_len = cur_new_embed.shape[0]
+ if getattr(self.config, 'tokenizer_padding_side', 'right') == "left":
+ new_input_embeds_padded.append(torch.cat((
+ torch.zeros((max_len - cur_len, cur_new_embed.shape[1]), dtype=cur_new_embed.dtype, device=cur_new_embed.device),
+ cur_new_embed
+ ), dim=0))
+ if cur_len > 0:
+ new_labels_padded[i, -cur_len:] = cur_new_labels
+ attention_mask[i, -cur_len:] = True
+ position_ids[i, -cur_len:] = torch.arange(0, cur_len, dtype=position_ids.dtype, device=position_ids.device)
+ else:
+ new_input_embeds_padded.append(torch.cat((
+ cur_new_embed,
+ torch.zeros((max_len - cur_len, cur_new_embed.shape[1]), dtype=cur_new_embed.dtype, device=cur_new_embed.device)
+ ), dim=0))
+ if cur_len > 0:
+ new_labels_padded[i, :cur_len] = cur_new_labels
+ attention_mask[i, :cur_len] = True
+ position_ids[i, :cur_len] = torch.arange(0, cur_len, dtype=position_ids.dtype, device=position_ids.device)
+
+ new_input_embeds = torch.stack(new_input_embeds_padded, dim=0)
+
+ if _labels is None:
+ new_labels = None
+ else:
+ new_labels = new_labels_padded
+
+ if _attention_mask is None:
+ attention_mask = None
+ else:
+ attention_mask = attention_mask.to(dtype=_attention_mask.dtype)
+
+ if _position_ids is None:
+ position_ids = None
+
+ return None, position_ids, attention_mask, past_key_values, new_input_embeds, new_labels
+
+ def initialize_vision_tokenizer(self, model_args, tokenizer):
+ if model_args.mm_use_im_patch_token:
+ tokenizer.add_tokens([DEFAULT_IMAGE_PATCH_TOKEN], special_tokens=True)
+ self.resize_token_embeddings(len(tokenizer))
+
+ if model_args.mm_use_im_start_end:
+ num_new_tokens = tokenizer.add_tokens([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN], special_tokens=True)
+ self.resize_token_embeddings(len(tokenizer))
+
+ if num_new_tokens > 0:
+ input_embeddings = self.get_input_embeddings().weight.data
+ output_embeddings = self.get_output_embeddings().weight.data
+
+ input_embeddings_avg = input_embeddings[:-num_new_tokens].mean(
+ dim=0, keepdim=True)
+ output_embeddings_avg = output_embeddings[:-num_new_tokens].mean(
+ dim=0, keepdim=True)
+
+ input_embeddings[-num_new_tokens:] = input_embeddings_avg
+ output_embeddings[-num_new_tokens:] = output_embeddings_avg
+
+ if model_args.tune_mm_mlp_adapter:
+ for p in self.get_input_embeddings().parameters():
+ p.requires_grad = True
+ for p in self.get_output_embeddings().parameters():
+ p.requires_grad = False
+
+ if model_args.pretrain_mm_mlp_adapter:
+ mm_projector_weights = torch.load(model_args.pretrain_mm_mlp_adapter, map_location='cpu')
+ embed_tokens_weight = mm_projector_weights['model.embed_tokens.weight']
+ assert num_new_tokens == 2
+ if input_embeddings.shape == embed_tokens_weight.shape:
+ input_embeddings[-num_new_tokens:] = embed_tokens_weight[-num_new_tokens:]
+ elif embed_tokens_weight.shape[0] == num_new_tokens:
+ input_embeddings[-num_new_tokens:] = embed_tokens_weight
+ else:
+ raise ValueError(f"Unexpected embed_tokens_weight shape. Pretrained: {embed_tokens_weight.shape}. Current: {input_embeddings.shape}. Numer of new tokens: {num_new_tokens}.")
+ elif model_args.mm_use_im_patch_token:
+ if model_args.tune_mm_mlp_adapter:
+ for p in self.get_input_embeddings().parameters():
+ p.requires_grad = False
+ for p in self.get_output_embeddings().parameters():
+ p.requires_grad = False
\ No newline at end of file
diff --git a/vlmeval/vlm/ola/ola/model/speech_encoder/beats/BEATs.py b/vlmeval/vlm/ola/ola/model/speech_encoder/beats/BEATs.py
new file mode 100644
index 0000000000000000000000000000000000000000..9bbf36a82bc86705f851d479bd8acb5237c9e425
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/model/speech_encoder/beats/BEATs.py
@@ -0,0 +1,182 @@
+# --------------------------------------------------------
+# BEATs: Audio Pre-Training with Acoustic Tokenizers (https://arxiv.org/abs/2212.09058)
+# Github source: https://github.com/microsoft/unilm/tree/master/beats
+# Copyright (c) 2022 Microsoft
+# Licensed under The MIT License [see LICENSE for details]
+# Based on fairseq code bases
+# https://github.com/pytorch/fairseq
+# --------------------------------------------------------
+
+
+import torch
+import torch.nn as nn
+from torch.nn import LayerNorm
+# import torchaudio.compliance.kaldi as ta_kaldi
+
+from .kaldi import fbank as kaldi_fbank
+
+from .backbone import (
+ TransformerEncoder,
+)
+
+import logging
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+class BEATsConfig:
+ def __init__(self, cfg=None):
+ self.input_patch_size: int = -1 # path size of patch embedding
+ self.embed_dim: int = 512 # patch embedding dimension
+ self.conv_bias: bool = False # include bias in conv encoder
+
+ self.encoder_layers: int = 12 # num encoder layers in the transformer
+ self.encoder_embed_dim: int = 768 # encoder embedding dimension
+ self.encoder_ffn_embed_dim: int = 3072 # encoder embedding dimension for FFN
+ self.encoder_attention_heads: int = 12 # num encoder attention heads
+ self.activation_fn: str = "gelu" # activation function to use
+
+ self.layer_wise_gradient_decay_ratio: float = 1.0 # ratio for layer-wise gradient decay
+ self.layer_norm_first: bool = False # apply layernorm first in the transformer
+ self.deep_norm: bool = False # apply deep_norm first in the transformer
+
+ # dropouts
+ self.dropout: float = 0.1 # dropout probability for the transformer
+ self.attention_dropout: float = 0.1 # dropout probability for attention weights
+ self.activation_dropout: float = 0.0 # dropout probability after activation in FFN
+ self.encoder_layerdrop: float = 0.0 # probability of dropping a tarnsformer layer
+ self.dropout_input: float = 0.0 # dropout to apply to the input (after feat extr)
+
+ # positional embeddings
+ self.conv_pos: int = 128 # number of filters for convolutional positional embeddings
+ self.conv_pos_groups: int = 16 # number of groups for convolutional positional embedding
+
+ # relative position embedding
+ self.relative_position_embedding: bool = False # apply relative position embedding
+ self.num_buckets: int = 320 # number of buckets for relative position embedding
+ self.max_distance: int = 1280 # maximum distance for relative position embedding
+ self.gru_rel_pos: bool = False # apply gated relative position embedding
+
+ # label predictor
+ self.finetuned_model: bool = False # whether the model is a fine-tuned model.
+ self.predictor_dropout: float = 0.1 # dropout probability for the predictor
+ self.predictor_class: int = 527 # target class number for the predictor
+
+ if cfg is not None:
+ self.update(cfg)
+
+ def update(self, cfg: dict):
+ self.__dict__.update(cfg)
+
+
+class BEATs(nn.Module):
+ def __init__(
+ self,
+ cfg: BEATsConfig,
+ ) -> None:
+ super().__init__()
+ logger.info(f"BEATs Config: {cfg.__dict__}")
+
+ self.cfg = cfg
+
+ self.embed = cfg.embed_dim
+ self.post_extract_proj = (
+ nn.Linear(self.embed, cfg.encoder_embed_dim)
+ if self.embed != cfg.encoder_embed_dim
+ else None
+ )
+
+ self.input_patch_size = cfg.input_patch_size
+ self.patch_embedding = nn.Conv2d(1, self.embed, kernel_size=self.input_patch_size, stride=self.input_patch_size,
+ bias=cfg.conv_bias)
+
+ self.dropout_input = nn.Dropout(cfg.dropout_input)
+
+ assert not cfg.deep_norm or not cfg.layer_norm_first
+ self.encoder = TransformerEncoder(cfg)
+ self.layer_norm = LayerNorm(self.embed)
+
+ if cfg.finetuned_model:
+ self.predictor_dropout = nn.Dropout(cfg.predictor_dropout)
+ self.predictor = nn.Linear(cfg.encoder_embed_dim, cfg.predictor_class)
+ else:
+ self.predictor = None
+
+ def forward_padding_mask(
+ self,
+ features: torch.Tensor,
+ padding_mask: torch.Tensor,
+ ) -> torch.Tensor:
+ extra = padding_mask.size(1) % features.size(1)
+ if extra > 0:
+ padding_mask = padding_mask[:, :-extra]
+ padding_mask = padding_mask.view(
+ padding_mask.size(0), features.size(1), -1
+ )
+ padding_mask = padding_mask.all(-1)
+ return padding_mask
+
+ def preprocess(
+ self,
+ source: torch.Tensor,
+ fbank_mean: float = 15.41663,
+ fbank_std: float = 6.55582,
+ ) -> torch.Tensor:
+ fbanks = []
+ for waveform in source:
+ waveform = waveform.unsqueeze(0) * 2 ** 15
+ fbank = kaldi_fbank(waveform, num_mel_bins=128, sample_frequency=16000, frame_length=25, frame_shift=10)
+ fbanks.append(fbank)
+ fbank = torch.stack(fbanks, dim=0)
+ fbank = (fbank - fbank_mean) / (2 * fbank_std)
+ return fbank
+
+ def extract_features(
+ self,
+ source: torch.Tensor,
+ padding_mask: Optional[torch.Tensor] = None,
+ fbank_mean: float = 15.41663,
+ fbank_std: float = 6.55582,
+ feature_only=False,
+ ):
+ fbank = self.preprocess(source, fbank_mean=fbank_mean, fbank_std=fbank_std).to(torch.float32)
+
+ if padding_mask is not None:
+ padding_mask = self.forward_padding_mask(fbank, padding_mask)
+
+ fbank = fbank.unsqueeze(1)
+ features = self.patch_embedding(fbank)
+ features = features.reshape(features.shape[0], features.shape[1], -1)
+ features = features.transpose(1, 2)
+ features = self.layer_norm(features)
+
+ if padding_mask is not None:
+ padding_mask = self.forward_padding_mask(features, padding_mask)
+
+ if self.post_extract_proj is not None:
+ features = self.post_extract_proj(features)
+
+ x = self.dropout_input(features)
+
+ x, layer_results = self.encoder(
+ x,
+ padding_mask=padding_mask,
+ )
+
+ if not feature_only and self.predictor is not None:
+ x = self.predictor_dropout(x)
+ logits = self.predictor(x)
+
+ if padding_mask is not None and padding_mask.any():
+ logits[padding_mask] = 0
+ logits = logits.sum(dim=1)
+ logits = logits / (~padding_mask).sum(dim=1).unsqueeze(-1).expand_as(logits)
+ else:
+ logits = logits.mean(dim=1)
+
+ lprobs = torch.sigmoid(logits)
+
+ return lprobs, padding_mask
+ else:
+ return x, padding_mask
\ No newline at end of file
diff --git a/vlmeval/vlm/ola/ola/model/speech_encoder/beats/Tokenizers.py b/vlmeval/vlm/ola/ola/model/speech_encoder/beats/Tokenizers.py
new file mode 100644
index 0000000000000000000000000000000000000000..597c8902493b38689136b7153f114842c8fd66a3
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/model/speech_encoder/beats/Tokenizers.py
@@ -0,0 +1,174 @@
+# --------------------------------------------------------
+# BEATs: Audio Pre-Training with Acoustic Tokenizers (https://arxiv.org/abs/2212.09058)
+# Github source: https://github.com/microsoft/unilm/tree/master/beats
+# Copyright (c) 2022 Microsoft
+# Licensed under The MIT License [see LICENSE for details]
+# Based on fairseq code bases
+# https://github.com/pytorch/fairseq
+# --------------------------------------------------------
+
+
+import torch
+import torch.nn as nn
+from torch.nn import LayerNorm
+# import torchaudio.compliance.kaldi as ta_kaldi
+
+from .kaldi import fbank as kaldi_fbank
+
+from .backbone import (
+ TransformerEncoder,
+)
+from .quantizer import (
+ NormEMAVectorQuantizer,
+)
+
+import logging
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+class TokenizersConfig:
+ def __init__(self, cfg=None):
+ self.input_patch_size: int = -1 # path size of patch embedding
+ self.embed_dim: int = 512 # patch embedding dimension
+ self.conv_bias: bool = False # include bias in conv encoder
+
+ self.encoder_layers: int = 12 # num encoder layers in the transformer
+ self.encoder_embed_dim: int = 768 # encoder embedding dimension
+ self.encoder_ffn_embed_dim: int = 3072 # encoder embedding dimension for FFN
+ self.encoder_attention_heads: int = 12 # num encoder attention heads
+ self.activation_fn: str = "gelu" # activation function to use
+
+ self.layer_norm_first: bool = False # apply layernorm first in the transformer
+ self.deep_norm: bool = False # apply deep_norm first in the transformer
+
+ # dropouts
+ self.dropout: float = 0.1 # dropout probability for the transformer
+ self.attention_dropout: float = 0.1 # dropout probability for attention weights
+ self.activation_dropout: float = 0.0 # dropout probability after activation in FFN
+ self.encoder_layerdrop: float = 0.0 # probability of dropping a tarnsformer layer
+ self.dropout_input: float = 0.0 # dropout to apply to the input (after feat extr)
+
+ # positional embeddings
+ self.conv_pos: int = 128 # number of filters for convolutional positional embeddings
+ self.conv_pos_groups: int = 16 # number of groups for convolutional positional embedding
+
+ # relative position embedding
+ self.relative_position_embedding: bool = False # apply relative position embedding
+ self.num_buckets: int = 320 # number of buckets for relative position embedding
+ self.max_distance: int = 1280 # maximum distance for relative position embedding
+ self.gru_rel_pos: bool = False # apply gated relative position embedding
+
+ # quantizer
+ self.quant_n: int = 1024 # codebook number in quantizer
+ self.quant_dim: int = 256 # codebook dimension in quantizer
+
+ if cfg is not None:
+ self.update(cfg)
+
+ def update(self, cfg: dict):
+ self.__dict__.update(cfg)
+
+
+class Tokenizers(nn.Module):
+ def __init__(
+ self,
+ cfg: TokenizersConfig,
+ ) -> None:
+ super().__init__()
+ logger.info(f"Tokenizers Config: {cfg.__dict__}")
+
+ self.cfg = cfg
+
+ self.embed = cfg.embed_dim
+ self.post_extract_proj = (
+ nn.Linear(self.embed, cfg.encoder_embed_dim)
+ if self.embed != cfg.encoder_embed_dim
+ else None
+ )
+
+ self.input_patch_size = cfg.input_patch_size
+ self.patch_embedding = nn.Conv2d(1, self.embed, kernel_size=self.input_patch_size, stride=self.input_patch_size,
+ bias=cfg.conv_bias)
+
+ self.dropout_input = nn.Dropout(cfg.dropout_input)
+
+ assert not cfg.deep_norm or not cfg.layer_norm_first
+ self.encoder = TransformerEncoder(cfg)
+ self.layer_norm = LayerNorm(self.embed)
+
+ self.quantize = NormEMAVectorQuantizer(
+ n_embed=cfg.quant_n, embedding_dim=cfg.quant_dim, beta=1.0, kmeans_init=True, decay=0.99,
+ )
+ self.quant_n = cfg.quant_n
+ self.quantize_layer = nn.Sequential(
+ nn.Linear(cfg.encoder_embed_dim, cfg.encoder_embed_dim),
+ nn.Tanh(),
+ nn.Linear(cfg.encoder_embed_dim, cfg.quant_dim) # for quantize
+ )
+
+ def forward_padding_mask(
+ self,
+ features: torch.Tensor,
+ padding_mask: torch.Tensor,
+ ) -> torch.Tensor:
+ extra = padding_mask.size(1) % features.size(1)
+ if extra > 0:
+ padding_mask = padding_mask[:, :-extra]
+ padding_mask = padding_mask.view(
+ padding_mask.size(0), features.size(1), -1
+ )
+ padding_mask = padding_mask.all(-1)
+ return padding_mask
+
+ def preprocess(
+ self,
+ source: torch.Tensor,
+ fbank_mean: float = 15.41663,
+ fbank_std: float = 6.55582,
+ ) -> torch.Tensor:
+ fbanks = []
+ for waveform in source:
+ waveform = waveform.unsqueeze(0) * 2 ** 15
+ fbank = kaldi_fbank(waveform, num_mel_bins=128, sample_frequency=16000, frame_length=25, frame_shift=10)
+ fbanks.append(fbank)
+ fbank = torch.stack(fbanks, dim=0)
+ fbank = (fbank - fbank_mean) / (2 * fbank_std)
+ return fbank
+
+ def extract_labels(
+ self,
+ source: torch.Tensor,
+ padding_mask: Optional[torch.Tensor] = None,
+ fbank_mean: float = 15.41663,
+ fbank_std: float = 6.55582,
+ ):
+ fbank = self.preprocess(source, fbank_mean=fbank_mean, fbank_std=fbank_std)
+
+ if padding_mask is not None:
+ padding_mask = self.forward_padding_mask(fbank, padding_mask)
+
+ fbank = fbank.unsqueeze(1)
+ features = self.patch_embedding(fbank)
+ features = features.reshape(features.shape[0], features.shape[1], -1)
+ features = features.transpose(1, 2)
+ features = self.layer_norm(features)
+
+ if padding_mask is not None:
+ padding_mask = self.forward_padding_mask(features, padding_mask)
+
+ if self.post_extract_proj is not None:
+ features = self.post_extract_proj(features)
+
+ x = self.dropout_input(features)
+
+ x, layer_results = self.encoder(
+ x,
+ padding_mask=padding_mask,
+ )
+
+ quantize_input = self.quantize_layer(x)
+ quantize_feature, embed_loss, embed_ind = self.quantize(quantize_input)
+
+ return embed_ind
diff --git a/vlmeval/vlm/ola/ola/model/speech_encoder/beats/__init__.py b/vlmeval/vlm/ola/ola/model/speech_encoder/beats/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/vlmeval/vlm/ola/ola/model/speech_encoder/beats/backbone.py b/vlmeval/vlm/ola/ola/model/speech_encoder/beats/backbone.py
new file mode 100644
index 0000000000000000000000000000000000000000..ef6ba72a47bb537e025d32580ab0b530a34ca4fb
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/model/speech_encoder/beats/backbone.py
@@ -0,0 +1,782 @@
+# --------------------------------------------------------
+# BEATs: Audio Pre-Training with Acoustic Tokenizers (https://arxiv.org/abs/2212.09058)
+# Github source: https://github.com/microsoft/unilm/tree/master/beats
+# Copyright (c) 2022 Microsoft
+# Licensed under The MIT License [see LICENSE for details]
+# Based on fairseq code bases
+# https://github.com/pytorch/fairseq
+# --------------------------------------------------------
+
+import math
+import numpy as np
+from typing import Dict, Optional, Tuple
+import torch
+from torch import Tensor, nn
+import torch.nn.functional as F
+from torch.nn import LayerNorm, Parameter
+from .modules import (
+ GradMultiply,
+ SamePad,
+ get_activation_fn,
+ GLU_Linear,
+ quant_noise,
+)
+
+
+class TransformerEncoder(nn.Module):
+ def __init__(self, args):
+ super().__init__()
+
+ self.dropout = args.dropout
+ self.embedding_dim = args.encoder_embed_dim
+
+ self.pos_conv = nn.Conv1d(
+ self.embedding_dim,
+ self.embedding_dim,
+ kernel_size=args.conv_pos,
+ padding=args.conv_pos // 2,
+ groups=args.conv_pos_groups,
+ )
+ dropout = 0
+ std = math.sqrt((4 * (1.0 - dropout)) / (args.conv_pos * self.embedding_dim))
+ nn.init.normal_(self.pos_conv.weight, mean=0, std=std)
+ nn.init.constant_(self.pos_conv.bias, 0)
+
+ self.pos_conv = nn.utils.weight_norm(self.pos_conv, name="weight", dim=2)
+ self.pos_conv = nn.Sequential(self.pos_conv, SamePad(args.conv_pos), nn.GELU())
+
+ if hasattr(args, "relative_position_embedding"):
+ self.relative_position_embedding = args.relative_position_embedding
+ self.num_buckets = args.num_buckets
+ self.max_distance = args.max_distance
+ else:
+ self.relative_position_embedding = False
+ self.num_buckets = 0
+ self.max_distance = 0
+
+ self.layers = nn.ModuleList(
+ [
+ TransformerSentenceEncoderLayer(
+ embedding_dim=self.embedding_dim,
+ ffn_embedding_dim=args.encoder_ffn_embed_dim,
+ num_attention_heads=args.encoder_attention_heads,
+ dropout=self.dropout,
+ attention_dropout=args.attention_dropout,
+ activation_dropout=args.activation_dropout,
+ activation_fn=args.activation_fn,
+ layer_norm_first=args.layer_norm_first,
+ deep_norm=args.deep_norm,
+ has_relative_attention_bias=self.relative_position_embedding,
+ num_buckets=self.num_buckets,
+ max_distance=self.max_distance,
+ gru_rel_pos=args.gru_rel_pos,
+ encoder_layers=args.encoder_layers,
+ )
+ for i in range(args.encoder_layers)
+ ]
+ )
+ if self.relative_position_embedding:
+ for i in range(1, args.encoder_layers):
+ del self.layers[i].self_attn.relative_attention_bias
+ self.layers[i].self_attn.relative_attention_bias = self.layers[0].self_attn.relative_attention_bias
+
+ self.layer_norm_first = args.layer_norm_first
+ self.layer_norm = LayerNorm(self.embedding_dim)
+ self.layerdrop = args.encoder_layerdrop
+
+ self.apply(init_bert_params)
+
+ if args.deep_norm:
+ deep_norm_beta = math.pow(8 * args.encoder_layers, -1 / 4)
+ for i in range(args.encoder_layers):
+ nn.init.xavier_normal_(self.layers[i].self_attn.k_proj.weight, gain=1)
+ nn.init.xavier_normal_(self.layers[i].self_attn.v_proj.weight, gain=deep_norm_beta)
+ nn.init.xavier_normal_(self.layers[i].self_attn.q_proj.weight, gain=1)
+ nn.init.xavier_normal_(self.layers[i].self_attn.out_proj.weight, gain=deep_norm_beta)
+ nn.init.xavier_normal_(self.layers[i].fc1.weight, gain=deep_norm_beta)
+ nn.init.xavier_normal_(self.layers[i].fc2.weight, gain=deep_norm_beta)
+
+ self.layer_wise_gradient_decay_ratio = getattr(args, "layer_wise_gradient_decay_ratio", 1)
+
+ def forward(self, x, padding_mask=None, layer=None):
+ x, layer_results = self.extract_features(x, padding_mask, layer)
+
+ if self.layer_norm_first and layer is None:
+ x = self.layer_norm(x)
+
+ return x, layer_results
+
+ def extract_features(self, x, padding_mask=None, tgt_layer=None):
+
+ if padding_mask is not None:
+ x[padding_mask] = 0
+ x_conv = self.pos_conv(x.transpose(1, 2))
+ x_conv = x_conv.transpose(1, 2)
+ x = x + x_conv
+
+ if not self.layer_norm_first:
+ x = self.layer_norm(x)
+
+ x = F.dropout(x, p=self.dropout, training=self.training)
+
+ # B x T x C -> T x B x C
+ x = x.transpose(0, 1)
+
+ layer_results = []
+ z = None
+ if tgt_layer is not None:
+ layer_results.append((x, z))
+ r = None
+ pos_bias = None
+ for i, layer in enumerate(self.layers):
+ if self.layer_wise_gradient_decay_ratio != 1.0:
+ x = GradMultiply.apply(x, self.layer_wise_gradient_decay_ratio)
+ dropout_probability = np.random.random()
+ if not self.training or (dropout_probability > self.layerdrop):
+ x, z, pos_bias = layer(x, self_attn_padding_mask=padding_mask, need_weights=False, pos_bias=pos_bias)
+ if tgt_layer is not None:
+ layer_results.append((x, z))
+ if i == tgt_layer:
+ r = x
+ break
+
+ if r is not None:
+ x = r
+
+ # T x B x C -> B x T x C
+ x = x.transpose(0, 1)
+
+ return x, layer_results
+
+
+class TransformerSentenceEncoderLayer(nn.Module):
+ def __init__(
+ self,
+ embedding_dim: float = 768,
+ ffn_embedding_dim: float = 3072,
+ num_attention_heads: float = 8,
+ dropout: float = 0.1,
+ attention_dropout: float = 0.1,
+ activation_dropout: float = 0.1,
+ activation_fn: str = "relu",
+ layer_norm_first: bool = False,
+ deep_norm: bool = False,
+ has_relative_attention_bias: bool = False,
+ num_buckets: int = 0,
+ max_distance: int = 0,
+ rescale_init: bool = False,
+ gru_rel_pos: bool = False,
+ encoder_layers: int = 0,
+ ) -> None:
+
+ super().__init__()
+ self.embedding_dim = embedding_dim
+ self.dropout = dropout
+ self.activation_dropout = activation_dropout
+
+ self.activation_name = activation_fn
+ self.activation_fn = get_activation_fn(activation_fn)
+ self.self_attn = MultiheadAttention(
+ self.embedding_dim,
+ num_attention_heads,
+ dropout=attention_dropout,
+ self_attention=True,
+ has_relative_attention_bias=has_relative_attention_bias,
+ num_buckets=num_buckets,
+ max_distance=max_distance,
+ rescale_init=rescale_init,
+ gru_rel_pos=gru_rel_pos,
+ )
+
+ self.dropout1 = nn.Dropout(dropout)
+ self.dropout2 = nn.Dropout(self.activation_dropout)
+ self.dropout3 = nn.Dropout(dropout)
+
+ self.layer_norm_first = layer_norm_first
+
+ self.self_attn_layer_norm = LayerNorm(self.embedding_dim)
+
+ if self.activation_name == "glu":
+ self.fc1 = GLU_Linear(self.embedding_dim, ffn_embedding_dim, "swish")
+ else:
+ self.fc1 = nn.Linear(self.embedding_dim, ffn_embedding_dim)
+ self.fc2 = nn.Linear(ffn_embedding_dim, self.embedding_dim)
+
+ self.final_layer_norm = LayerNorm(self.embedding_dim)
+
+ self.deep_norm = deep_norm
+ if self.deep_norm:
+ self.deep_norm_alpha = math.pow(2 * encoder_layers, 1 / 4)
+ else:
+ self.deep_norm_alpha = 1
+
+ def forward(
+ self,
+ x: torch.Tensor,
+ self_attn_mask: torch.Tensor = None,
+ self_attn_padding_mask: torch.Tensor = None,
+ need_weights: bool = False,
+ pos_bias=None
+ ):
+ residual = x
+
+ if self.layer_norm_first:
+ x = self.self_attn_layer_norm(x)
+ x, attn, pos_bias = self.self_attn(
+ query=x,
+ key=x,
+ value=x,
+ key_padding_mask=self_attn_padding_mask,
+ need_weights=False,
+ attn_mask=self_attn_mask,
+ position_bias=pos_bias
+ )
+ x = self.dropout1(x)
+ x = residual + x
+
+ residual = x
+ x = self.final_layer_norm(x)
+ if self.activation_name == "glu":
+ x = self.fc1(x)
+ else:
+ x = self.activation_fn(self.fc1(x))
+ x = self.dropout2(x)
+ x = self.fc2(x)
+ x = self.dropout3(x)
+ x = residual + x
+ else:
+ x, attn, pos_bias = self.self_attn(
+ query=x,
+ key=x,
+ value=x,
+ key_padding_mask=self_attn_padding_mask,
+ need_weights=need_weights,
+ attn_mask=self_attn_mask,
+ position_bias=pos_bias
+ )
+
+ x = self.dropout1(x)
+ x = residual * self.deep_norm_alpha + x
+
+ x = self.self_attn_layer_norm(x)
+
+ residual = x
+ if self.activation_name == "glu":
+ x = self.fc1(x)
+ else:
+ x = self.activation_fn(self.fc1(x))
+ x = self.dropout2(x)
+ x = self.fc2(x)
+ x = self.dropout3(x)
+ x = residual * self.deep_norm_alpha + x
+ x = self.final_layer_norm(x)
+
+ return x, attn, pos_bias
+
+
+class MultiheadAttention(nn.Module):
+ """Multi-headed attention.
+
+ See "Attention Is All You Need" for more details.
+ """
+
+ def __init__(
+ self,
+ embed_dim,
+ num_heads,
+ kdim=None,
+ vdim=None,
+ dropout=0.0,
+ bias=True,
+ add_bias_kv=False,
+ add_zero_attn=False,
+ self_attention=False,
+ encoder_decoder_attention=False,
+ q_noise=0.0,
+ qn_block_size=8,
+ has_relative_attention_bias=False,
+ num_buckets=32,
+ max_distance=128,
+ gru_rel_pos=False,
+ rescale_init=False,
+ ):
+ super().__init__()
+ self.embed_dim = embed_dim
+ self.kdim = kdim if kdim is not None else embed_dim
+ self.vdim = vdim if vdim is not None else embed_dim
+ self.qkv_same_dim = self.kdim == embed_dim and self.vdim == embed_dim
+
+ self.num_heads = num_heads
+ self.dropout_module = nn.Dropout(dropout)
+
+ self.has_relative_attention_bias = has_relative_attention_bias
+ self.num_buckets = num_buckets
+ self.max_distance = max_distance
+ if self.has_relative_attention_bias:
+ self.relative_attention_bias = nn.Embedding(num_buckets, num_heads)
+
+ self.head_dim = embed_dim // num_heads
+ self.q_head_dim = self.head_dim
+ self.k_head_dim = self.head_dim
+ assert (
+ self.head_dim * num_heads == self.embed_dim
+ ), "embed_dim must be divisible by num_heads"
+ self.scaling = self.head_dim ** -0.5
+
+ self.self_attention = self_attention
+ self.encoder_decoder_attention = encoder_decoder_attention
+
+ assert not self.self_attention or self.qkv_same_dim, (
+ "Self-attention requires query, key and " "value to be of the same size"
+ )
+
+ k_bias = True
+ if rescale_init:
+ k_bias = False
+
+ k_embed_dim = embed_dim
+ q_embed_dim = embed_dim
+
+ self.k_proj = quant_noise(
+ nn.Linear(self.kdim, k_embed_dim, bias=k_bias), q_noise, qn_block_size
+ )
+ self.v_proj = quant_noise(
+ nn.Linear(self.vdim, embed_dim, bias=bias), q_noise, qn_block_size
+ )
+ self.q_proj = quant_noise(
+ nn.Linear(embed_dim, q_embed_dim, bias=bias), q_noise, qn_block_size
+ )
+
+ self.out_proj = quant_noise(
+ nn.Linear(embed_dim, embed_dim, bias=bias), q_noise, qn_block_size
+ )
+
+ if add_bias_kv:
+ self.bias_k = Parameter(torch.Tensor(1, 1, embed_dim))
+ self.bias_v = Parameter(torch.Tensor(1, 1, embed_dim))
+ else:
+ self.bias_k = self.bias_v = None
+
+ self.add_zero_attn = add_zero_attn
+
+ self.gru_rel_pos = gru_rel_pos
+ if self.gru_rel_pos:
+ self.grep_linear = nn.Linear(self.q_head_dim, 8)
+ self.grep_a = nn.Parameter(torch.ones(1, num_heads, 1, 1))
+
+ self.reset_parameters()
+
+ def reset_parameters(self):
+ if self.qkv_same_dim:
+ # Empirically observed the convergence to be much better with
+ # the scaled initialization
+ nn.init.xavier_uniform_(self.k_proj.weight, gain=1 / math.sqrt(2))
+ nn.init.xavier_uniform_(self.v_proj.weight, gain=1 / math.sqrt(2))
+ nn.init.xavier_uniform_(self.q_proj.weight, gain=1 / math.sqrt(2))
+ else:
+ nn.init.xavier_uniform_(self.k_proj.weight)
+ nn.init.xavier_uniform_(self.v_proj.weight)
+ nn.init.xavier_uniform_(self.q_proj.weight)
+
+ nn.init.xavier_uniform_(self.out_proj.weight)
+ if self.out_proj.bias is not None:
+ nn.init.constant_(self.out_proj.bias, 0.0)
+ if self.bias_k is not None:
+ nn.init.xavier_normal_(self.bias_k)
+ if self.bias_v is not None:
+ nn.init.xavier_normal_(self.bias_v)
+ if self.has_relative_attention_bias:
+ nn.init.xavier_normal_(self.relative_attention_bias.weight)
+
+ def _relative_positions_bucket(self, relative_positions, bidirectional=True):
+ num_buckets = self.num_buckets
+ max_distance = self.max_distance
+ relative_buckets = 0
+
+ if bidirectional:
+ num_buckets = num_buckets // 2
+ relative_buckets += (relative_positions > 0).to(torch.long) * num_buckets
+ relative_positions = torch.abs(relative_positions)
+ else:
+ relative_positions = -torch.min(relative_positions, torch.zeros_like(relative_positions))
+
+ max_exact = num_buckets // 2
+ is_small = relative_positions < max_exact
+
+ relative_postion_if_large = max_exact + (
+ torch.log(relative_positions.float() / max_exact)
+ / math.log(max_distance / max_exact)
+ * (num_buckets - max_exact)
+ ).to(torch.long)
+ relative_postion_if_large = torch.min(
+ relative_postion_if_large, torch.full_like(relative_postion_if_large, num_buckets - 1)
+ )
+
+ relative_buckets += torch.where(is_small, relative_positions, relative_postion_if_large)
+ return relative_buckets
+
+ def compute_bias(self, query_length, key_length):
+ context_position = torch.arange(query_length, dtype=torch.long)[:, None]
+ memory_position = torch.arange(key_length, dtype=torch.long)[None, :]
+ relative_position = memory_position - context_position
+ relative_position_bucket = self._relative_positions_bucket(
+ relative_position,
+ bidirectional=True
+ )
+ relative_position_bucket = relative_position_bucket.to(self.relative_attention_bias.weight.device)
+ values = self.relative_attention_bias(relative_position_bucket)
+ values = values.permute([2, 0, 1])
+ return values
+
+ def forward(
+ self,
+ query,
+ key: Optional[Tensor],
+ value: Optional[Tensor],
+ key_padding_mask: Optional[Tensor] = None,
+ incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None,
+ need_weights: bool = True,
+ static_kv: bool = False,
+ attn_mask: Optional[Tensor] = None,
+ before_softmax: bool = False,
+ need_head_weights: bool = False,
+ position_bias: Optional[Tensor] = None
+ ) -> Tuple[Tensor, Optional[Tensor], Optional[Tensor]]:
+ """Input shape: Time x Batch x Channel
+
+ Args:
+ key_padding_mask (ByteTensor, optional): mask to exclude
+ keys that are pads, of shape `(batch, src_len)`, where
+ padding elements are indicated by 1s.
+ need_weights (bool, optional): return the attention weights,
+ averaged over heads (default: False).
+ attn_mask (ByteTensor, optional): typically used to
+ implement causal attention, where the mask prevents the
+ attention from looking forward in time (default: None).
+ before_softmax (bool, optional): return the raw attention
+ weights and values before the attention softmax.
+ need_head_weights (bool, optional): return the attention
+ weights for each head. Implies *need_weights*. Default:
+ return the average attention weights over all heads.
+ """
+ if need_head_weights:
+ need_weights = True
+
+ is_tpu = query.device.type == "xla"
+
+ tgt_len, bsz, embed_dim = query.size()
+ src_len = tgt_len
+ assert embed_dim == self.embed_dim
+ assert list(query.size()) == [tgt_len, bsz, embed_dim]
+ if key is not None:
+ src_len, key_bsz, _ = key.size()
+ if not torch.jit.is_scripting():
+ assert key_bsz == bsz
+ assert value is not None
+ assert src_len, bsz == value.shape[:2]
+
+ if self.has_relative_attention_bias and position_bias is None:
+ position_bias = self.compute_bias(tgt_len, src_len)
+ position_bias = position_bias.unsqueeze(0).repeat(bsz, 1, 1, 1).view(bsz * self.num_heads, tgt_len, src_len)
+
+ if incremental_state is not None:
+ saved_state = self._get_input_buffer(incremental_state)
+ if saved_state is not None and "prev_key" in saved_state:
+ # previous time steps are cached - no need to recompute
+ # key and value if they are static
+ if static_kv:
+ assert self.encoder_decoder_attention and not self.self_attention
+ key = value = None
+ else:
+ saved_state = None
+
+ if self.self_attention:
+ q = self.q_proj(query)
+ k = self.k_proj(query)
+ v = self.v_proj(query)
+ elif self.encoder_decoder_attention:
+ # encoder-decoder attention
+ q = self.q_proj(query)
+ if key is None:
+ assert value is None
+ k = v = None
+ else:
+ k = self.k_proj(key)
+ v = self.v_proj(key)
+
+ else:
+ assert key is not None and value is not None
+ q = self.q_proj(query)
+ k = self.k_proj(key)
+ v = self.v_proj(value)
+ q *= self.scaling
+ alpha = 32
+ q *= 1 / alpha
+
+ if self.bias_k is not None:
+ assert self.bias_v is not None
+ k = torch.cat([k, self.bias_k.repeat(1, bsz, 1)])
+ v = torch.cat([v, self.bias_v.repeat(1, bsz, 1)])
+ if attn_mask is not None:
+ attn_mask = torch.cat(
+ [attn_mask, attn_mask.new_zeros(attn_mask.size(0), 1)], dim=1
+ )
+ if key_padding_mask is not None:
+ key_padding_mask = torch.cat(
+ [
+ key_padding_mask,
+ key_padding_mask.new_zeros(key_padding_mask.size(0), 1),
+ ],
+ dim=1,
+ )
+
+ q = (
+ q.contiguous()
+ .view(tgt_len, bsz * self.num_heads, self.q_head_dim)
+ .transpose(0, 1)
+ )
+ if k is not None:
+ k = (
+ k.contiguous()
+ .view(-1, bsz * self.num_heads, self.k_head_dim)
+ .transpose(0, 1)
+ )
+ if v is not None:
+ v = (
+ v.contiguous()
+ .view(-1, bsz * self.num_heads, self.head_dim)
+ .transpose(0, 1)
+ )
+
+ if saved_state is not None:
+ # saved states are stored with shape (bsz, num_heads, seq_len, head_dim)
+ if "prev_key" in saved_state:
+ _prev_key = saved_state["prev_key"]
+ assert _prev_key is not None
+ prev_key = _prev_key.view(bsz * self.num_heads, -1, self.head_dim)
+ if static_kv:
+ k = prev_key
+ else:
+ assert k is not None
+ k = torch.cat([prev_key, k], dim=1)
+ src_len = k.size(1)
+ if "prev_value" in saved_state:
+ _prev_value = saved_state["prev_value"]
+ assert _prev_value is not None
+ prev_value = _prev_value.view(bsz * self.num_heads, -1, self.head_dim)
+ if static_kv:
+ v = prev_value
+ else:
+ assert v is not None
+ v = torch.cat([prev_value, v], dim=1)
+ prev_key_padding_mask: Optional[Tensor] = None
+ if "prev_key_padding_mask" in saved_state:
+ prev_key_padding_mask = saved_state["prev_key_padding_mask"]
+ assert k is not None and v is not None
+ key_padding_mask = MultiheadAttention._append_prev_key_padding_mask(
+ key_padding_mask=key_padding_mask,
+ prev_key_padding_mask=prev_key_padding_mask,
+ batch_size=bsz,
+ src_len=k.size(1),
+ static_kv=static_kv,
+ )
+
+ saved_state["prev_key"] = k.view(bsz, self.num_heads, -1, self.head_dim)
+ saved_state["prev_value"] = v.view(bsz, self.num_heads, -1, self.head_dim)
+ saved_state["prev_key_padding_mask"] = key_padding_mask
+ # In this branch incremental_state is never None
+ assert incremental_state is not None
+ incremental_state = self._set_input_buffer(incremental_state, saved_state)
+ assert k is not None
+ assert k.size(1) == src_len
+
+ # This is part of a workaround to get around fork/join parallelism
+ # not supporting Optional types.
+ if key_padding_mask is not None and key_padding_mask.dim() == 0:
+ key_padding_mask = None
+
+ if key_padding_mask is not None:
+ assert key_padding_mask.size(0) == bsz
+ assert key_padding_mask.size(1) == src_len
+
+ if self.add_zero_attn:
+ assert v is not None
+ src_len += 1
+ k = torch.cat([k, k.new_zeros((k.size(0), 1) + k.size()[2:])], dim=1)
+ v = torch.cat([v, v.new_zeros((v.size(0), 1) + v.size()[2:])], dim=1)
+ if attn_mask is not None:
+ attn_mask = torch.cat(
+ [attn_mask, attn_mask.new_zeros(attn_mask.size(0), 1)], dim=1
+ )
+ if key_padding_mask is not None:
+ key_padding_mask = torch.cat(
+ [
+ key_padding_mask,
+ torch.zeros(key_padding_mask.size(0), 1).type_as(
+ key_padding_mask
+ ),
+ ],
+ dim=1,
+ )
+
+ attn_weights = torch.bmm(q, k.transpose(1, 2))
+ attn_weights = (attn_weights - attn_weights.max(dim=-1, keepdim=True)[0]) * alpha
+ attn_weights = self.apply_sparse_mask(attn_weights, tgt_len, src_len, bsz)
+
+ assert list(attn_weights.size()) == [bsz * self.num_heads, tgt_len, src_len]
+
+ if attn_mask is not None:
+ attn_mask = attn_mask.unsqueeze(0)
+ attn_weights += attn_mask
+
+ if key_padding_mask is not None:
+ # don't attend to padding symbols
+ attn_weights = attn_weights.view(bsz, self.num_heads, tgt_len, src_len)
+ if not is_tpu:
+ attn_weights = attn_weights.masked_fill(
+ key_padding_mask.unsqueeze(1).unsqueeze(2).to(torch.bool),
+ float("-inf"),
+ )
+ else:
+ attn_weights = attn_weights.transpose(0, 2)
+ attn_weights = attn_weights.masked_fill(key_padding_mask, float("-inf"))
+ attn_weights = attn_weights.transpose(0, 2)
+ attn_weights = attn_weights.view(bsz * self.num_heads, tgt_len, src_len)
+
+ if before_softmax:
+ return attn_weights, v, position_bias
+
+ if position_bias is not None:
+ attn_mask_rel_pos = position_bias
+ if self.gru_rel_pos == 1:
+ query_layer = q.view(bsz, self.num_heads, tgt_len, self.q_head_dim) * alpha / self.scaling
+ _B, _H, _L, __ = query_layer.size()
+ gate_a, gate_b = torch.sigmoid(self.grep_linear(query_layer).view(
+ _B, _H, _L, 2, 4).sum(-1, keepdim=False)).chunk(2, dim=-1)
+ gate_a_1 = gate_a * (gate_b * self.grep_a - 1.0) + 2.0
+ attn_mask_rel_pos = gate_a_1.view(bsz * self.num_heads, tgt_len, 1) * position_bias
+
+ attn_mask_rel_pos = attn_mask_rel_pos.view(attn_weights.size())
+
+ attn_weights = attn_weights + attn_mask_rel_pos
+
+ attn_weights_float = F.softmax(
+ attn_weights, dim=-1
+ )
+ attn_weights = attn_weights_float.type_as(attn_weights)
+ attn_probs = self.dropout_module(attn_weights)
+
+ assert v is not None
+ attn = torch.bmm(attn_probs, v)
+ assert list(attn.size()) == [bsz * self.num_heads, tgt_len, self.head_dim]
+ attn = attn.transpose(0, 1).contiguous().view(tgt_len, bsz, embed_dim)
+ attn = self.out_proj(attn)
+ attn_weights: Optional[Tensor] = None
+ if need_weights:
+ attn_weights = attn_weights_float.view(
+ bsz, self.num_heads, tgt_len, src_len
+ ).transpose(1, 0)
+ if not need_head_weights:
+ # average attention weights over heads
+ attn_weights = attn_weights.mean(dim=0)
+
+ return attn, attn_weights, position_bias
+
+ @staticmethod
+ def _append_prev_key_padding_mask(
+ key_padding_mask: Optional[Tensor],
+ prev_key_padding_mask: Optional[Tensor],
+ batch_size: int,
+ src_len: int,
+ static_kv: bool,
+ ) -> Optional[Tensor]:
+ # saved key padding masks have shape (bsz, seq_len)
+ if prev_key_padding_mask is not None and static_kv:
+ new_key_padding_mask = prev_key_padding_mask
+ elif prev_key_padding_mask is not None and key_padding_mask is not None:
+ new_key_padding_mask = torch.cat(
+ [prev_key_padding_mask.float(), key_padding_mask.float()], dim=1
+ )
+ # During incremental decoding, as the padding token enters and
+ # leaves the frame, there will be a time when prev or current
+ # is None
+ elif prev_key_padding_mask is not None:
+ if src_len > prev_key_padding_mask.size(1):
+ filler = torch.zeros(
+ (batch_size, src_len - prev_key_padding_mask.size(1)),
+ device=prev_key_padding_mask.device,
+ )
+ new_key_padding_mask = torch.cat(
+ [prev_key_padding_mask.float(), filler.float()], dim=1
+ )
+ else:
+ new_key_padding_mask = prev_key_padding_mask.float()
+ elif key_padding_mask is not None:
+ if src_len > key_padding_mask.size(1):
+ filler = torch.zeros(
+ (batch_size, src_len - key_padding_mask.size(1)),
+ device=key_padding_mask.device,
+ )
+ new_key_padding_mask = torch.cat(
+ [filler.float(), key_padding_mask.float()], dim=1
+ )
+ else:
+ new_key_padding_mask = key_padding_mask.float()
+ else:
+ new_key_padding_mask = prev_key_padding_mask
+ return new_key_padding_mask
+
+ def _get_input_buffer(
+ self, incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]]
+ ) -> Dict[str, Optional[Tensor]]:
+ result = self.get_incremental_state(incremental_state, "attn_state")
+ if result is not None:
+ return result
+ else:
+ empty_result: Dict[str, Optional[Tensor]] = {}
+ return empty_result
+
+ def _set_input_buffer(
+ self,
+ incremental_state: Dict[str, Dict[str, Optional[Tensor]]],
+ buffer: Dict[str, Optional[Tensor]],
+ ):
+ return self.set_incremental_state(incremental_state, "attn_state", buffer)
+
+ def apply_sparse_mask(self, attn_weights, tgt_len: int, src_len: int, bsz: int):
+ return attn_weights
+
+
+def init_bert_params(module):
+ """
+ Initialize the weights specific to the BERT Model.
+ This overrides the default initializations depending on the specified arguments.
+ 1. If normal_init_linear_weights is set then weights of linear
+ layer will be initialized using the normal distribution and
+ bais will be set to the specified value.
+ 2. If normal_init_embed_weights is set then weights of embedding
+ layer will be initialized using the normal distribution.
+ 3. If normal_init_proj_weights is set then weights of
+ in_project_weight for MultiHeadAttention initialized using
+ the normal distribution (to be validated).
+ """
+
+ def normal_(data):
+ # with FSDP, module params will be on CUDA, so we cast them back to CPU
+ # so that the RNG is consistent with and without FSDP
+ data.copy_(
+ data.cpu().normal_(mean=0.0, std=0.02).to(data.device)
+ )
+
+ if isinstance(module, nn.Linear):
+ normal_(module.weight.data)
+ if module.bias is not None:
+ module.bias.data.zero_()
+ if isinstance(module, nn.Embedding):
+ normal_(module.weight.data)
+ if module.padding_idx is not None:
+ module.weight.data[module.padding_idx].zero_()
+ if isinstance(module, MultiheadAttention):
+ normal_(module.q_proj.weight.data)
+ normal_(module.k_proj.weight.data)
+ normal_(module.v_proj.weight.data)
\ No newline at end of file
diff --git a/vlmeval/vlm/ola/ola/model/speech_encoder/beats/kaldi.py b/vlmeval/vlm/ola/ola/model/speech_encoder/beats/kaldi.py
new file mode 100644
index 0000000000000000000000000000000000000000..f97fa85308e785af571bfdc912d6f12bb092e10e
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/model/speech_encoder/beats/kaldi.py
@@ -0,0 +1,813 @@
+import math
+from typing import Tuple
+
+import torch
+# import torchaudio
+from torch import Tensor
+
+__all__ = [
+ "get_mel_banks",
+ "inverse_mel_scale",
+ "inverse_mel_scale_scalar",
+ "mel_scale",
+ "mel_scale_scalar",
+ "spectrogram",
+ "fbank",
+ "mfcc",
+ "vtln_warp_freq",
+ "vtln_warp_mel_freq",
+]
+
+# numeric_limits::epsilon() 1.1920928955078125e-07
+EPSILON = torch.tensor(torch.finfo(torch.float).eps)
+# 1 milliseconds = 0.001 seconds
+MILLISECONDS_TO_SECONDS = 0.001
+
+# window types
+HAMMING = "hamming"
+HANNING = "hanning"
+POVEY = "povey"
+RECTANGULAR = "rectangular"
+BLACKMAN = "blackman"
+WINDOWS = [HAMMING, HANNING, POVEY, RECTANGULAR, BLACKMAN]
+
+
+def _get_epsilon(device, dtype):
+ return EPSILON.to(device=device, dtype=dtype)
+
+
+def _next_power_of_2(x: int) -> int:
+ r"""Returns the smallest power of 2 that is greater than x"""
+ return 1 if x == 0 else 2 ** (x - 1).bit_length()
+
+
+def _get_strided(waveform: Tensor, window_size: int, window_shift: int, snip_edges: bool) -> Tensor:
+ r"""Given a waveform (1D tensor of size ``num_samples``), it returns a 2D tensor (m, ``window_size``)
+ representing how the window is shifted along the waveform. Each row is a frame.
+
+ Args:
+ waveform (Tensor): Tensor of size ``num_samples``
+ window_size (int): Frame length
+ window_shift (int): Frame shift
+ snip_edges (bool): If True, end effects will be handled by outputting only frames that completely fit
+ in the file, and the number of frames depends on the frame_length. If False, the number of frames
+ depends only on the frame_shift, and we reflect the data at the ends.
+
+ Returns:
+ Tensor: 2D tensor of size (m, ``window_size``) where each row is a frame
+ """
+ assert waveform.dim() == 1
+ num_samples = waveform.size(0)
+ strides = (window_shift * waveform.stride(0), waveform.stride(0))
+
+ if snip_edges:
+ if num_samples < window_size:
+ return torch.empty((0, 0), dtype=waveform.dtype, device=waveform.device)
+ else:
+ m = 1 + (num_samples - window_size) // window_shift
+ else:
+ reversed_waveform = torch.flip(waveform, [0])
+ m = (num_samples + (window_shift // 2)) // window_shift
+ pad = window_size // 2 - window_shift // 2
+ pad_right = reversed_waveform
+ if pad > 0:
+ # torch.nn.functional.pad returns [2,1,0,1,2] for 'reflect'
+ # but we want [2, 1, 0, 0, 1, 2]
+ pad_left = reversed_waveform[-pad:]
+ waveform = torch.cat((pad_left, waveform, pad_right), dim=0)
+ else:
+ # pad is negative so we want to trim the waveform at the front
+ waveform = torch.cat((waveform[-pad:], pad_right), dim=0)
+
+ sizes = (m, window_size)
+ return waveform.as_strided(sizes, strides)
+
+
+def _feature_window_function(
+ window_type: str,
+ window_size: int,
+ blackman_coeff: float,
+ device: torch.device,
+ dtype: int,
+) -> Tensor:
+ r"""Returns a window function with the given type and size"""
+ if window_type == HANNING:
+ return torch.hann_window(window_size, periodic=False, device=device, dtype=dtype)
+ elif window_type == HAMMING:
+ return torch.hamming_window(window_size, periodic=False, alpha=0.54, beta=0.46, device=device, dtype=dtype)
+ elif window_type == POVEY:
+ # like hanning but goes to zero at edges
+ return torch.hann_window(window_size, periodic=False, device=device, dtype=dtype).pow(0.85)
+ elif window_type == RECTANGULAR:
+ return torch.ones(window_size, device=device, dtype=dtype)
+ elif window_type == BLACKMAN:
+ a = 2 * math.pi / (window_size - 1)
+ window_function = torch.arange(window_size, device=device, dtype=dtype)
+ # can't use torch.blackman_window as they use different coefficients
+ return (
+ blackman_coeff
+ - 0.5 * torch.cos(a * window_function)
+ + (0.5 - blackman_coeff) * torch.cos(2 * a * window_function)
+ ).to(device=device, dtype=dtype)
+ else:
+ raise Exception("Invalid window type " + window_type)
+
+
+def _get_log_energy(strided_input: Tensor, epsilon: Tensor, energy_floor: float) -> Tensor:
+ r"""Returns the log energy of size (m) for a strided_input (m,*)"""
+ device, dtype = strided_input.device, strided_input.dtype
+ log_energy = torch.max(strided_input.pow(2).sum(1), epsilon).log() # size (m)
+ if energy_floor == 0.0:
+ return log_energy
+ return torch.max(log_energy, torch.tensor(math.log(energy_floor), device=device, dtype=dtype))
+
+
+def _get_waveform_and_window_properties(
+ waveform: Tensor,
+ channel: int,
+ sample_frequency: float,
+ frame_shift: float,
+ frame_length: float,
+ round_to_power_of_two: bool,
+ preemphasis_coefficient: float,
+) -> Tuple[Tensor, int, int, int]:
+ r"""Gets the waveform and window properties"""
+ channel = max(channel, 0)
+ assert channel < waveform.size(0), "Invalid channel {} for size {}".format(channel, waveform.size(0))
+ waveform = waveform[channel, :] # size (n)
+ window_shift = int(sample_frequency * frame_shift * MILLISECONDS_TO_SECONDS)
+ window_size = int(sample_frequency * frame_length * MILLISECONDS_TO_SECONDS)
+ padded_window_size = _next_power_of_2(window_size) if round_to_power_of_two else window_size
+
+ assert 2 <= window_size <= len(waveform), "choose a window size {} that is [2, {}]".format(
+ window_size, len(waveform)
+ )
+ assert 0 < window_shift, "`window_shift` must be greater than 0"
+ assert padded_window_size % 2 == 0, (
+ "the padded `window_size` must be divisible by two." " use `round_to_power_of_two` or change `frame_length`"
+ )
+ assert 0.0 <= preemphasis_coefficient <= 1.0, "`preemphasis_coefficient` must be between [0,1]"
+ assert sample_frequency > 0, "`sample_frequency` must be greater than zero"
+ return waveform, window_shift, window_size, padded_window_size
+
+
+def _get_window(
+ waveform: Tensor,
+ padded_window_size: int,
+ window_size: int,
+ window_shift: int,
+ window_type: str,
+ blackman_coeff: float,
+ snip_edges: bool,
+ raw_energy: bool,
+ energy_floor: float,
+ dither: float,
+ remove_dc_offset: bool,
+ preemphasis_coefficient: float,
+) -> Tuple[Tensor, Tensor]:
+ r"""Gets a window and its log energy
+
+ Returns:
+ (Tensor, Tensor): strided_input of size (m, ``padded_window_size``) and signal_log_energy of size (m)
+ """
+ device, dtype = waveform.device, waveform.dtype
+ epsilon = _get_epsilon(device, dtype)
+
+ # size (m, window_size)
+ strided_input = _get_strided(waveform, window_size, window_shift, snip_edges)
+
+ if dither != 0.0:
+ rand_gauss = torch.randn(strided_input.shape, device=device, dtype=dtype)
+ strided_input = strided_input + rand_gauss * dither
+
+ if remove_dc_offset:
+ # Subtract each row/frame by its mean
+ row_means = torch.mean(strided_input, dim=1).unsqueeze(1) # size (m, 1)
+ strided_input = strided_input - row_means
+
+ if raw_energy:
+ # Compute the log energy of each row/frame before applying preemphasis and
+ # window function
+ signal_log_energy = _get_log_energy(strided_input, epsilon, energy_floor) # size (m)
+
+ if preemphasis_coefficient != 0.0:
+ # strided_input[i,j] -= preemphasis_coefficient * strided_input[i, max(0, j-1)] for all i,j
+ offset_strided_input = torch.nn.functional.pad(strided_input.unsqueeze(0), (1, 0), mode="replicate").squeeze(
+ 0
+ ) # size (m, window_size + 1)
+ strided_input = strided_input - preemphasis_coefficient * offset_strided_input[:, :-1]
+
+ # Apply window_function to each row/frame
+ window_function = _feature_window_function(window_type, window_size, blackman_coeff, device, dtype).unsqueeze(
+ 0
+ ) # size (1, window_size)
+ strided_input = strided_input * window_function # size (m, window_size)
+
+ # Pad columns with zero until we reach size (m, padded_window_size)
+ if padded_window_size != window_size:
+ padding_right = padded_window_size - window_size
+ strided_input = torch.nn.functional.pad(
+ strided_input.unsqueeze(0), (0, padding_right), mode="constant", value=0
+ ).squeeze(0)
+
+ # Compute energy after window function (not the raw one)
+ if not raw_energy:
+ signal_log_energy = _get_log_energy(strided_input, epsilon, energy_floor) # size (m)
+
+ return strided_input, signal_log_energy
+
+
+def _subtract_column_mean(tensor: Tensor, subtract_mean: bool) -> Tensor:
+ # subtracts the column mean of the tensor size (m, n) if subtract_mean=True
+ # it returns size (m, n)
+ if subtract_mean:
+ col_means = torch.mean(tensor, dim=0).unsqueeze(0)
+ tensor = tensor - col_means
+ return tensor
+
+
+def spectrogram(
+ waveform: Tensor,
+ blackman_coeff: float = 0.42,
+ channel: int = -1,
+ dither: float = 0.0,
+ energy_floor: float = 1.0,
+ frame_length: float = 25.0,
+ frame_shift: float = 10.0,
+ min_duration: float = 0.0,
+ preemphasis_coefficient: float = 0.97,
+ raw_energy: bool = True,
+ remove_dc_offset: bool = True,
+ round_to_power_of_two: bool = True,
+ sample_frequency: float = 16000.0,
+ snip_edges: bool = True,
+ subtract_mean: bool = False,
+ window_type: str = POVEY,
+) -> Tensor:
+ r"""Create a spectrogram from a raw audio signal. This matches the input/output of Kaldi's
+ compute-spectrogram-feats.
+
+ Args:
+ waveform (Tensor): Tensor of audio of size (c, n) where c is in the range [0,2)
+ blackman_coeff (float, optional): Constant coefficient for generalized Blackman window. (Default: ``0.42``)
+ channel (int, optional): Channel to extract (-1 -> expect mono, 0 -> left, 1 -> right) (Default: ``-1``)
+ dither (float, optional): Dithering constant (0.0 means no dither). If you turn this off, you should set
+ the energy_floor option, e.g. to 1.0 or 0.1 (Default: ``0.0``)
+ energy_floor (float, optional): Floor on energy (absolute, not relative) in Spectrogram computation. Caution:
+ this floor is applied to the zeroth component, representing the total signal energy. The floor on the
+ individual spectrogram elements is fixed at std::numeric_limits::epsilon(). (Default: ``1.0``)
+ frame_length (float, optional): Frame length in milliseconds (Default: ``25.0``)
+ frame_shift (float, optional): Frame shift in milliseconds (Default: ``10.0``)
+ min_duration (float, optional): Minimum duration of segments to process (in seconds). (Default: ``0.0``)
+ preemphasis_coefficient (float, optional): Coefficient for use in signal preemphasis (Default: ``0.97``)
+ raw_energy (bool, optional): If True, compute energy before preemphasis and windowing (Default: ``True``)
+ remove_dc_offset (bool, optional): Subtract mean from waveform on each frame (Default: ``True``)
+ round_to_power_of_two (bool, optional): If True, round window size to power of two by zero-padding input
+ to FFT. (Default: ``True``)
+ sample_frequency (float, optional): Waveform data sample frequency (must match the waveform file, if
+ specified there) (Default: ``16000.0``)
+ snip_edges (bool, optional): If True, end effects will be handled by outputting only frames that completely fit
+ in the file, and the number of frames depends on the frame_length. If False, the number of frames
+ depends only on the frame_shift, and we reflect the data at the ends. (Default: ``True``)
+ subtract_mean (bool, optional): Subtract mean of each feature file [CMS]; not recommended to do
+ it this way. (Default: ``False``)
+ window_type (str, optional): Type of window ('hamming'|'hanning'|'povey'|'rectangular'|'blackman')
+ (Default: ``'povey'``)
+
+ Returns:
+ Tensor: A spectrogram identical to what Kaldi would output. The shape is
+ (m, ``padded_window_size // 2 + 1``) where m is calculated in _get_strided
+ """
+ device, dtype = waveform.device, waveform.dtype
+ epsilon = _get_epsilon(device, dtype)
+
+ waveform, window_shift, window_size, padded_window_size = _get_waveform_and_window_properties(
+ waveform, channel, sample_frequency, frame_shift, frame_length, round_to_power_of_two, preemphasis_coefficient
+ )
+
+ if len(waveform) < min_duration * sample_frequency:
+ # signal is too short
+ return torch.empty(0)
+
+ strided_input, signal_log_energy = _get_window(
+ waveform,
+ padded_window_size,
+ window_size,
+ window_shift,
+ window_type,
+ blackman_coeff,
+ snip_edges,
+ raw_energy,
+ energy_floor,
+ dither,
+ remove_dc_offset,
+ preemphasis_coefficient,
+ )
+
+ # size (m, padded_window_size // 2 + 1, 2)
+ fft = torch.fft.rfft(strided_input)
+
+ # Convert the FFT into a power spectrum
+ power_spectrum = torch.max(fft.abs().pow(2.0), epsilon).log() # size (m, padded_window_size // 2 + 1)
+ power_spectrum[:, 0] = signal_log_energy
+
+ power_spectrum = _subtract_column_mean(power_spectrum, subtract_mean)
+ return power_spectrum
+
+
+def inverse_mel_scale_scalar(mel_freq: float) -> float:
+ return 700.0 * (math.exp(mel_freq / 1127.0) - 1.0)
+
+
+def inverse_mel_scale(mel_freq: Tensor) -> Tensor:
+ return 700.0 * ((mel_freq / 1127.0).exp() - 1.0)
+
+
+def mel_scale_scalar(freq: float) -> float:
+ return 1127.0 * math.log(1.0 + freq / 700.0)
+
+
+def mel_scale(freq: Tensor) -> Tensor:
+ return 1127.0 * (1.0 + freq / 700.0).log()
+
+
+def vtln_warp_freq(
+ vtln_low_cutoff: float,
+ vtln_high_cutoff: float,
+ low_freq: float,
+ high_freq: float,
+ vtln_warp_factor: float,
+ freq: Tensor,
+) -> Tensor:
+ r"""This computes a VTLN warping function that is not the same as HTK's one,
+ but has similar inputs (this function has the advantage of never producing
+ empty bins).
+
+ This function computes a warp function F(freq), defined between low_freq
+ and high_freq inclusive, with the following properties:
+ F(low_freq) == low_freq
+ F(high_freq) == high_freq
+ The function is continuous and piecewise linear with two inflection
+ points.
+ The lower inflection point (measured in terms of the unwarped
+ frequency) is at frequency l, determined as described below.
+ The higher inflection point is at a frequency h, determined as
+ described below.
+ If l <= f <= h, then F(f) = f/vtln_warp_factor.
+ If the higher inflection point (measured in terms of the unwarped
+ frequency) is at h, then max(h, F(h)) == vtln_high_cutoff.
+ Since (by the last point) F(h) == h/vtln_warp_factor, then
+ max(h, h/vtln_warp_factor) == vtln_high_cutoff, so
+ h = vtln_high_cutoff / max(1, 1/vtln_warp_factor).
+ = vtln_high_cutoff * min(1, vtln_warp_factor).
+ If the lower inflection point (measured in terms of the unwarped
+ frequency) is at l, then min(l, F(l)) == vtln_low_cutoff
+ This implies that l = vtln_low_cutoff / min(1, 1/vtln_warp_factor)
+ = vtln_low_cutoff * max(1, vtln_warp_factor)
+ Args:
+ vtln_low_cutoff (float): Lower frequency cutoffs for VTLN
+ vtln_high_cutoff (float): Upper frequency cutoffs for VTLN
+ low_freq (float): Lower frequency cutoffs in mel computation
+ high_freq (float): Upper frequency cutoffs in mel computation
+ vtln_warp_factor (float): Vtln warp factor
+ freq (Tensor): given frequency in Hz
+
+ Returns:
+ Tensor: Freq after vtln warp
+ """
+ assert vtln_low_cutoff > low_freq, "be sure to set the vtln_low option higher than low_freq"
+ assert vtln_high_cutoff < high_freq, "be sure to set the vtln_high option lower than high_freq [or negative]"
+ l = vtln_low_cutoff * max(1.0, vtln_warp_factor)
+ h = vtln_high_cutoff * min(1.0, vtln_warp_factor)
+ scale = 1.0 / vtln_warp_factor
+ Fl = scale * l # F(l)
+ Fh = scale * h # F(h)
+ assert l > low_freq and h < high_freq
+ # slope of left part of the 3-piece linear function
+ scale_left = (Fl - low_freq) / (l - low_freq)
+ # [slope of center part is just "scale"]
+
+ # slope of right part of the 3-piece linear function
+ scale_right = (high_freq - Fh) / (high_freq - h)
+
+ res = torch.empty_like(freq)
+
+ outside_low_high_freq = torch.lt(freq, low_freq) | torch.gt(freq, high_freq) # freq < low_freq || freq > high_freq
+ before_l = torch.lt(freq, l) # freq < l
+ before_h = torch.lt(freq, h) # freq < h
+ after_h = torch.ge(freq, h) # freq >= h
+
+ # order of operations matter here (since there is overlapping frequency regions)
+ res[after_h] = high_freq + scale_right * (freq[after_h] - high_freq)
+ res[before_h] = scale * freq[before_h]
+ res[before_l] = low_freq + scale_left * (freq[before_l] - low_freq)
+ res[outside_low_high_freq] = freq[outside_low_high_freq]
+
+ return res
+
+
+def vtln_warp_mel_freq(
+ vtln_low_cutoff: float,
+ vtln_high_cutoff: float,
+ low_freq,
+ high_freq: float,
+ vtln_warp_factor: float,
+ mel_freq: Tensor,
+) -> Tensor:
+ r"""
+ Args:
+ vtln_low_cutoff (float): Lower frequency cutoffs for VTLN
+ vtln_high_cutoff (float): Upper frequency cutoffs for VTLN
+ low_freq (float): Lower frequency cutoffs in mel computation
+ high_freq (float): Upper frequency cutoffs in mel computation
+ vtln_warp_factor (float): Vtln warp factor
+ mel_freq (Tensor): Given frequency in Mel
+
+ Returns:
+ Tensor: ``mel_freq`` after vtln warp
+ """
+ return mel_scale(
+ vtln_warp_freq(
+ vtln_low_cutoff, vtln_high_cutoff, low_freq, high_freq, vtln_warp_factor, inverse_mel_scale(mel_freq)
+ )
+ )
+
+
+def get_mel_banks(
+ num_bins: int,
+ window_length_padded: int,
+ sample_freq: float,
+ low_freq: float,
+ high_freq: float,
+ vtln_low: float,
+ vtln_high: float,
+ vtln_warp_factor: float,
+) -> Tuple[Tensor, Tensor]:
+ """
+ Returns:
+ (Tensor, Tensor): The tuple consists of ``bins`` (which is
+ melbank of size (``num_bins``, ``num_fft_bins``)) and ``center_freqs`` (which is
+ center frequencies of bins of size (``num_bins``)).
+ """
+ assert num_bins > 3, "Must have at least 3 mel bins"
+ assert window_length_padded % 2 == 0
+ num_fft_bins = window_length_padded / 2
+ nyquist = 0.5 * sample_freq
+
+ if high_freq <= 0.0:
+ high_freq += nyquist
+
+ assert (
+ (0.0 <= low_freq < nyquist) and (0.0 < high_freq <= nyquist) and (low_freq < high_freq)
+ ), "Bad values in options: low-freq {} and high-freq {} vs. nyquist {}".format(low_freq, high_freq, nyquist)
+
+ # fft-bin width [think of it as Nyquist-freq / half-window-length]
+ fft_bin_width = sample_freq / window_length_padded
+ mel_low_freq = mel_scale_scalar(low_freq)
+ mel_high_freq = mel_scale_scalar(high_freq)
+
+ # divide by num_bins+1 in next line because of end-effects where the bins
+ # spread out to the sides.
+ mel_freq_delta = (mel_high_freq - mel_low_freq) / (num_bins + 1)
+
+ if vtln_high < 0.0:
+ vtln_high += nyquist
+
+ assert vtln_warp_factor == 1.0 or (
+ (low_freq < vtln_low < high_freq) and (0.0 < vtln_high < high_freq) and (vtln_low < vtln_high)
+ ), "Bad values in options: vtln-low {} and vtln-high {}, versus " "low-freq {} and high-freq {}".format(
+ vtln_low, vtln_high, low_freq, high_freq
+ )
+
+ bin = torch.arange(num_bins).unsqueeze(1)
+ left_mel = mel_low_freq + bin * mel_freq_delta # size(num_bins, 1)
+ center_mel = mel_low_freq + (bin + 1.0) * mel_freq_delta # size(num_bins, 1)
+ right_mel = mel_low_freq + (bin + 2.0) * mel_freq_delta # size(num_bins, 1)
+
+ if vtln_warp_factor != 1.0:
+ left_mel = vtln_warp_mel_freq(vtln_low, vtln_high, low_freq, high_freq, vtln_warp_factor, left_mel)
+ center_mel = vtln_warp_mel_freq(vtln_low, vtln_high, low_freq, high_freq, vtln_warp_factor, center_mel)
+ right_mel = vtln_warp_mel_freq(vtln_low, vtln_high, low_freq, high_freq, vtln_warp_factor, right_mel)
+
+ center_freqs = inverse_mel_scale(center_mel) # size (num_bins)
+ # size(1, num_fft_bins)
+ mel = mel_scale(fft_bin_width * torch.arange(num_fft_bins)).unsqueeze(0)
+
+ # size (num_bins, num_fft_bins)
+ up_slope = (mel - left_mel) / (center_mel - left_mel)
+ down_slope = (right_mel - mel) / (right_mel - center_mel)
+
+ if vtln_warp_factor == 1.0:
+ # left_mel < center_mel < right_mel so we can min the two slopes and clamp negative values
+ bins = torch.max(torch.zeros(1), torch.min(up_slope, down_slope))
+ else:
+ # warping can move the order of left_mel, center_mel, right_mel anywhere
+ bins = torch.zeros_like(up_slope)
+ up_idx = torch.gt(mel, left_mel) & torch.le(mel, center_mel) # left_mel < mel <= center_mel
+ down_idx = torch.gt(mel, center_mel) & torch.lt(mel, right_mel) # center_mel < mel < right_mel
+ bins[up_idx] = up_slope[up_idx]
+ bins[down_idx] = down_slope[down_idx]
+
+ return bins, center_freqs
+
+
+def fbank(
+ waveform: Tensor,
+ blackman_coeff: float = 0.42,
+ channel: int = -1,
+ dither: float = 0.0,
+ energy_floor: float = 1.0,
+ frame_length: float = 25.0,
+ frame_shift: float = 10.0,
+ high_freq: float = 0.0,
+ htk_compat: bool = False,
+ low_freq: float = 20.0,
+ min_duration: float = 0.0,
+ num_mel_bins: int = 23,
+ preemphasis_coefficient: float = 0.97,
+ raw_energy: bool = True,
+ remove_dc_offset: bool = True,
+ round_to_power_of_two: bool = True,
+ sample_frequency: float = 16000.0,
+ snip_edges: bool = True,
+ subtract_mean: bool = False,
+ use_energy: bool = False,
+ use_log_fbank: bool = True,
+ use_power: bool = True,
+ vtln_high: float = -500.0,
+ vtln_low: float = 100.0,
+ vtln_warp: float = 1.0,
+ window_type: str = POVEY,
+) -> Tensor:
+ r"""Create a fbank from a raw audio signal. This matches the input/output of Kaldi's
+ compute-fbank-feats.
+
+ Args:
+ waveform (Tensor): Tensor of audio of size (c, n) where c is in the range [0,2)
+ blackman_coeff (float, optional): Constant coefficient for generalized Blackman window. (Default: ``0.42``)
+ channel (int, optional): Channel to extract (-1 -> expect mono, 0 -> left, 1 -> right) (Default: ``-1``)
+ dither (float, optional): Dithering constant (0.0 means no dither). If you turn this off, you should set
+ the energy_floor option, e.g. to 1.0 or 0.1 (Default: ``0.0``)
+ energy_floor (float, optional): Floor on energy (absolute, not relative) in Spectrogram computation. Caution:
+ this floor is applied to the zeroth component, representing the total signal energy. The floor on the
+ individual spectrogram elements is fixed at std::numeric_limits::epsilon(). (Default: ``1.0``)
+ frame_length (float, optional): Frame length in milliseconds (Default: ``25.0``)
+ frame_shift (float, optional): Frame shift in milliseconds (Default: ``10.0``)
+ high_freq (float, optional): High cutoff frequency for mel bins (if <= 0, offset from Nyquist)
+ (Default: ``0.0``)
+ htk_compat (bool, optional): If true, put energy last. Warning: not sufficient to get HTK compatible features
+ (need to change other parameters). (Default: ``False``)
+ low_freq (float, optional): Low cutoff frequency for mel bins (Default: ``20.0``)
+ min_duration (float, optional): Minimum duration of segments to process (in seconds). (Default: ``0.0``)
+ num_mel_bins (int, optional): Number of triangular mel-frequency bins (Default: ``23``)
+ preemphasis_coefficient (float, optional): Coefficient for use in signal preemphasis (Default: ``0.97``)
+ raw_energy (bool, optional): If True, compute energy before preemphasis and windowing (Default: ``True``)
+ remove_dc_offset (bool, optional): Subtract mean from waveform on each frame (Default: ``True``)
+ round_to_power_of_two (bool, optional): If True, round window size to power of two by zero-padding input
+ to FFT. (Default: ``True``)
+ sample_frequency (float, optional): Waveform data sample frequency (must match the waveform file, if
+ specified there) (Default: ``16000.0``)
+ snip_edges (bool, optional): If True, end effects will be handled by outputting only frames that completely fit
+ in the file, and the number of frames depends on the frame_length. If False, the number of frames
+ depends only on the frame_shift, and we reflect the data at the ends. (Default: ``True``)
+ subtract_mean (bool, optional): Subtract mean of each feature file [CMS]; not recommended to do
+ it this way. (Default: ``False``)
+ use_energy (bool, optional): Add an extra dimension with energy to the FBANK output. (Default: ``False``)
+ use_log_fbank (bool, optional):If true, produce log-filterbank, else produce linear. (Default: ``True``)
+ use_power (bool, optional): If true, use power, else use magnitude. (Default: ``True``)
+ vtln_high (float, optional): High inflection point in piecewise linear VTLN warping function (if
+ negative, offset from high-mel-freq (Default: ``-500.0``)
+ vtln_low (float, optional): Low inflection point in piecewise linear VTLN warping function (Default: ``100.0``)
+ vtln_warp (float, optional): Vtln warp factor (only applicable if vtln_map not specified) (Default: ``1.0``)
+ window_type (str, optional): Type of window ('hamming'|'hanning'|'povey'|'rectangular'|'blackman')
+ (Default: ``'povey'``)
+
+ Returns:
+ Tensor: A fbank identical to what Kaldi would output. The shape is (m, ``num_mel_bins + use_energy``)
+ where m is calculated in _get_strided
+ """
+ device, dtype = waveform.device, waveform.dtype
+
+ waveform, window_shift, window_size, padded_window_size = _get_waveform_and_window_properties(
+ waveform, channel, sample_frequency, frame_shift, frame_length, round_to_power_of_two, preemphasis_coefficient
+ )
+
+ if len(waveform) < min_duration * sample_frequency:
+ # signal is too short
+ return torch.empty(0, device=device, dtype=dtype)
+
+ # strided_input, size (m, padded_window_size) and signal_log_energy, size (m)
+ strided_input, signal_log_energy = _get_window(
+ waveform,
+ padded_window_size,
+ window_size,
+ window_shift,
+ window_type,
+ blackman_coeff,
+ snip_edges,
+ raw_energy,
+ energy_floor,
+ dither,
+ remove_dc_offset,
+ preemphasis_coefficient,
+ )
+
+ # size (m, padded_window_size // 2 + 1)
+ spectrum = torch.fft.rfft(strided_input).abs()
+ if use_power:
+ spectrum = spectrum.pow(2.0)
+
+ # size (num_mel_bins, padded_window_size // 2)
+ mel_energies, _ = get_mel_banks(
+ num_mel_bins, padded_window_size, sample_frequency, low_freq, high_freq, vtln_low, vtln_high, vtln_warp
+ )
+ mel_energies = mel_energies.to(device=device, dtype=dtype)
+
+ # pad right column with zeros and add dimension, size (num_mel_bins, padded_window_size // 2 + 1)
+ mel_energies = torch.nn.functional.pad(mel_energies, (0, 1), mode="constant", value=0)
+
+ # sum with mel fiterbanks over the power spectrum, size (m, num_mel_bins)
+ mel_energies = torch.mm(spectrum, mel_energies.T)
+ if use_log_fbank:
+ # avoid log of zero (which should be prevented anyway by dithering)
+ mel_energies = torch.max(mel_energies, _get_epsilon(device, dtype)).log()
+
+ # if use_energy then add it as the last column for htk_compat == true else first column
+ if use_energy:
+ signal_log_energy = signal_log_energy.unsqueeze(1) # size (m, 1)
+ # returns size (m, num_mel_bins + 1)
+ if htk_compat:
+ mel_energies = torch.cat((mel_energies, signal_log_energy), dim=1)
+ else:
+ mel_energies = torch.cat((signal_log_energy, mel_energies), dim=1)
+
+ mel_energies = _subtract_column_mean(mel_energies, subtract_mean)
+ return mel_energies
+
+
+def _get_dct_matrix(num_ceps: int, num_mel_bins: int) -> Tensor:
+ # returns a dct matrix of size (num_mel_bins, num_ceps)
+ # size (num_mel_bins, num_mel_bins)
+ dct_matrix = torchaudio.functional.create_dct(num_mel_bins, num_mel_bins, "ortho")
+ # kaldi expects the first cepstral to be weighted sum of factor sqrt(1/num_mel_bins)
+ # this would be the first column in the dct_matrix for torchaudio as it expects a
+ # right multiply (which would be the first column of the kaldi's dct_matrix as kaldi
+ # expects a left multiply e.g. dct_matrix * vector).
+ dct_matrix[:, 0] = math.sqrt(1 / float(num_mel_bins))
+ dct_matrix = dct_matrix[:, :num_ceps]
+ return dct_matrix
+
+
+def _get_lifter_coeffs(num_ceps: int, cepstral_lifter: float) -> Tensor:
+ # returns size (num_ceps)
+ # Compute liftering coefficients (scaling on cepstral coeffs)
+ # coeffs are numbered slightly differently from HTK: the zeroth index is C0, which is not affected.
+ i = torch.arange(num_ceps)
+ return 1.0 + 0.5 * cepstral_lifter * torch.sin(math.pi * i / cepstral_lifter)
+
+
+def mfcc(
+ waveform: Tensor,
+ blackman_coeff: float = 0.42,
+ cepstral_lifter: float = 22.0,
+ channel: int = -1,
+ dither: float = 0.0,
+ energy_floor: float = 1.0,
+ frame_length: float = 25.0,
+ frame_shift: float = 10.0,
+ high_freq: float = 0.0,
+ htk_compat: bool = False,
+ low_freq: float = 20.0,
+ num_ceps: int = 13,
+ min_duration: float = 0.0,
+ num_mel_bins: int = 23,
+ preemphasis_coefficient: float = 0.97,
+ raw_energy: bool = True,
+ remove_dc_offset: bool = True,
+ round_to_power_of_two: bool = True,
+ sample_frequency: float = 16000.0,
+ snip_edges: bool = True,
+ subtract_mean: bool = False,
+ use_energy: bool = False,
+ vtln_high: float = -500.0,
+ vtln_low: float = 100.0,
+ vtln_warp: float = 1.0,
+ window_type: str = POVEY,
+) -> Tensor:
+ r"""Create a mfcc from a raw audio signal. This matches the input/output of Kaldi's
+ compute-mfcc-feats.
+
+ Args:
+ waveform (Tensor): Tensor of audio of size (c, n) where c is in the range [0,2)
+ blackman_coeff (float, optional): Constant coefficient for generalized Blackman window. (Default: ``0.42``)
+ cepstral_lifter (float, optional): Constant that controls scaling of MFCCs (Default: ``22.0``)
+ channel (int, optional): Channel to extract (-1 -> expect mono, 0 -> left, 1 -> right) (Default: ``-1``)
+ dither (float, optional): Dithering constant (0.0 means no dither). If you turn this off, you should set
+ the energy_floor option, e.g. to 1.0 or 0.1 (Default: ``0.0``)
+ energy_floor (float, optional): Floor on energy (absolute, not relative) in Spectrogram computation. Caution:
+ this floor is applied to the zeroth component, representing the total signal energy. The floor on the
+ individual spectrogram elements is fixed at std::numeric_limits::epsilon(). (Default: ``1.0``)
+ frame_length (float, optional): Frame length in milliseconds (Default: ``25.0``)
+ frame_shift (float, optional): Frame shift in milliseconds (Default: ``10.0``)
+ high_freq (float, optional): High cutoff frequency for mel bins (if <= 0, offset from Nyquist)
+ (Default: ``0.0``)
+ htk_compat (bool, optional): If true, put energy last. Warning: not sufficient to get HTK compatible
+ features (need to change other parameters). (Default: ``False``)
+ low_freq (float, optional): Low cutoff frequency for mel bins (Default: ``20.0``)
+ num_ceps (int, optional): Number of cepstra in MFCC computation (including C0) (Default: ``13``)
+ min_duration (float, optional): Minimum duration of segments to process (in seconds). (Default: ``0.0``)
+ num_mel_bins (int, optional): Number of triangular mel-frequency bins (Default: ``23``)
+ preemphasis_coefficient (float, optional): Coefficient for use in signal preemphasis (Default: ``0.97``)
+ raw_energy (bool, optional): If True, compute energy before preemphasis and windowing (Default: ``True``)
+ remove_dc_offset (bool, optional): Subtract mean from waveform on each frame (Default: ``True``)
+ round_to_power_of_two (bool, optional): If True, round window size to power of two by zero-padding input
+ to FFT. (Default: ``True``)
+ sample_frequency (float, optional): Waveform data sample frequency (must match the waveform file, if
+ specified there) (Default: ``16000.0``)
+ snip_edges (bool, optional): If True, end effects will be handled by outputting only frames that completely fit
+ in the file, and the number of frames depends on the frame_length. If False, the number of frames
+ depends only on the frame_shift, and we reflect the data at the ends. (Default: ``True``)
+ subtract_mean (bool, optional): Subtract mean of each feature file [CMS]; not recommended to do
+ it this way. (Default: ``False``)
+ use_energy (bool, optional): Add an extra dimension with energy to the FBANK output. (Default: ``False``)
+ vtln_high (float, optional): High inflection point in piecewise linear VTLN warping function (if
+ negative, offset from high-mel-freq (Default: ``-500.0``)
+ vtln_low (float, optional): Low inflection point in piecewise linear VTLN warping function (Default: ``100.0``)
+ vtln_warp (float, optional): Vtln warp factor (only applicable if vtln_map not specified) (Default: ``1.0``)
+ window_type (str, optional): Type of window ('hamming'|'hanning'|'povey'|'rectangular'|'blackman')
+ (Default: ``"povey"``)
+
+ Returns:
+ Tensor: A mfcc identical to what Kaldi would output. The shape is (m, ``num_ceps``)
+ where m is calculated in _get_strided
+ """
+ assert num_ceps <= num_mel_bins, "num_ceps cannot be larger than num_mel_bins: %d vs %d" % (num_ceps, num_mel_bins)
+
+ device, dtype = waveform.device, waveform.dtype
+
+ # The mel_energies should not be squared (use_power=True), not have mean subtracted
+ # (subtract_mean=False), and use log (use_log_fbank=True).
+ # size (m, num_mel_bins + use_energy)
+ feature = fbank(
+ waveform=waveform,
+ blackman_coeff=blackman_coeff,
+ channel=channel,
+ dither=dither,
+ energy_floor=energy_floor,
+ frame_length=frame_length,
+ frame_shift=frame_shift,
+ high_freq=high_freq,
+ htk_compat=htk_compat,
+ low_freq=low_freq,
+ min_duration=min_duration,
+ num_mel_bins=num_mel_bins,
+ preemphasis_coefficient=preemphasis_coefficient,
+ raw_energy=raw_energy,
+ remove_dc_offset=remove_dc_offset,
+ round_to_power_of_two=round_to_power_of_two,
+ sample_frequency=sample_frequency,
+ snip_edges=snip_edges,
+ subtract_mean=False,
+ use_energy=use_energy,
+ use_log_fbank=True,
+ use_power=True,
+ vtln_high=vtln_high,
+ vtln_low=vtln_low,
+ vtln_warp=vtln_warp,
+ window_type=window_type,
+ )
+
+ if use_energy:
+ # size (m)
+ signal_log_energy = feature[:, num_mel_bins if htk_compat else 0]
+ # offset is 0 if htk_compat==True else 1
+ mel_offset = int(not htk_compat)
+ feature = feature[:, mel_offset : (num_mel_bins + mel_offset)]
+
+ # size (num_mel_bins, num_ceps)
+ dct_matrix = _get_dct_matrix(num_ceps, num_mel_bins).to(dtype=dtype, device=device)
+
+ # size (m, num_ceps)
+ feature = feature.matmul(dct_matrix)
+
+ if cepstral_lifter != 0.0:
+ # size (1, num_ceps)
+ lifter_coeffs = _get_lifter_coeffs(num_ceps, cepstral_lifter).unsqueeze(0)
+ feature *= lifter_coeffs.to(device=device, dtype=dtype)
+
+ # if use_energy then replace the last column for htk_compat == true else first column
+ if use_energy:
+ feature[:, 0] = signal_log_energy
+
+ if htk_compat:
+ energy = feature[:, 0].unsqueeze(1) # size (m, 1)
+ feature = feature[:, 1:] # size (m, num_ceps - 1)
+ if not use_energy:
+ # scale on C0 (actually removing a scale we previously added that's
+ # part of one common definition of the cosine transform.)
+ energy *= math.sqrt(2)
+
+ feature = torch.cat((feature, energy), dim=1)
+
+ feature = _subtract_column_mean(feature, subtract_mean)
+ return feature
diff --git a/vlmeval/vlm/ola/ola/model/speech_encoder/beats/modules.py b/vlmeval/vlm/ola/ola/model/speech_encoder/beats/modules.py
new file mode 100644
index 0000000000000000000000000000000000000000..18e2d2066b93139acc9427f0edcdd96b12769f25
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/model/speech_encoder/beats/modules.py
@@ -0,0 +1,218 @@
+# --------------------------------------------------------
+# BEATs: Audio Pre-Training with Acoustic Tokenizers (https://arxiv.org/abs/2212.09058)
+# Github source: https://github.com/microsoft/unilm/tree/master/beats
+# Copyright (c) 2022 Microsoft
+# Licensed under The MIT License [see LICENSE for details]
+# Based on fairseq code bases
+# https://github.com/pytorch/fairseq
+# --------------------------------------------------------
+
+import math
+import warnings
+import torch
+from torch import Tensor, nn
+import torch.nn.functional as F
+
+
+class GradMultiply(torch.autograd.Function):
+ @staticmethod
+ def forward(ctx, x, scale):
+ ctx.scale = scale
+ res = x.new(x)
+ return res
+
+ @staticmethod
+ def backward(ctx, grad):
+ return grad * ctx.scale, None
+
+
+class SamePad(nn.Module):
+ def __init__(self, kernel_size, causal=False):
+ super().__init__()
+ if causal:
+ self.remove = kernel_size - 1
+ else:
+ self.remove = 1 if kernel_size % 2 == 0 else 0
+
+ def forward(self, x):
+ if self.remove > 0:
+ x = x[:, :, : -self.remove]
+ return x
+
+
+class Swish(nn.Module):
+ def __init__(self):
+ super(Swish, self).__init__()
+ self.act = torch.nn.Sigmoid()
+
+ def forward(self, x):
+ return x * self.act(x)
+
+
+class GLU_Linear(nn.Module):
+ def __init__(self, input_dim, output_dim, glu_type="sigmoid", bias_in_glu=True):
+ super(GLU_Linear, self).__init__()
+
+ self.glu_type = glu_type
+ self.output_dim = output_dim
+
+ if glu_type == "sigmoid":
+ self.glu_act = torch.nn.Sigmoid()
+ elif glu_type == "swish":
+ self.glu_act = Swish()
+ elif glu_type == "relu":
+ self.glu_act = torch.nn.ReLU()
+ elif glu_type == "gelu":
+ self.glu_act = torch.nn.GELU()
+
+ if bias_in_glu:
+ self.linear = nn.Linear(input_dim, output_dim * 2, True)
+ else:
+ self.linear = nn.Linear(input_dim, output_dim * 2, False)
+
+ def forward(self, x):
+ # to be consistent with GLU_Linear, we assume the input always has the #channel (#dim) in the last dimension of the tensor, so need to switch the dimension first for 1D-Conv case
+ x = self.linear(x)
+
+ if self.glu_type == "bilinear":
+ x = (x[:, :, 0:self.output_dim] * x[:, :, self.output_dim:self.output_dim * 2])
+ else:
+ x = (x[:, :, 0:self.output_dim] * self.glu_act(x[:, :, self.output_dim:self.output_dim * 2]))
+
+ return x
+
+
+def gelu_accurate(x):
+ if not hasattr(gelu_accurate, "_a"):
+ gelu_accurate._a = math.sqrt(2 / math.pi)
+ return (
+ 0.5 * x * (1 + torch.tanh(gelu_accurate._a * (x + 0.044715 * torch.pow(x, 3))))
+ )
+
+
+def gelu(x: torch.Tensor) -> torch.Tensor:
+ return torch.nn.functional.gelu(x.float()).type_as(x)
+
+
+def get_activation_fn(activation: str):
+ """Returns the activation function corresponding to `activation`"""
+
+ if activation == "relu":
+ return F.relu
+ elif activation == "gelu":
+ return gelu
+ elif activation == "gelu_fast":
+ warnings.warn(
+ "--activation-fn=gelu_fast has been renamed to gelu_accurate"
+ )
+ return gelu_accurate
+ elif activation == "gelu_accurate":
+ return gelu_accurate
+ elif activation == "tanh":
+ return torch.tanh
+ elif activation == "linear":
+ return lambda x: x
+ elif activation == "glu":
+ return lambda x: x
+ else:
+ raise RuntimeError("--activation-fn {} not supported".format(activation))
+
+
+def quant_noise(module, p, block_size):
+ """
+ Wraps modules and applies quantization noise to the weights for
+ subsequent quantization with Iterative Product Quantization as
+ described in "Training with Quantization Noise for Extreme Model Compression"
+
+ Args:
+ - module: nn.Module
+ - p: amount of Quantization Noise
+ - block_size: size of the blocks for subsequent quantization with iPQ
+
+ Remarks:
+ - Module weights must have the right sizes wrt the block size
+ - Only Linear, Embedding and Conv2d modules are supported for the moment
+ - For more detail on how to quantize by blocks with convolutional weights,
+ see "And the Bit Goes Down: Revisiting the Quantization of Neural Networks"
+ - We implement the simplest form of noise here as stated in the paper
+ which consists in randomly dropping blocks
+ """
+
+ # if no quantization noise, don't register hook
+ if p <= 0:
+ return module
+
+ # supported modules
+ assert isinstance(module, (nn.Linear, nn.Embedding, nn.Conv2d))
+
+ # test whether module.weight has the right sizes wrt block_size
+ is_conv = module.weight.ndim == 4
+
+ # 2D matrix
+ if not is_conv:
+ assert (
+ module.weight.size(1) % block_size == 0
+ ), "Input features must be a multiple of block sizes"
+
+ # 4D matrix
+ else:
+ # 1x1 convolutions
+ if module.kernel_size == (1, 1):
+ assert (
+ module.in_channels % block_size == 0
+ ), "Input channels must be a multiple of block sizes"
+ # regular convolutions
+ else:
+ k = module.kernel_size[0] * module.kernel_size[1]
+ assert k % block_size == 0, "Kernel size must be a multiple of block size"
+
+ def _forward_pre_hook(mod, input):
+ # no noise for evaluation
+ if mod.training:
+ if not is_conv:
+ # gather weight and sizes
+ weight = mod.weight
+ in_features = weight.size(1)
+ out_features = weight.size(0)
+
+ # split weight matrix into blocks and randomly drop selected blocks
+ mask = torch.zeros(
+ in_features // block_size * out_features, device=weight.device
+ )
+ mask.bernoulli_(p)
+ mask = mask.repeat_interleave(block_size, -1).view(-1, in_features)
+
+ else:
+ # gather weight and sizes
+ weight = mod.weight
+ in_channels = mod.in_channels
+ out_channels = mod.out_channels
+
+ # split weight matrix into blocks and randomly drop selected blocks
+ if mod.kernel_size == (1, 1):
+ mask = torch.zeros(
+ int(in_channels // block_size * out_channels),
+ device=weight.device,
+ )
+ mask.bernoulli_(p)
+ mask = mask.repeat_interleave(block_size, -1).view(-1, in_channels)
+ else:
+ mask = torch.zeros(
+ weight.size(0), weight.size(1), device=weight.device
+ )
+ mask.bernoulli_(p)
+ mask = (
+ mask.unsqueeze(2)
+ .unsqueeze(3)
+ .repeat(1, 1, mod.kernel_size[0], mod.kernel_size[1])
+ )
+
+ # scale weights and apply mask
+ mask = mask.to(
+ torch.bool
+ ) # x.bool() is not currently supported in TorchScript
+ s = 1 / (1 - p)
+ mod.weight.data = s * weight.masked_fill(mask, 0)
+
+ module.register_forward_pre_hook(_forward_pre_hook)
+ return module
diff --git a/vlmeval/vlm/ola/ola/model/speech_encoder/beats/quantizer.py b/vlmeval/vlm/ola/ola/model/speech_encoder/beats/quantizer.py
new file mode 100644
index 0000000000000000000000000000000000000000..704be4c357bce7ee425ea2b6737b536333a5a63c
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/model/speech_encoder/beats/quantizer.py
@@ -0,0 +1,215 @@
+# --------------------------------------------------------
+# BEATs: Audio Pre-Training with Acoustic Tokenizers (https://arxiv.org/abs/2212.09058)
+# Github source: https://github.com/microsoft/unilm/tree/master/beats
+# Copyright (c) 2022 Microsoft
+# Licensed under The MIT License [see LICENSE for details]
+# Based on VQGAN code bases
+# https://github.com/CompVis/taming-transformers
+# --------------------------------------------------------'
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.distributed as distributed
+
+try:
+ from einops import rearrange, repeat
+except ImportError:
+ pass
+
+
+def l2norm(t):
+ return F.normalize(t, p=2, dim=-1)
+
+
+def ema_inplace(moving_avg, new, decay):
+ moving_avg.data.mul_(decay).add_(new, alpha=(1 - decay))
+
+
+def sample_vectors(samples, num):
+ num_samples, device = samples.shape[0], samples.device
+
+ if num_samples >= num:
+ indices = torch.randperm(num_samples, device=device)[:num]
+ else:
+ indices = torch.randint(0, num_samples, (num,), device=device)
+
+ return samples[indices]
+
+
+def kmeans(samples, num_clusters, num_iters=10, use_cosine_sim=False):
+ dim, dtype, device = samples.shape[-1], samples.dtype, samples.device
+
+ means = sample_vectors(samples, num_clusters)
+
+ for _ in range(num_iters):
+ if use_cosine_sim:
+ dists = samples @ means.t()
+ else:
+ diffs = rearrange(samples, 'n d -> n () d') \
+ - rearrange(means, 'c d -> () c d')
+ dists = -(diffs ** 2).sum(dim=-1)
+
+ buckets = dists.max(dim=-1).indices
+ bins = torch.bincount(buckets, minlength=num_clusters)
+ zero_mask = bins == 0
+ bins_min_clamped = bins.masked_fill(zero_mask, 1)
+
+ new_means = buckets.new_zeros(num_clusters, dim, dtype=dtype)
+ new_means.scatter_add_(0, repeat(buckets, 'n -> n d', d=dim), samples)
+ new_means = new_means / bins_min_clamped[..., None]
+
+ if use_cosine_sim:
+ new_means = l2norm(new_means)
+
+ means = torch.where(zero_mask[..., None], means, new_means)
+
+ return means, bins
+
+
+class EmbeddingEMA(nn.Module):
+ def __init__(self, num_tokens, codebook_dim, decay=0.99, eps=1e-5, kmeans_init=True, codebook_init_path=''):
+ super().__init__()
+ self.num_tokens = num_tokens
+ self.codebook_dim = codebook_dim
+ self.decay = decay
+ self.eps = eps
+ if codebook_init_path == '':
+ if not kmeans_init:
+ weight = torch.randn(num_tokens, codebook_dim)
+ weight = l2norm(weight)
+ else:
+ weight = torch.zeros(num_tokens, codebook_dim)
+ self.register_buffer('initted', torch.Tensor([not kmeans_init]))
+ else:
+ print(f"load init codebook weight from {codebook_init_path}")
+ codebook_ckpt_weight = torch.load(codebook_init_path, map_location='cpu')
+ weight = codebook_ckpt_weight.clone()
+ self.register_buffer('initted', torch.Tensor([True]))
+
+ self.weight = nn.Parameter(weight, requires_grad=False)
+ self.cluster_size = nn.Parameter(torch.zeros(num_tokens), requires_grad=False)
+ self.embed_avg = nn.Parameter(weight.clone(), requires_grad=False)
+ # self.register_buffer('initted', torch.Tensor([not kmeans_init]))
+ self.update = True
+
+ @torch.jit.ignore
+ def init_embed_(self, data):
+ if self.initted:
+ return
+ print("Performing Kemans init for codebook")
+ embed, cluster_size = kmeans(data, self.num_tokens, 10, use_cosine_sim=True)
+ self.weight.data.copy_(embed)
+ self.cluster_size.data.copy_(cluster_size)
+ self.initted.data.copy_(torch.Tensor([True]))
+
+ def forward(self, embed_id):
+ return F.embedding(embed_id, self.weight)
+
+ def cluster_size_ema_update(self, new_cluster_size):
+ self.cluster_size.data.mul_(self.decay).add_(new_cluster_size, alpha=1 - self.decay)
+
+ def embed_avg_ema_update(self, new_embed_avg):
+ self.embed_avg.data.mul_(self.decay).add_(new_embed_avg, alpha=1 - self.decay)
+
+ def weight_update(self, num_tokens):
+ n = self.cluster_size.sum()
+ smoothed_cluster_size = (
+ (self.cluster_size + self.eps) / (n + num_tokens * self.eps) * n
+ )
+ # normalize embedding average with smoothed cluster size
+ embed_normalized = self.embed_avg / smoothed_cluster_size.unsqueeze(1)
+ # embed_normalized = l2norm(self.embed_avg / smoothed_cluster_size.unsqueeze(1))
+ self.weight.data.copy_(embed_normalized)
+
+
+def norm_ema_inplace(moving_avg, new, decay):
+ moving_avg.data.mul_(decay).add_(new, alpha=(1 - decay))
+ moving_avg.data.copy_(l2norm(moving_avg.data))
+
+
+class NormEMAVectorQuantizer(nn.Module):
+ def __init__(self, n_embed, embedding_dim, beta, decay=0.99, eps=1e-5,
+ statistic_code_usage=True, kmeans_init=False, codebook_init_path=''):
+ super().__init__()
+ self.codebook_dim = embedding_dim
+ self.num_tokens = n_embed
+ self.beta = beta
+ self.decay = decay
+
+ # learnable = True if orthogonal_reg_weight > 0 else False
+ self.embedding = EmbeddingEMA(self.num_tokens, self.codebook_dim, decay, eps, kmeans_init, codebook_init_path)
+
+ self.statistic_code_usage = statistic_code_usage
+ if statistic_code_usage:
+ self.register_buffer('cluster_size', torch.zeros(n_embed))
+ if distributed.is_available() and distributed.is_initialized():
+ print("ddp is enable, so use ddp_reduce to sync the statistic_code_usage for each gpu!")
+ self.all_reduce_fn = distributed.all_reduce
+ else:
+ self.all_reduce_fn = nn.Identity()
+
+ def reset_cluster_size(self, device):
+ if self.statistic_code_usage:
+ self.register_buffer('cluster_size', torch.zeros(self.num_tokens))
+ self.cluster_size = self.cluster_size.to(device)
+
+ def forward(self, z):
+ # reshape z -> (batch, height, width, channel) and flatten
+ # z, 'b c h w -> b h w c'
+ # z = rearrange(z, 'b c h w -> b h w c')
+ # z = z.transpose(1, 2)
+ z = l2norm(z)
+ z_flattened = z.reshape(-1, self.codebook_dim)
+
+ self.embedding.init_embed_(z_flattened)
+
+ d = z_flattened.pow(2).sum(dim=1, keepdim=True) + \
+ self.embedding.weight.pow(2).sum(dim=1) - 2 * \
+ torch.einsum('bd,nd->bn', z_flattened, self.embedding.weight) # 'n d -> d n'
+
+ encoding_indices = torch.argmin(d, dim=1)
+
+ z_q = self.embedding(encoding_indices).view(z.shape)
+
+ encodings = F.one_hot(encoding_indices, self.num_tokens).type(z.dtype)
+
+ if not self.training:
+ with torch.no_grad():
+ cluster_size = encodings.sum(0)
+ self.all_reduce_fn(cluster_size)
+ ema_inplace(self.cluster_size, cluster_size, self.decay)
+
+ if self.training and self.embedding.update:
+ # EMA cluster size
+
+ bins = encodings.sum(0)
+ self.all_reduce_fn(bins)
+
+ # self.embedding.cluster_size_ema_update(bins)
+ ema_inplace(self.cluster_size, bins, self.decay)
+
+ zero_mask = (bins == 0)
+ bins = bins.masked_fill(zero_mask, 1.)
+
+ embed_sum = z_flattened.t() @ encodings
+ self.all_reduce_fn(embed_sum)
+
+ embed_normalized = (embed_sum / bins.unsqueeze(0)).t()
+ embed_normalized = l2norm(embed_normalized)
+
+ embed_normalized = torch.where(zero_mask[..., None], self.embedding.weight,
+ embed_normalized)
+ norm_ema_inplace(self.embedding.weight, embed_normalized, self.decay)
+
+ # compute loss for embedding
+ loss = self.beta * F.mse_loss(z_q.detach(), z)
+
+ # preserve gradients
+ z_q = z + (z_q - z).detach()
+
+ # reshape back to match original input shape
+ # z_q, 'b h w c -> b c h w'
+ # z_q = rearrange(z_q, 'b h w c -> b c h w')
+ # z_q = z_q.transpose(1, 2)
+ return z_q, loss, encoding_indices
\ No newline at end of file
diff --git a/vlmeval/vlm/ola/ola/model/speech_encoder/builder.py b/vlmeval/vlm/ola/ola/model/speech_encoder/builder.py
new file mode 100644
index 0000000000000000000000000000000000000000..e6b1fcb068ed79c1c90f1f0866bb72326f140de9
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/model/speech_encoder/builder.py
@@ -0,0 +1,11 @@
+from .speech_encoder import WhisperWrappedEncoder, DualWrappedEncoder
+
+
+def build_speech_encoder(config):
+ speech_encoder_type = getattr(config, 'speech_encoder_type', None)
+ if "whisper" in speech_encoder_type.lower():
+ return WhisperWrappedEncoder.load(config)
+ elif "dual" in speech_encoder_type.lower():
+ return DualWrappedEncoder(config)
+
+ raise ValueError(f'Unknown speech encoder: {speech_encoder_type}')
diff --git a/vlmeval/vlm/ola/ola/model/speech_encoder/speech_encoder.py b/vlmeval/vlm/ola/ola/model/speech_encoder/speech_encoder.py
new file mode 100644
index 0000000000000000000000000000000000000000..752dea4223597caf75aa67d819b84f8a7baf21dc
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/model/speech_encoder/speech_encoder.py
@@ -0,0 +1,74 @@
+import types
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers import WhisperFeatureExtractor
+import whisper
+
+from ....ola.model.speech_encoder.beats.BEATs import BEATsConfig, BEATs
+
+class WhisperWrappedEncoder:
+
+ @classmethod
+ def load(cls, model_config):
+
+ def replace_layer_norm(module):
+ from whisper.model import LayerNorm
+ for name, child in module.named_children():
+ if isinstance(child, LayerNorm):
+ old_params = child.state_dict()
+ new_layer_norm = nn.LayerNorm(child.normalized_shape, eps=child.eps, elementwise_affine=child.elementwise_affine)
+ new_layer_norm.load_state_dict(old_params)
+ setattr(module, name, new_layer_norm)
+ else:
+ replace_layer_norm(child)
+
+ encoder = whisper.load_model(name=model_config.speech_encoder, device='cpu').encoder
+ replace_layer_norm(encoder)
+ return encoder
+
+class DualWrappedEncoder(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.whisper_model = self.load_whisper(config)
+ self.beats_model = self.load_beats(config)
+
+ def load_whisper(cls, model_config):
+
+ def replace_layer_norm(module):
+ from whisper.model import LayerNorm
+ for name, child in module.named_children():
+ if isinstance(child, LayerNorm):
+ old_params = child.state_dict()
+ new_layer_norm = nn.LayerNorm(child.normalized_shape, eps=child.eps, elementwise_affine=child.elementwise_affine)
+ new_layer_norm.load_state_dict(old_params)
+ setattr(module, name, new_layer_norm)
+ else:
+ replace_layer_norm(child)
+
+ encoder = whisper.load_model(name=model_config.speech_encoder, device='cpu').encoder
+ replace_layer_norm(encoder)
+ return encoder
+
+ def load_beats(cls, model_config):
+ beats_path = model_config.music_encoder
+ print("Loading BEATs Model")
+ beats_ckpt = torch.load(beats_path, map_location='cpu')
+ beats_cfg = BEATsConfig(beats_ckpt['cfg'])
+ beats = BEATs(beats_cfg)
+ beats.load_state_dict(beats_ckpt['model'])
+ return beats
+
+ def forward(self, x, raw_wav=None, audio_padding_mask=None):
+ with torch.no_grad():
+ self.beats_model = self.beats_model.float()
+ speech_embeds = self.whisper_model(x.half())
+ audio_embeds, _ = self.beats_model.extract_features(raw_wav.float(), padding_mask=audio_padding_mask, feature_only=True)
+ if audio_embeds.size(1) < speech_embeds.size(1):
+ audio_embeds = F.pad(audio_embeds, (0, 0, 0, speech_embeds.size(1) - audio_embeds.size(1)))
+ elif audio_embeds.size(1) > speech_embeds.size(1):
+ speech_embeds = F.pad(speech_embeds, (0, 0, 0, audio_embeds.size(1) - speech_embeds.size(1)))
+ speech_embeds = torch.cat((speech_embeds, audio_embeds), dim=-1)
+ speech_embeds = speech_embeds.to(torch.bfloat16)
+ return speech_embeds
\ No newline at end of file
diff --git a/vlmeval/vlm/ola/ola/model/speech_projector/builder.py b/vlmeval/vlm/ola/ola/model/speech_projector/builder.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c5959e229de1e43544dae3ae3a333693ba3e824
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/model/speech_projector/builder.py
@@ -0,0 +1,9 @@
+from .speech_projector import EncoderProjectorConcat
+
+
+def build_speech_projector(config):
+ projector_type = getattr(config, 'speech_projector_type', 'linear')
+ if projector_type == 'linear':
+ return EncoderProjectorConcat(config)
+
+ raise ValueError(f'Unknown projector type: {projector_type}')
diff --git a/vlmeval/vlm/ola/ola/model/speech_projector/speech_projector.py b/vlmeval/vlm/ola/ola/model/speech_projector/speech_projector.py
new file mode 100644
index 0000000000000000000000000000000000000000..1e0156065bc238807c57918aeeed48df575ff533
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/model/speech_projector/speech_projector.py
@@ -0,0 +1,47 @@
+import torch
+import torch.nn as nn
+import math
+
+class EncoderProjectorConcat(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.k = config.speech_encoder_ds_rate
+ self.encoder_dim = config.speech_encoder_hidden_size
+ self.llm_dim = config.hidden_size
+ self.linear1 = nn.Linear(self.encoder_dim * self.k, 2048)
+ self.relu = nn.ReLU()
+ self.linear2 = nn.Linear(2048, config.hidden_size)
+
+ embed_std = 1 / math.sqrt(config.hidden_size)
+ self.speech_newline = nn.Parameter(
+ torch.randn(config.hidden_size) * embed_std
+ )
+ self.speech_begin = nn.Parameter(
+ torch.randn(config.hidden_size) * embed_std
+ )
+ self.speech_end = nn.Parameter(
+ torch.randn(config.hidden_size) * embed_std
+ )
+
+ def forward(self, x):
+ batch_size, seq_len, dim = x.size()
+ num_frames_to_discard = seq_len % self.k
+ if num_frames_to_discard > 0:
+ x = x[:, :-num_frames_to_discard, :]
+ seq_len = x.size(1)
+
+ x = x.contiguous()
+ x = x.view(batch_size, seq_len // self.k, dim * self.k)
+ x = self.linear1(x)
+ x = self.relu(x)
+ x = self.linear2(x)
+ x = torch.cat([
+ x,
+ self.speech_newline.reshape(1, 1, -1).expand(batch_size, 1, -1).to(x.dtype)
+ ], dim=1)
+ begin = self.speech_begin.reshape(1, -1).to(x.dtype)
+ end = self.speech_end.reshape(1, -1).to(x.dtype)
+ x = x.flatten(0, 1)
+ x = torch.cat([begin, x, end], dim=0)
+ # x = x.flatten(0, 1)
+ return x
\ No newline at end of file
diff --git a/vlmeval/vlm/ola/ola/utils.py b/vlmeval/vlm/ola/ola/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..3e7b8bf7d3137a078565e13952cbb8c72726b6b7
--- /dev/null
+++ b/vlmeval/vlm/ola/ola/utils.py
@@ -0,0 +1,213 @@
+# Adopted from https://github.com/haotian-liu/LLaVA. Below is the original copyright:
+# Copyright 2023 Haotian Liu
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import sys
+import torch
+import logging
+import logging.handlers
+import transformers
+
+from ...ola.ola.constants import LOGDIR
+
+server_error_msg = "**NETWORK ERROR DUE TO HIGH TRAFFIC. PLEASE REGENERATE OR REFRESH THIS PAGE.**"
+moderation_msg = "YOUR INPUT VIOLATES OUR CONTENT MODERATION GUIDELINES. PLEASE TRY AGAIN."
+
+handler = None
+
+
+def build_logger(logger_name, logger_filename):
+ global handler
+
+ formatter = logging.Formatter(
+ fmt="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+ datefmt="%Y-%m-%d %H:%M:%S",
+ )
+
+ # Set the format of root handlers
+ if not logging.getLogger().handlers:
+ logging.basicConfig(level=logging.INFO)
+ logging.getLogger().handlers[0].setFormatter(formatter)
+
+ # Redirect stdout and stderr to loggers
+ stdout_logger = logging.getLogger("stdout")
+ stdout_logger.setLevel(logging.INFO)
+ sl = StreamToLogger(stdout_logger, logging.INFO)
+ sys.stdout = sl
+
+ stderr_logger = logging.getLogger("stderr")
+ stderr_logger.setLevel(logging.ERROR)
+ sl = StreamToLogger(stderr_logger, logging.ERROR)
+ sys.stderr = sl
+
+ # Get logger
+ logger = logging.getLogger(logger_name)
+ logger.setLevel(logging.INFO)
+
+ # Add a file handler for all loggers
+ if handler is None:
+ os.makedirs(LOGDIR, exist_ok=True)
+ filename = os.path.join(LOGDIR, logger_filename)
+ handler = logging.handlers.TimedRotatingFileHandler(
+ filename, when='D', utc=True, encoding='UTF-8')
+ handler.setFormatter(formatter)
+
+ for name, item in logging.root.manager.loggerDict.items():
+ if isinstance(item, logging.Logger):
+ item.addHandler(handler)
+
+ return logger
+
+
+class StreamToLogger(object):
+ """
+ Fake file-like stream object that redirects writes to a logger instance.
+ """
+ def __init__(self, logger, log_level=logging.INFO):
+ self.terminal = sys.stdout
+ self.logger = logger
+ self.log_level = log_level
+ self.linebuf = ''
+
+ def __getattr__(self, attr):
+ return getattr(self.terminal, attr)
+
+ def write(self, buf):
+ temp_linebuf = self.linebuf + buf
+ self.linebuf = ''
+ for line in temp_linebuf.splitlines(True):
+ # From the io.TextIOWrapper docs:
+ # On output, if newline is None, any '\n' characters written
+ # are translated to the system default line separator.
+ # By default sys.stdout.write() expects '\n' newlines and then
+ # translates them so this is still cross platform.
+ if line[-1] == '\n':
+ self.logger.log(self.log_level, line.rstrip())
+ else:
+ self.linebuf += line
+
+ def flush(self):
+ if self.linebuf != '':
+ self.logger.log(self.log_level, self.linebuf.rstrip())
+ self.linebuf = ''
+
+
+def maybe_zero_3(param, ignore_status=False, name=None):
+ from deepspeed import zero
+ from deepspeed.runtime.zero.partition_parameters import ZeroParamStatus
+ if hasattr(param, "ds_id"):
+ if param.ds_status == ZeroParamStatus.NOT_AVAILABLE:
+ if not ignore_status:
+ logging.warning(f"{name}: param.ds_status != ZeroParamStatus.NOT_AVAILABLE: {param.ds_status}")
+ with zero.GatheredParameters([param]):
+ param = param.data.detach().cpu().clone()
+ else:
+ param = param.detach().cpu().clone()
+ return param
+
+
+# Borrowed from peft.utils.get_peft_model_state_dict
+def get_peft_state_maybe_zero_3(named_params, bias):
+ if bias == "none":
+ to_return = {k: t for k, t in named_params if "lora_" in k}
+ elif bias == "all":
+ to_return = {k: t for k, t in named_params if "lora_" in k or "bias" in k}
+ elif bias == "lora_only":
+ to_return = {}
+ maybe_lora_bias = {}
+ lora_bias_names = set()
+ for k, t in named_params:
+ if "lora_" in k:
+ to_return[k] = t
+ bias_name = k.split("lora_")[0] + "bias"
+ lora_bias_names.add(bias_name)
+ elif "bias" in k:
+ maybe_lora_bias[k] = t
+ for k, t in maybe_lora_bias:
+ if bias_name in lora_bias_names:
+ to_return[bias_name] = t
+ else:
+ raise NotImplementedError
+ to_return = {k: maybe_zero_3(v, ignore_status=True) for k, v in to_return.items()}
+ return to_return
+
+
+def get_peft_state_non_lora_maybe_zero_3(named_params, require_grad_only=True):
+ to_return = {k: t for k, t in named_params if "lora_" not in k}
+ if require_grad_only:
+ to_return = {k: t for k, t in to_return.items() if t.requires_grad}
+ to_return = {k: maybe_zero_3(v, ignore_status=True).cpu() for k, v in to_return.items()}
+ return to_return
+
+
+def get_speech_projector_state_maybe_zero_3(named_params, keys_to_match):
+ to_return = {k: t for k, t in named_params if any(key_match in k for key_match in keys_to_match)}
+ to_return = {k: maybe_zero_3(v, ignore_status=True).cpu() for k, v in to_return.items()}
+ return to_return
+
+def lengths_to_padding_mask(lens):
+ bsz, max_lens = lens.size(0), torch.max(lens).item()
+ mask = torch.arange(max_lens).to(lens.device).view(1, max_lens)
+ mask = mask.expand(bsz, -1) >= lens.view(bsz, 1).expand(-1, max_lens)
+ return mask
+
+
+def lengths_to_mask(lens):
+ return ~lengths_to_padding_mask(lens)
+
+
+def disable_torch_init():
+ """
+ Disable the redundant torch default initialization to accelerate model creation.
+ """
+ import torch
+ setattr(torch.nn.Linear, "reset_parameters", lambda self: None)
+ setattr(torch.nn.LayerNorm, "reset_parameters", lambda self: None)
+
+
+def get_model_name_from_path(model_path):
+ model_path = model_path.strip("/")
+ model_paths = model_path.split("/")
+ if model_paths[-1].startswith('checkpoint-'):
+ return model_paths[-2] + "_" + model_paths[-1]
+ else:
+ return model_paths[-1]
+
+
+def violates_moderation(text):
+ """
+ Check whether the text violates OpenAI moderation API.
+ """
+ url = "https://api.openai.com/v1/moderations"
+ headers = {"Content-Type": "application/json",
+ "Authorization": "Bearer " + os.environ["OPENAI_API_KEY"]}
+ text = text.replace("\n", "")
+ data = "{" + '"input": ' + f'"{text}"' + "}"
+ data = data.encode("utf-8")
+ try:
+ ret = requests.post(url, headers=headers, data=data, timeout=5)
+ flagged = ret.json()["results"][0]["flagged"]
+ except requests.exceptions.RequestException as e:
+ flagged = False
+ except KeyError as e:
+ flagged = False
+
+ return flagged
+
+
+def pretty_print_semaphore(semaphore):
+ if semaphore is None:
+ return "None"
+ return f"Semaphore(value={semaphore._value}, locked={semaphore.locked()})"
\ No newline at end of file
diff --git a/vlmeval/vlm/ola/ola_model.py b/vlmeval/vlm/ola/ola_model.py
new file mode 100644
index 0000000000000000000000000000000000000000..15c45ebfbb978ce00caf4bcc633fe5e57d0b0270
--- /dev/null
+++ b/vlmeval/vlm/ola/ola_model.py
@@ -0,0 +1,172 @@
+import torch
+from PIL import Image
+from abc import abstractproperty
+import sys
+import os.path as osp
+from ..base import BaseModel
+from ...smp import *
+from ...dataset import DATASET_TYPE
+import os
+
+from transformers import CLIPImageProcessor
+
+os.environ['LOWRES_RESIZE']="384x32"
+os.environ['HIGHRES_BASE']="0x32"
+os.environ['MAXRES']="1536"
+os.environ['MINRES']="0"
+os.environ['SIMPLE_ARCH']="1"
+os.environ['PAD2STRIDE']="1"
+os.environ['REGIONAL_POOL']='2x'
+os.environ['FORCE_NO_DOWNSAMPLE']="1"
+os.environ['LOAD_VISION_EARLY']="1"
+os.environ['SKIP_LOAD_VIT']="1"
+
+class Ola(BaseModel):
+
+ INSTALL_REQ = True
+ INTERLEAVE = True
+
+ def __init__(self,
+ model_path='liuhaotian/llava_v1.5_7b',
+ **kwargs):
+
+ from .ola.model.builder import load_pretrained_model
+ from .ola.mm_utils import get_model_name_from_path
+
+ assert osp.exists(model_path) or splitlen(model_path) == 2
+
+ model_name = get_model_name_from_path(model_path)
+
+ self.tokenizer, self.model, self.image_processor, self.context_len = load_pretrained_model(
+ model_path=model_path,
+ model_base=None,
+ use_flash_attn=True,
+ )
+
+ if self.image_processor is None:
+ self.image_processor = CLIPImageProcessor.from_pretrained("openai/clip-vit-large-patch14")
+ print('Using default image processor. ')
+
+ self._config = self.model.config
+
+
+ self.model = self.model.cuda()
+ self.conv_mode = 'v1_qwen2'
+
+ self.device = torch.device('cuda')
+
+ kwargs_default = dict(do_sample=False, temperature=0, max_new_tokens=512, top_p=None, num_beams=1, use_cache=True) # noqa E501
+ kwargs_default.update(kwargs)
+ self.kwargs = kwargs_default
+ warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ')
+
+ def use_custom_prompt(self, dataset):
+ assert dataset is not None
+ if DATASET_TYPE(dataset) == 'multi-choice':
+ return True
+ return False
+
+ def build_prompt(self, line, dataset=None):
+ assert self.use_custom_prompt(dataset)
+ assert dataset is None or isinstance(dataset, str)
+ tgt_path = self.dump_image(line, dataset)
+
+ question = line['question']
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ if hint is not None:
+ question = hint + '\n' + question
+
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ for key, item in options.items():
+ question += f'\n{key}. {item}'
+ prompt = question
+
+ if len(options):
+ prompt += '\nAnswer with the option letter from the given choices directly.'
+ else:
+ prompt += '\nAnswer the question using a single word or phrase.'
+
+ message = [dict(type='image', value=s) for s in tgt_path]
+ message.append(dict(type='text', value=prompt))
+ return message
+
+ def generate_inner(self, message, dataset=None):
+ from .ola.mm_utils import process_anyres_highres_image_genli, KeywordsStoppingCriteria
+ from .ola.constants import (
+ IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN)
+ from .ola.conversation import conv_templates, SeparatorStyle
+ from .ola.datasets.preprocess import tokenizer_image_token
+
+ # Support interleave text and image
+ conv = conv_templates[self.conv_mode].copy()
+ conv.append_message(conv.roles[0], 'PLACEHOLDER')
+ conv.append_message(conv.roles[1], None)
+ prompt = conv.get_prompt()
+
+ content, images = '', []
+ for msg in message:
+ if msg['type'] == 'text':
+ content += msg['value']
+ elif msg['type'] == 'image':
+ if 'MMVet' in msg['value'] or 'MMMU' in msg['value']:
+ os.environ['USE_HIGHRES_ONLY'] = '1'
+ if self.model.config.mm_use_im_start_end:
+ content += DEFAULT_IM_START_TOKEN + DEFAULT_IMAGE_TOKEN + DEFAULT_IM_END_TOKEN + '\n'
+ else:
+ content += DEFAULT_IMAGE_TOKEN + '\n'
+ images.append(msg['value'])
+
+ images = [Image.open(s).convert('RGB') for s in images]
+ image_sizes = [img.size for img in images]
+ # args = abstractproperty()
+ # args.image_aspect_ratio = 'pad'
+ self.image_processor.do_resize = False
+ self.image_processor.do_center_crop = False
+ image_tensor, image_highres_tensor = [], []
+ for visual in images:
+ image_tensor_, image_highres_tensor_ = process_anyres_highres_image_genli(visual, self.image_processor)
+ image_tensor.append(image_tensor_)
+ image_highres_tensor.append(image_highres_tensor_)
+ if type(image_tensor) is list:
+ image_tensor = [_image.bfloat16().to("cuda") for _image in image_tensor]
+ else:
+ image_tensor = image_tensor.bfloat16().to("cuda")
+ if type(image_highres_tensor) is list:
+ image_highres_tensor = [_image.bfloat16().to("cuda") for _image in image_highres_tensor]
+ else:
+ image_highres_tensor = image_highres_tensor.bfloat16().to("cuda")
+ prompt = prompt.replace('PLACEHOLDER', content)
+
+ input_ids = tokenizer_image_token(
+ prompt, self.tokenizer, IMAGE_TOKEN_INDEX, return_tensors='pt').unsqueeze(0).cuda()
+ stop_str = '<|im_end|>'
+ keywords = [stop_str]
+ stopping_criteria = KeywordsStoppingCriteria(keywords, self.tokenizer, input_ids)
+
+ pad_token_ids = self.tokenizer.pad_token_id if self.tokenizer.pad_token_id is not None else self.tokenizer.eos_token_id
+ attention_masks = input_ids.ne(pad_token_ids).to(self.device)
+
+ speechs = [torch.zeros(1, 3000, 128).bfloat16().to('cuda')]
+ speech_lengths = [torch.LongTensor([3000]).to('cuda')]
+ speech_wavs = [torch.zeros([1, 480000]).to('cuda')]
+ speech_chunks = [torch.LongTensor([1]).to('cuda')]
+
+ with torch.inference_mode():
+ output_ids = self.model.generate(
+ input_ids, images=image_tensor, images_highres=image_highres_tensor, image_sizes=image_sizes,
+ modalities=['image'] * len(image_tensor),
+ speech=speechs,
+ speech_lengths=speech_lengths,
+ speech_chunks=speech_chunks,
+ speech_wav=speech_wavs,
+ attention_mask=attention_masks,
+ pad_token_id=pad_token_ids,
+ stopping_criteria=[stopping_criteria], **self.kwargs)
+
+ output = self.tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0].strip()
+ print(content, output)
+ return output
diff --git a/vlmeval/vlm/omchat.py b/vlmeval/vlm/omchat.py
new file mode 100644
index 0000000000000000000000000000000000000000..c352d253e7e3ecad9d2eb38b63e5d90804c3fdf9
--- /dev/null
+++ b/vlmeval/vlm/omchat.py
@@ -0,0 +1,159 @@
+import torch
+from PIL import Image
+import re
+from transformers import AutoModel, AutoProcessor
+
+from .base import BaseModel
+from ..smp import *
+from ..dataset import DATASET_TYPE
+
+
+class OmChat(BaseModel):
+
+ INSTALL_REQ = True
+ INTERLEAVE = True
+
+ def __init__(self, model_path='omlab/omchat-v2.0-13B-single-beta_hf', **kwargs):
+
+ # Recommend to install `transformers==4.44.0`
+ assert model_path is not None
+ self.model_path = model_path
+ print(f'load from {self.model_path}')
+ model = AutoModel.from_pretrained(self.model_path, trust_remote_code=True, torch_dtype=torch.float16)
+ self.model = model.cuda().eval()
+ self.kwargs = kwargs
+ self.processor = AutoProcessor.from_pretrained(self.model_path, trust_remote_code=True)
+ torch.cuda.empty_cache()
+
+ # system prompt
+ self.default_system_prompt = 'You are a helpful assistant. Focus on accuracy and reliability in your response.'
+ self.new1_system_prompt = 'You are a helpful assistant.'
+ self.new2_system_prompt = (
+ 'Read the following question carefully, '
+ 'solve it step by step, '
+ 'and then output the final answer in the format of '
+ "'Answer: single number or single word or phrase'.\n\n"
+ )
+
+ # suffix_prompt for MCQ
+ self.mcq_suffix_prompt_en = 'Please select the correct answer from the options above. \n'
+ self.mcq_suffix_prompt_cn = '请直接回答选项字母。\n'
+ # suffix_prompt for Y/N
+ self.yorn_suffix_prompt = ' Please answer yes or no. Answer the question using a single word or phrase.'
+
+ def use_custom_prompt(self, dataset):
+ assert dataset is not None
+ if DATASET_TYPE(dataset) == 'MCQ' or DATASET_TYPE(dataset) == 'Y/N':
+ return True
+ return False
+
+ def build_prompt(self, line, dataset=None):
+ assert dataset is None or isinstance(dataset, str)
+ assert self.use_custom_prompt(dataset)
+ tgt_path = self.dump_image(line, dataset)
+
+ if isinstance(line, int):
+ line = self.data.iloc[line]
+
+ question = line['question']
+
+ if DATASET_TYPE(dataset) == 'MCQ':
+ hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+ options = {
+ cand: line[cand]
+ for cand in string.ascii_uppercase
+ if cand in line and not pd.isna(line[cand])
+ }
+ options_prompt = 'Options:\n'
+ for key, item in options.items():
+ options_prompt += f'{key}. {item}\n'
+
+ prompt = ''
+ if hint is not None:
+ prompt += f'Hint: {hint}\n'
+ prompt += f'Question: {question}\n'
+ if len(options):
+ prompt += options_prompt
+ if not dataset.startswith('MMMU_'):
+ if not cn_string(prompt):
+ prompt += self.mcq_suffix_prompt_en
+ else:
+ prompt += self.mcq_suffix_prompt_cn
+
+ elif DATASET_TYPE(dataset) == 'Y/N':
+ prompt = question + self.yorn_suffix_prompt
+
+ print(DATASET_TYPE(dataset))
+ message = []
+ if isinstance(tgt_path, list):
+ message.extend([dict(type='image', value=p) for p in tgt_path])
+ else:
+ message = [dict(type='image', value=tgt_path)]
+ message.append(dict(type='text', value=prompt))
+
+ return message
+
+ def message_to_promptimg(self, message, dataset=None):
+ if dataset is None or listinstr(['MMMU'], dataset):
+ prompt = '\n'.join([
+ re.sub(r'', '', x['value'])
+ for x in message
+ if x['type'] == 'text'
+ ])
+ image = [x['value'] for x in message if x['type'] == 'image']
+ else:
+ prompt = '\n'.join([x['value'] for x in message if x['type'] == 'text'])
+ image = [x['value'] for x in message if x['type'] == 'image']
+ return prompt, image
+
+ def generate_inner(self, message, dataset=None):
+
+ def replace_last_dot(input_string):
+ if input_string.endswith('.'):
+ return input_string[:-1]
+ else:
+ return input_string
+
+ prompt, image_path = self.message_to_promptimg(message, dataset=dataset)
+ image = [Image.open(img_path).convert('RGB') for img_path in image_path]
+
+ default_kwargs = dict(
+ max_new_tokens=1024,
+ do_sample=False,
+ temperature=0.0,
+ top_p=1)
+
+ if dataset is not None and listinstr(['MathVista_MINI'], dataset):
+ system_prompt = self.new2_system_prompt
+ elif dataset is not None and listinstr(['MMMU_DEV_VAL', 'MMStar'], dataset):
+ system_prompt = self.new1_system_prompt
+ else:
+ system_prompt = self.default_system_prompt
+ inputs = self.processor(text=prompt, system_prompt=system_prompt, images=image, return_tensors='pt').to('cuda')
+ default_kwargs.update(self.kwargs)
+
+ with torch.inference_mode():
+ output_ids = self.model.generate(
+ **inputs,
+ eos_token_id=self.model.generation_config.eos_token_id,
+ **default_kwargs
+ )
+ res = self.processor.tokenizer.decode(output_ids[0, inputs.input_ids.shape[1]:]).strip()
+ if '<|im_end|>' in res:
+ res = res.split('<|im_end|>')[0].strip()
+
+ if dataset != 'MMMU_DEV_VAL':
+ if res.startswith('Answer: '):
+ res = res[len('Answer: '):]
+
+ match = re.search(r'\nThe answer is:(.+)', res)
+ if match:
+ res = match.group(1).strip()
+
+ # for OCRBench
+ doc_match = re.search(r'(.*?)<\/doc>', res)
+ if doc_match:
+ res = doc_match.group(1).strip()
+ res = replace_last_dot(res)
+
+ return res
diff --git a/vlmeval/vlm/omnilmm.py b/vlmeval/vlm/omnilmm.py
new file mode 100644
index 0000000000000000000000000000000000000000..12971cd7795d0bd0305186582ec6f9d6e0762a43
--- /dev/null
+++ b/vlmeval/vlm/omnilmm.py
@@ -0,0 +1,183 @@
+import torch
+from PIL import Image
+from transformers import AutoTokenizer
+
+from .base import BaseModel
+from ..smp import *
+from ..dataset import DATASET_TYPE
+
+
+DEFAULT_IMAGE_TOKEN = ''
+DEFAULT_IMAGE_PATCH_TOKEN = ''
+DEFAULT_IM_START_TOKEN = '
