Add files using upload-large-folder tool

VLMEvalKit-sudoku/.gitignore

@@ -0,0 +1,212 @@
+.idea/
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+.vscode/
+.gradio/
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+environment.yml
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# Images
+images/
+
+scripts/*ttf
+.history
+cache_dir/*
+
+# Evaluation Outputs
+outputs/*
+demo.ipynb
+*json
+!vlmeval/dataset/utils/vgrpbench/configs/formating-prompt/**/*.json
+.vscode
+*.swp
+GPT4o_MINI/
+
+2weiyun*
+script.py
+Gemini*
+Claude3-5V*
+GLM4V*
+GPT4o*
+GPT4V*
+mmmu_debug
+bailingMM
+BailingMM*
+SenseChat*
+Step*
+DoubaoVL
+arch
+BlueLM*
+mmb_*
+gpt-4.1*
+Reka*
+Taiyi
+TeleMM
+apple.jpg
+assets/LOGO.png
+api_list.txt
+vlmeval/gemini_tmp.py
+run.sh
+run_g.sh
+tmp/
+InternVL*
+Qwen*
+CongRong*
+Seed1.5*
+aguvis*
+grok-*
+GLM4.5*
+SenseNova*
+
+.DS_Store

VLMEvalKit-sudoku/docs/zh-CN/cp_origin_docs.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+
+# Copy *.md files from docs/ if it doesn't have a Chinese translation
+
+for filename in $(find ../en/ -name '*.md' -printf "%P\n");
+do
+    mkdir -p $(dirname $filename)
+    cp -n ../en/$filename ./$filename
+done

VLMEvalKit-sudoku/llava/eval/eval_textvqa.py

@@ -0,0 +1,65 @@
+import os
+import argparse
+import json
+import re
+
+from llava.eval.m4c_evaluator import TextVQAAccuracyEvaluator
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--annotation-file', type=str)
+    parser.add_argument('--result-file', type=str)
+    parser.add_argument('--result-dir', type=str)
+    return parser.parse_args()
+
+
+def prompt_processor(prompt):
+    if prompt.startswith('OCR tokens: '):
+        pattern = r"Question: (.*?) Short answer:"
+        match = re.search(pattern, prompt, re.DOTALL)
+        question = match.group(1)
+    elif 'Reference OCR token: ' in prompt and len(prompt.split('\n')) == 3:
+        if prompt.startswith('Reference OCR token:'):
+            question = prompt.split('\n')[1]
+        else:
+            question = prompt.split('\n')[0]
+    elif len(prompt.split('\n')) == 2:
+        question = prompt.split('\n')[0]
+    else:
+        assert False
+
+    return question.lower()
+
+
+def eval_single(annotation_file, result_file):
+    experiment_name = os.path.splitext(os.path.basename(result_file))[0]
+    print(experiment_name)
+    annotations = json.load(open(annotation_file))['data']
+    annotations = {(annotation['image_id'], annotation['question'].lower()): annotation for annotation in annotations}
+    results = [json.loads(line) for line in open(result_file)]
+
+    pred_list = []
+    for result in results:
+        annotation = annotations[(result['question_id'], prompt_processor(result['prompt']))]
+        pred_list.append({
+            "pred_answer": result['text'],
+            "gt_answers": annotation['answers'],
+        })
+
+    evaluator = TextVQAAccuracyEvaluator()
+    print('Samples: {}\nAccuracy: {:.2f}%\n'.format(len(pred_list), 100. * evaluator.eval_pred_list(pred_list)))
+
+
+if __name__ == "__main__":
+    args = get_args()
+
+    if args.result_file is not None:
+        eval_single(args.annotation_file, args.result_file)
+
+    if args.result_dir is not None:
+        for result_file in sorted(os.listdir(args.result_dir)):
+            if not result_file.endswith('.jsonl'):
+                print(f'Skipping {result_file}')
+                continue
+            eval_single(args.annotation_file, os.path.join(args.result_dir, result_file))

VLMEvalKit-sudoku/run.py

@@ -0,0 +1,500 @@
+import json
+import os
+import subprocess
+from functools import partial
+
+
+# GET the number of GPUs on the node without importing libs like torch
+def get_gpu_list():
+    CUDA_VISIBLE_DEVICES = os.environ.get('CUDA_VISIBLE_DEVICES', '')
+    if CUDA_VISIBLE_DEVICES != '':
+        gpu_list = [int(x) for x in CUDA_VISIBLE_DEVICES.split(',')]
+        return gpu_list
+    try:
+        ps = subprocess.Popen(('nvidia-smi', '--list-gpus'), stdout=subprocess.PIPE)
+        output = subprocess.check_output(('wc', '-l'), stdin=ps.stdout)
+        return list(range(int(output)))
+    except:
+        return []
+
+
+RANK = int(os.environ.get('RANK', 0))
+WORLD_SIZE = int(os.environ.get('WORLD_SIZE', 1))
+LOCAL_WORLD_SIZE = int(os.environ.get("LOCAL_WORLD_SIZE",1))
+LOCAL_RANK = int(os.environ.get("LOCAL_RANK",1))
+
+GPU_LIST = get_gpu_list()
+if LOCAL_WORLD_SIZE > 1 and len(GPU_LIST):
+    NGPU = len(GPU_LIST)
+    assert NGPU >= LOCAL_WORLD_SIZE, "The number of processes should be less than or equal to the number of GPUs"
+    GPU_PER_PROC = NGPU // LOCAL_WORLD_SIZE
+    DEVICE_START_IDX = GPU_PER_PROC * LOCAL_RANK
+    CUDA_VISIBLE_DEVICES = [str(i) for i in GPU_LIST[DEVICE_START_IDX: DEVICE_START_IDX + GPU_PER_PROC]]
+    CUDA_VISIBLE_DEVICES = ','.join(CUDA_VISIBLE_DEVICES)
+    # Set CUDA_VISIBLE_DEVICES
+    os.environ['CUDA_VISIBLE_DEVICES'] = CUDA_VISIBLE_DEVICES
+    print(
+        f'RANK: {RANK}, LOCAL_RANK: {LOCAL_RANK}, WORLD_SIZE: {WORLD_SIZE},'
+        f'LOCAL_WORLD_SIZE: {LOCAL_WORLD_SIZE}, CUDA_VISIBLE_DEVICES: {CUDA_VISIBLE_DEVICES}'
+    )
+
+
+from vlmeval.config import supported_VLM
+from vlmeval.dataset.video_dataset_config import supported_video_datasets
+from vlmeval.dataset import build_dataset
+from vlmeval.inference import infer_data_job
+from vlmeval.inference_video import infer_data_job_video
+from vlmeval.inference_mt import infer_data_job_mt
+from vlmeval.smp import *
+from vlmeval.utils.result_transfer import MMMU_result_transfer, MMTBench_result_transfer
+
+
+# Make WORLD_SIZE invisible when build models
+def build_model_from_config(cfg, model_name, use_vllm=False):
+    import vlmeval.api
+    import vlmeval.vlm
+    ws_bak = os.environ.pop('WORLD_SIZE', None)
+
+    config = cp.deepcopy(cfg[model_name])
+    if use_vllm:
+        config['use_vllm'] = use_vllm
+    if 'class' not in config:
+        return supported_VLM[model_name](**config)
+    cls_name = config.pop('class')
+    if hasattr(vlmeval.api, cls_name):
+        model = getattr(vlmeval.api, cls_name)(**config)
+    elif hasattr(vlmeval.vlm, cls_name):
+        model = getattr(vlmeval.vlm, cls_name)(**config)
+    else:
+        raise ValueError(f'Class {cls_name} is not supported in `vlmeval.api` or `vlmeval.vlm`')
+
+    if ws_bak:
+        os.environ['WORLD_SIZE'] = ws_bak
+    return model
+
+
+def build_dataset_from_config(cfg, dataset_name):
+    import vlmeval.dataset
+    import inspect
+    config = cp.deepcopy(cfg[dataset_name])
+    if config == {}:
+        return supported_video_datasets[dataset_name]()
+    assert 'class' in config
+    cls_name = config.pop('class')
+    if hasattr(vlmeval.dataset, cls_name):
+        cls = getattr(vlmeval.dataset, cls_name)
+        sig = inspect.signature(cls.__init__)
+        valid_params = {k: v for k, v in config.items() if k in sig.parameters}
+        if cls.MODALITY == 'VIDEO':
+            if valid_params.get('fps', 0) > 0 and valid_params.get('nframe', 0) > 0:
+                raise ValueError('fps and nframe should not be set at the same time')
+            if valid_params.get('fps', 0) <= 0 and valid_params.get('nframe', 0) <= 0:
+                raise ValueError('fps and nframe should be set at least one valid value')
+        return cls(**valid_params)
+    else:
+        raise ValueError(f'Class {cls_name} is not supported in `vlmeval.dataset`')
+
+
+def parse_args():
+    help_msg = """\
+You can launch the evaluation by setting either --data and --model or --config.
+
+--data and --model:
+    Each Arg should be a list of strings, specifying the names of datasets and models.
+    To find all supported model names, please refer to the `vlmeval/config.py` of check the output of the command \
+        `vlmutil mlist all` in the terminal (you should first have vlmeval installed).
+    To find all supported dataset names, please refer to the `vlmeval/dataset/__init__.py` file. The python script \
+        to print all supported dataset names is as follows:
+        ```python
+        from vlmeval.dataset import SUPPORTED_DATASETS
+        print(SUPPORTED_DATASETS)
+        ```
+        or you can check the output of the command `vlmutil dlist all` in the terminal.
+    To find all supported video dataset default settings, please refer to the \
+        `vlmeval/dataset/video_dataset_config.py` file.
+
+--config:
+    Launch the evaluation by specifying the path to the config json file. Sample Json Content:
+    ```json
+    {
+        "model": {
+            "GPT4o_20240806_T00_HIGH": {
+                "class": "GPT4V",
+                "model": "gpt-4o-2024-08-06",
+                "temperature": 0,
+                "img_detail": "high"
+            },
+            "GPT4o_20240806_T10_Low": {
+                "class": "GPT4V",
+                "model": "gpt-4o-2024-08-06",
+                "temperature": 1.0,
+                "img_detail": "low"
+            },
+            "GPT4o_20241120": {}
+        },
+        "data": {
+            "MME-RealWorld-Lite": {
+                "class": "MMERealWorld",
+                "dataset": "MME-RealWorld-Lite"
+            },
+            "MMBench_DEV_EN_V11": {
+                "class": "ImageMCQDataset",
+                "dataset": "MMBench_DEV_EN_V11"
+            },
+            "MMBench_Video_8frame_nopack": {},
+            "Video-MME_16frame_subs": {
+                "class": "VideoMME",
+                "dataset": "Video-MME",
+                "nframe": 16,
+                "use_subtitle": true,
+            }
+        }
+    }
+    ```
+    Currently, only `model` and `data` are supported fields. The content of each field is a dictionary.
+    For `model`, the key is the name of the model, and the value is a dictionary containing the following keys:
+    - `class`: The class name of the model, which should be a class in `vlmeval.vlm` or `vlmeval.api`.
+    - Other keys are specific to the model, please refer to the corresponding class.
+    - Tip: The defined model in the `supported_VLM` of `vlmeval/config.py` can be used as a shortcut.
+    For `data`, the key is the name of the dataset (should be the same as the `dataset` field in most cases, \
+        except for video datasets), and the value is a dictionary containing the following keys:
+    - `class`: The class name of the dataset, which should be a class in `vlmeval.dataset`.
+    - `dataset`: The name of the dataset, which should be a string that is accepted by the `dataset` argument of the \
+        corresponding class.
+    - Other keys are specific to the dataset, please refer to the corresponding class.
+    - Tip: The defined dataset in the `supported_video_datasets` of `vlmeval/dataset/video_dataset_config.py` \
+        can be used as a shortcut.
+
+    The keys in the `model` and `data` fields will be used for naming the prediction files and evaluation results.
+    When launching with `--config`, args for API VLMs, such as `--retry`, `--verbose`, will be ignored.
+"""
+    parser = argparse.ArgumentParser(description=help_msg, formatter_class=argparse.RawTextHelpFormatter)
+    # Essential Args, Setting the Names of Datasets and Models
+    parser.add_argument('--data', type=str, nargs='+', help='Names of Datasets')
+    parser.add_argument('--model', type=str, nargs='+', help='Names of Models')
+    parser.add_argument('--config', type=str, help='Path to the Config Json File')
+    # Work Dir
+    parser.add_argument('--work-dir', type=str, default='./outputs', help='select the output directory')
+    # Infer + Eval or Infer Only
+    parser.add_argument('--mode', type=str, default='all', choices=['all', 'infer', 'eval'])
+    # API Kwargs, Apply to API VLMs and Judge API LLMs
+    parser.add_argument('--api-nproc', type=int, default=4, help='Parallel API calling')
+    parser.add_argument('--retry', type=int, default=None, help='retry numbers for API VLMs')
+    parser.add_argument('--judge-args', type=str, default=None, help='Judge arguments in JSON format')
+    # Explicitly Set the Judge Model
+    parser.add_argument('--judge', type=str, default=None)
+    # Logging Utils
+    parser.add_argument('--verbose', action='store_true')
+    # Configuration for Resume
+    # Ignore: will not rerun failed VLM inference
+    parser.add_argument('--ignore', action='store_true', help='Ignore failed indices. ')
+    # Reuse: will reuse the existing prediction files
+    parser.add_argument('--reuse', action='store_true')
+    # Reuse-aux: if set, when reuse is True, will also reuse the auxiliary evaluation files
+    parser.add_argument('--reuse-aux', type=int, default=True, help='reuse auxiliary evaluation files')
+    parser.add_argument(
+        '--use-vllm', action='store_true', help='use vllm to generate, the flag is only supported in Llama4 for now')
+    parser.add_argument('--use-verifier', action='store_true', help='use verifier to evaluate')
+
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    logger = get_logger('RUN')
+    args = parse_args()
+    use_config, cfg = False, None
+    if args.config is not None:
+        assert args.data is None and args.model is None, '--data and --model should not be set when using --config'
+        use_config, cfg = True, load(args.config)
+        args.model = list(cfg['model'].keys())
+        args.data = list(cfg['data'].keys())
+    else:
+        assert len(args.data), '--data should be a list of data files'
+
+    if RANK == 0:
+        if not args.reuse:
+            logger.warning('--reuse is not set, will not reuse previous (before one day) temporary files')
+        else:
+            logger.warning('--reuse is set, will reuse the latest prediction & temporary pickle files')
+
+    if 'MMEVAL_ROOT' in os.environ:
+        args.work_dir = os.environ['MMEVAL_ROOT']
+
+    if not use_config:
+        for k, v in supported_VLM.items():
+            if hasattr(v, 'keywords') and 'retry' in v.keywords and args.retry is not None:
+                v.keywords['retry'] = args.retry
+                supported_VLM[k] = v
+            if hasattr(v, 'keywords') and 'verbose' in v.keywords and args.verbose is not None:
+                v.keywords['verbose'] = args.verbose
+                supported_VLM[k] = v
+
+        # If FWD_API is set, will use class `GPT4V` for all API models in the config
+        if os.environ.get('FWD_API', None) == '1':
+            from vlmeval.config import api_models as supported_APIs
+            from vlmeval.api import GPT4V
+            for m in args.model:
+                if m in supported_APIs:
+                    kws = supported_VLM[m].keywords
+                    supported_VLM[m] = partial(GPT4V, **kws)
+                    logger.warning(f'FWD_API is set, will use class `GPT4V` for {m}')
+
+    if WORLD_SIZE > 1:
+        import torch.distributed as dist
+        dist.init_process_group(
+            backend='nccl',
+            timeout=datetime.timedelta(seconds=int(os.environ.get('DIST_TIMEOUT', 3600)))
+        )
+
+    for _, model_name in enumerate(args.model):
+        model = None
+        date, commit_id = timestr('day'), githash(digits=8)
+        eval_id = f"T{date}_G{commit_id}"
+
+        pred_root = osp.join(args.work_dir, model_name, eval_id)
+        pred_root_meta = osp.join(args.work_dir, model_name)
+        os.makedirs(pred_root_meta, exist_ok=True)
+
+        prev_pred_roots = ls(osp.join(args.work_dir, model_name), mode='dir')
+        if len(prev_pred_roots) and args.reuse:
+            prev_pred_roots.sort()
+
+        if not osp.exists(pred_root):
+            os.makedirs(pred_root, exist_ok=True)
+
+        if use_config:
+            model = build_model_from_config(cfg['model'], model_name, args.use_vllm)
+
+        for _, dataset_name in enumerate(args.data):
+            if WORLD_SIZE > 1:
+                dist.barrier()
+
+            try:
+                pred_format = get_pred_file_format()
+                result_file_base = f'{model_name}_{dataset_name}.{pred_format}'
+
+                if use_config:
+                    if WORLD_SIZE > 1:
+                        if RANK == 0:
+                            dataset = build_dataset_from_config(cfg['data'], dataset_name)
+                        dist.barrier()
+                    dataset = build_dataset_from_config(cfg['data'], dataset_name)
+                    if dataset is None:
+                        logger.error(f'Dataset {dataset_name} is not valid, will be skipped. ')
+                        continue
+                else:
+                    dataset_kwargs = {}
+                    if dataset_name in ['MMLongBench_DOC', 'DUDE', 'DUDE_MINI', 'SLIDEVQA', 'SLIDEVQA_MINI']:
+                        dataset_kwargs['model'] = model_name
+
+                    # If distributed, first build the dataset on the main process for doing preparation works
+                    if WORLD_SIZE > 1:
+                        if RANK == 0:
+                            dataset = build_dataset(dataset_name, **dataset_kwargs)
+                        dist.barrier()
+
+                    dataset = build_dataset(dataset_name, **dataset_kwargs)
+                    if dataset is None:
+                        logger.error(f'Dataset {dataset_name} is not valid, will be skipped. ')
+                        continue
+
+                # Handling Multi-Turn Dataset
+                result_file = osp.join(pred_root, result_file_base)
+                # Reuse the previous prediction file if exists
+                if RANK == 0 and len(prev_pred_roots):
+                    prepare_reuse_files(
+                        pred_root_meta=pred_root_meta, eval_id=eval_id, model_name=model_name,
+                        dataset_name=dataset_name, reuse=args.reuse, reuse_aux=args.reuse_aux
+                    )
+
+                if WORLD_SIZE > 1:
+                    dist.barrier()
+
+                if model is None:
+                    model = model_name  # which is only a name
+
+                if args.model != "eval":
+                    # Perform the Inference
+                    if dataset.MODALITY == 'VIDEO':
+                        model = infer_data_job_video(
+                            model,
+                            work_dir=pred_root,
+                            model_name=model_name,
+                            dataset=dataset,
+                            result_file_name=result_file_base,
+                            verbose=args.verbose,
+                            api_nproc=args.api_nproc,
+                            use_vllm=args.use_vllm)
+                    elif dataset.TYPE == 'MT':
+                        model = infer_data_job_mt(
+                            model,
+                            work_dir=pred_root,
+                            model_name=model_name,
+                            dataset=dataset,
+                            verbose=args.verbose,
+                            api_nproc=args.api_nproc,
+                            ignore_failed=args.ignore,
+                            use_vllm=args.use_vllm)
+                    else:
+                        model = infer_data_job(
+                            model,
+                            work_dir=pred_root,
+                            model_name=model_name,
+                            dataset=dataset,
+                            verbose=args.verbose,
+                            api_nproc=args.api_nproc,
+                            ignore_failed=args.ignore,
+                            use_vllm=args.use_vllm)
+
+                # Set the judge kwargs first before evaluation or dumping
+
+                judge_kwargs = {
+                    'nproc': args.api_nproc,
+                    'verbose': args.verbose,
+                    'retry': args.retry if args.retry is not None else 3,
+                    **(json.loads(args.judge_args) if args.judge_args else {}),
+                }
+
+                if args.retry is not None:
+                    judge_kwargs['retry'] = args.retry
+                if args.judge is not None:
+                    judge_kwargs['model'] = args.judge
+                else:
+                    print(dataset_name)
+                    if dataset.TYPE in ['MCQ', 'Y/N', 'MCQ_MMMU_Pro'] or listinstr(
+                        ['moviechat1k', 'mme-reasoning'], dataset_name.lower()
+                    ):
+                        if listinstr(['WeMath', 'MME-Reasoning'], dataset_name):
+                            judge_kwargs['model'] = 'gpt-4o-mini'
+                        elif listinstr(['VisuLogic'], dataset_name):
+                            judge_kwargs['model'] = 'exact_matching'
+                        else:
+                            judge_kwargs['model'] = 'chatgpt-0125'
+                    elif listinstr(['MMVet', 'LLaVABench', 'MMBench_Video'], dataset_name):
+                        if listinstr(['LLaVABench_KO'], dataset_name):
+                            judge_kwargs['model'] = 'gpt-4o-0806'
+                        else:
+                            judge_kwargs['model'] = 'gpt-4-turbo'
+                    elif listinstr(['VGRPBench'], dataset_name):
+                        judge_kwargs['model'] = 'gpt-4o'
+                    elif listinstr(['MathVista', 'MathVerse', 'MathVision', 'DynaMath', 'VL-RewardBench', 'LogicVista', 'MOAT', 'OCR_Reasoning'], dataset_name):  # noqa: E501
+                        judge_kwargs['model'] = 'gpt-4o-mini'
+                    elif listinstr(['OlympiadBench'], dataset_name):
+                        use_api_judger = judge_kwargs.get("olympiad_use_api_judger", False)
+                        if use_api_judger:
+                            judge_kwargs['model'] = 'gpt-4o-mini'
+                    elif listinstr(['MMLongBench', 'MMDU', 'DUDE', 'SLIDEVQA', 'MIA-Bench', 'WildVision', 'MMAlignBench', 'MM-IFEval'], dataset_name):  # noqa: E501
+                        judge_kwargs['model'] = 'gpt-4o'
+                    elif listinstr(['ChartMimic'], dataset_name):
+                        judge_kwargs['model'] = 'gpt-4o'
+                    elif listinstr(['VDC'], dataset_name):
+                        judge_kwargs['model'] = 'llama31-8b'
+                    elif listinstr(['Video_MMLU_QA', 'Video_MMLU_CAP'], dataset_name):
+                        judge_kwargs['model'] = 'qwen-72b'
+                    elif listinstr(['MMVMBench'], dataset_name):
+                        judge_kwargs['model'] = 'gpt-4o'
+                    elif listinstr(['CVQA_EN', 'CVQA_LOC'], dataset_name):
+                        judge_kwargs['model'] = 'gpt-4.1'
+                    elif listinstr(['M4Bench'], dataset_name):
+                        judge_kwargs['model'] = 'gpt-4o'
+                    elif listinstr(['AyaVisionBench'], dataset_name):
+                        judge_kwargs['model'] = 'gpt-4.1'
+
+                if args.use_verifier:
+                    judge_kwargs['use_verifier'] = True
+                if args.use_vllm:
+                    judge_kwargs['use_vllm'] = True
+
+                if RANK == 0:
+                    logger.info(judge_kwargs)
+
+                if WORLD_SIZE > 1:
+                    dist.barrier()
+
+                # Only RANK 0 handles the evaluation part
+                if RANK == 0:
+                    # Prepare Submission Files for MMMU_TEST AND MMT-Bench_ALL
+                    if dataset_name in ['MMMU_TEST']:
+                        result_json = MMMU_result_transfer(result_file)
+                        logger.info(f'Transfer MMMU_TEST result to json for official evaluation, '
+                                    f'json file saved in {result_json}')
+                        continue
+                    elif 'MMT-Bench_ALL' in dataset_name:
+                        submission_file = MMTBench_result_transfer(result_file, **judge_kwargs)
+                        logger.info(f'Extract options from prediction of MMT-Bench FULL split for official evaluation '
+                                    f'(https://eval.ai/web/challenges/challenge-page/2328/overview), '
+                                    f'submission file saved in {submission_file}')
+                        continue
+
+                    # Skip the evaluation part if only infer
+                    if args.mode == 'infer':
+                        continue
+
+                    # Skip the evaluation part if the dataset evaluation is not supported or annotations are missing
+                    if 'MLLMGuard_DS' in dataset_name:
+                        logger.info('The evaluation of MLLMGuard_DS is not supported yet. ')
+                        continue
+                    elif 'AesBench_TEST' == dataset_name:
+                        logger.info(f'The results are saved in {result_file}. '
+                                    f'Please send it to the AesBench Team via huangyipo@hotmail.com.')
+                        continue
+                    elif dataset_name in ['DocVQA_TEST', 'InfoVQA_TEST', 'Q-Bench1_TEST', 'A-Bench_TEST']:
+                        logger.info(f'{dataset_name} is a test split without ground-truth. '
+                                    'Thus only the inference part is supported for those datasets. ')
+                        continue
+                    elif dataset_name in [
+                        'MMBench_TEST_CN', 'MMBench_TEST_EN', 'MMBench', 'MMBench_CN',
+                        'MMBench_TEST_CN_V11', 'MMBench_TEST_EN_V11', 'MMBench_V11', 'MMBench_CN_V11'
+                    ] and not MMBenchOfficialServer(dataset_name):
+                        logger.error(
+                            f'Can not evaluate {dataset_name} on non-official servers, will skip the evaluation.')
+                        continue
+
+                    # Setup the proxy for the evaluation
+                    eval_proxy = os.environ.get('EVAL_PROXY', None)
+                    old_proxy = os.environ.get('HTTP_PROXY', '')
+                    if eval_proxy is not None:
+                        proxy_set(eval_proxy)
+
+                    # Perform the Evaluation
+                    eval_results = dataset.evaluate(result_file, **judge_kwargs)
+                    # Display Evaluation Results in Terminal
+                    if eval_results is not None:
+                        assert isinstance(eval_results, dict) or isinstance(eval_results, pd.DataFrame)
+                        logger.info(f'The evaluation of model {model_name} x dataset {dataset_name} has finished! ')
+                        logger.info('Evaluation Results:')
+                        if isinstance(eval_results, dict):
+                            logger.info('\n' + json.dumps(eval_results, indent=4))
+                        elif isinstance(eval_results, pd.DataFrame):
+                            if len(eval_results) < len(eval_results.columns):
+                                eval_results = eval_results.T
+                            logger.info('\n' + tabulate(eval_results))
+
+                    # Restore the proxy
+                    if eval_proxy is not None:
+                        proxy_set(old_proxy)
+
+                    # Create the symbolic links for the prediction files
+                    files = os.listdir(pred_root)
+                    files = [x for x in files if (f'{model_name}_{dataset_name}' in x or "status.json" in x)]
+                    for f in files:
+                        cwd = os.getcwd()
+                        file_addr = osp.join(cwd, pred_root, f)
+                        link_addr = osp.join(cwd, pred_root_meta, f)
+                        if osp.exists(link_addr) or osp.islink(link_addr):
+                            os.remove(link_addr)
+                        os.symlink(file_addr, link_addr)
+
+            except Exception as e:
+                logger.exception(f'Model {model_name} x Dataset {dataset_name} combination failed: {e}, '
+                                 'skipping this combination.')
+                continue
+
+    if WORLD_SIZE > 1:
+        dist.destroy_process_group()
+
+
+if __name__ == '__main__':
+    load_env()
+    main()

VLMEvalKit-sudoku/vlmeval/dataset/CGAVCounting/cg_av_counting.py

@@ -0,0 +1,405 @@
+from huggingface_hub import snapshot_download
+from ...smp import *
+from ..video_base import VideoBaseDataset
+from ..utils import build_judge, DEBUG_MESSAGE, cgbench
+from .utils import *
+from ...utils import track_progress_rich
+
+
+class CGAVCounting(VideoBaseDataset):
+
+    dataset = "CG-AV-Counting"
+
+    TYPE = "Video-Counting"
+
+    MD5 = "d1cd8486353ab85178098d443264a7d0"
+
+    SYS = ""
+
+    def __init__(
+        self,
+        dataset="CG-AV-Counting",
+        use_frame_time=False,
+        nframe=0,
+        fps=-1,
+    ):
+        super().__init__(dataset=dataset, nframe=nframe, fps=fps)
+        self.use_frame_time = use_frame_time
+        self.dataset_name = dataset
+        self.frame_tmpl_clue = 'frame-{}.jpg'
+
+    @classmethod
+    def supported_datasets(cls):
+        return ["CGAVCounting"]
+
+    def frame_paths_clue(self, video,timestamp_list):
+        frame_root = osp.join(self.frame_root, video)
+        os.makedirs(frame_root, exist_ok=True)
+        return [osp.join(frame_root, self.frame_tmpl_clue.format(i)) for i in timestamp_list]
+
+    def save_video_frames_clue(self, video,uid,timestamp_list):
+        if type(uid) is not str:
+            uid = str(uid)
+        import decord
+        frame_paths = self.frame_paths_clue(uid,timestamp_list)
+        flag = np.all([osp.exists(p) for p in frame_paths])
+        if flag:
+            frame = Image.open(frame_paths[0])
+            return frame_paths,frame.width,frame.height
+        vid_path = osp.join(self.data_root, video)
+        vid = decord.VideoReader(vid_path)
+        frames = []
+        # 获取视频的帧率
+        fps = vid.get_avg_fps()
+        lock_path = osp.splitext(vid_path)[0] + '.lock'
+        with portalocker.Lock(lock_path, 'w', timeout=30):
+            for timestamp_sec in timestamp_list:
+                # 计算视频帧对应的索引
+                frame_idx = int(timestamp_sec * fps)
+
+                # 获取对应帧
+                frame = vid[frame_idx]
+
+                # 将帧转换为PIL图像
+                img = Image.fromarray(frame.asnumpy())
+                frames.append(img)
+            for im, pth in zip(frames, frame_paths):
+                if not osp.exists(pth):
+                    im.save(pth)
+        return frame_paths,frames[0].width,frames[0].height
+
+    def format_time(self,t):
+        return f"{t:.2f}"
+
+    def get_output_filename(self,item):
+        video_id = Path(item["video"]).stem
+        start_str = self.format_time(item["query_interval"][0])
+        end_str = self.format_time(item["query_interval"][1])
+        return f"{video_id}_{start_str}_{end_str}.mp4"
+
+    def prepare_dataset(self, dataset_name="CG-AV-Counting", repo_id="CG-Bench/CG-AV-Counting"):
+
+        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", "ref_acc", "clue_acc"]
+                all_data = []
+                for task_mode in task_modes:
+                    with open(osp.join(pth, "cg-av-counting.json"), "r") as f:
+                        data_file = pd.DataFrame(json.load(f))
+
+                    data_file = data_file.assign(index=range(len(data_file)))
+                    data_file["video_uid"] = data_file["video"].replace(".mp4","")
+                    data_file["video"] = data_file["video"].apply(lambda x: f"cg_videos_720p/{x}")
+
+                    data_file["ref_video_path"] = ""
+                    data_file["ref_video_uid"] = ""
+
+                    if task_mode in ["ref_acc"]:
+                        data_file["ref_video_path"] = data_file.apply(
+                            lambda row: f"ref_videos/{self.get_output_filename(row)}", axis=1
+                        )
+                        data_file["ref_video_uid"] = data_file["ref_video_path"].apply(
+                            lambda x: x.split("/")[-1].replace(".mp4", ""))
+
+                    data_file["task_mode"] = task_mode
+
+                    if task_mode == "clue_acc":
+                        data_file["answer"] = data_file["clue"].apply(json.dumps)
+
+                    data_file = data_file[
+                        [
+                            "index",
+                            "video_uid",
+                            "video",
+                            "ref_video_path",
+                            "ref_video_uid",
+                            "question",
+                            "answer",
+                            "type",
+                            "category",
+                            "task_mode"
+                        ]
+                    ]
+
+                    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)
+            dataset_path = cache_path
+
+            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"]
+        assert task_mode in ["long_acc","clue_acc","ref_acc"]
+        if task_mode == "long_acc":
+            user_prompt = ""
+            message = []
+            video_path = line["video"]
+            if video_llm:
+                message.append(dict(type="video", value=osp.join(self.data_root, video_path)))
+            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)
+
+            user_prompt += (
+                f"Please answer the question '{line['question']}' with a number. Just output the number itself, "
+                "don't output anything else."
+            )
+            message.append(dict(type="text", value=user_prompt))
+        elif task_mode == "ref_acc":
+            user_prompt = ""
+            message = []
+            video_path = line["ref_video_path"]
+            if video_llm:
+                message.append(dict(type="video", value=osp.join(self.data_root, video_path)))
+            else:
+                image_paths, frame_indices, vid_fps = self.save_video_frames(
+                    video_path, uid=line["ref_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)
+            user_prompt += (
+                f"Please answer the question '{line['question']}' with a number. Just output the number itself, "
+                "don't output anything else."
+            )
+            message.append(dict(type="text", value=user_prompt))
+        elif task_mode == "clue_acc":
+            if line["category"] == "event":
+                user_prompt = ""
+                message = []
+                video_path = line["video"]
+                if video_llm:
+                    message.append(dict(type="video", value=osp.join(self.data_root, video_path)))
+                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)
+                    user_prompt += get_timestampes(frame_indices, vid_fps)
+
+                user_prompt += (
+                    f"Watch the video and provide your answer to the question '{line['question']}', "
+                    "including the start and end timestamps for each event."
+                    "Format your answer in JSON, enclosed in <answer> and </answer> tags. "
+                    "The output should look like this: <answer>[[\"start_time\", \"end_time\"], ...]</answer>. "
+                    "Ensure each timestamp is in seconds (e.g., 'xx.xx')."
+                )
+                message.append(dict(type="text", value=user_prompt))
+            elif line["category"] == "object":
+                user_prompt = ""
+                message = []
+                video_path = line["video"]
+                clue_timestamp_list = []
+                for clue in json.loads(line["answer"]):
+                    if clue["timestamp"] not in clue_timestamp_list:
+                        clue_timestamp_list.append(clue["timestamp"])
+                image_paths, width, height = self.save_video_frames_clue(
+                    video_path, uid=line["video_uid"], timestamp_list=clue_timestamp_list
+                )
+                message.append(
+                    dict(type="text", value=f"There are {len(image_paths)} frames in the size of {width}x{height}"))
+                for idx,im in enumerate(image_paths):
+                    message.append(dict(type="text", value=f"Frame{idx + 1}:"))
+                    message.append(dict(type="image", value=im))
+                user_prompt += (
+                    f"Answer the question '{line['question']}', "
+                    "including the bounding box for the query object in the first frame "
+                    "where it appears. For subsequent frames where the object appears, "
+                    "do not provide the bounding box again. "
+                    "Format your answer in JSON, enclosed within <answer> and </answer> tags. "
+                    "The output should look like this: "
+                    "<answer>{\"Frame1\": [[x_min, y_min, x_max, y_max]], \"Frame2\": [...],...}</answer>. "
+                    "In the output, each frame should either contain the bounding box of the object "
+                    "(if it appears for the first time in that frame) or an empty list `[]` "
+                    "(if the object does not appear or it has already been labeled in a previous frame). "
+                    "Ensure that bounding boxes are listed as [x_min, y_min, x_max, y_max]."
+                )
+                message.append(dict(type="text", value=user_prompt))
+            elif line["category"] == "attribute":
+                user_prompt = ""
+                message = []
+                video_path = line["video"]
+                clue_timestamp_list = []
+                for clue_ in json.loads(line["answer"]):
+                    for clue in clue_:
+                        if clue["timestamp"] not in clue_timestamp_list:
+                            clue_timestamp_list.append(clue["timestamp"])
+                image_paths,width,height = self.save_video_frames_clue(
+                    video_path, uid=line["video_uid"],timestamp_list=clue_timestamp_list
+                )
+                message.append(dict(
+                    type="text",
+                    value=f"There are {len(image_paths)} frames in the size of {width}x{height}"))
+                for idx,im in enumerate(image_paths):
+                    message.append(dict(type="text", value=f"Frame{idx + 1}:"))
+                    message.append(dict(type="image", value=im))
+                user_prompt += (
+                    f"Answer the question '{line['question']}', clustering the objects according to the question. "
+                    "For each unique cluster, assign a unique label and return the bounding box for each object in "
+                    "the first frame where it appears. For subsequent frames where the object appears, "
+                    "do not output anything. "
+                    "Format your answer in JSON, enclosed within <answer> and </answer> tags. "
+                    "The output should look like this: "
+                    "<answer>{\"Frame 1\": [{\"bbox\": [x_min, y_min, x_max, y_max], 'label': \"Label 1\"}], "
+                    "\"Frame 2\": [...], ...}</answer>. "
+                    "In the output, each frame should either contain the bounding box and label for the object "
+                    "(if it appears for the first time in that frame) or an empty list `[]` "
+                    "(if the object has already been labeled or does not appear in that frame). "
+                    "The label should correspond to a unique object cluster according to the question."
+                )
+                message.append(dict(type="text", value=user_prompt))
+        print(message)
+        return message
+
+    def save_video_frames(self, video, uid, num_frames=8, fps=-1):
+
+        if type(uid) is not str:
+            uid = str(uid)
+        import decord
+        vid_path = osp.join(self.data_root, video)
+        vid = decord.VideoReader(vid_path)
+        vid_fps = vid.get_avg_fps()
+        n_frames = len(vid)
+
+        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 = []
+        lock_path = osp.splitext(vid_path)[0] + '.lock'
+        with portalocker.Lock(lock_path, 'w', timeout=30):
+            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 get_file_extension(eval_file) in ['xlsx', 'json', 'tsv'], \
+            'data file should be an supported format (xlsx/json/tsv) file'
+
+        tgt_file = get_intermediate_file_path(eval_file, '_rating', 'json')
+        score_file = get_intermediate_file_path(eval_file, '_score', 'csv')
+
+        data = load(eval_file)
+
+        data_un = data[~pd.isna(data["prediction"])]
+        data_pred_na = data[pd.isna(data["prediction"])]
+
+        data_pred_na["score"] = -1
+
+        scores_df = data_un.apply(
+            lambda row: post_process(
+                response=row["prediction"],
+                right_answer=row["answer"],
+                task_mode=row["task_mode"],
+                category=row["category"]
+            ),
+            axis=1,
+            result_type='expand'
+        )
+
+        data_un = pd.concat([data_un, scores_df], 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 = rating_func(score_file)
+
+        dump(rating, tgt_file)
+
+        return rating

VLMEvalKit-sudoku/vlmeval/dataset/CGAVCounting/utils.py

@@ -0,0 +1,422 @@
+import json
+import math
+
+from ...smp import *
+import numpy as np
+import re
+import zipfile
+
+from pathlib import Path
+from tqdm import tqdm
+import signal
+
+
+def rating_func(data_path):
+    df = load(data_path)
+
+    task_mode_fields = {
+        "long_acc": ["acc", "oboa", "mae", "rmse"],
+        "ref_acc": ["acc", "oboa", "mae", "rmse"],
+        "clue_acc": ["wcs", "ifa"],
+    }
+
+    rating = {}
+
+    for task_mode, fields in task_mode_fields.items():
+        sub_df = df[df["task_mode"] == task_mode]
+        for field in fields:
+            values = sub_df[field]
+            if field == "rmse":
+                # RMSE: sqrt(mean(x^2))
+                rmse_val = np.sqrt(values.mean())
+                rating[f"{task_mode}/rmse"] = round(rmse_val, 4)
+            else:
+                rating[f"{task_mode}/{field}"] = round(values.mean(), 4)
+
+    return rating
+
+
+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 time_str_to_seconds(time_str: str) -> float:
+    time_str = time_str.strip()
+    if '.' in time_str:
+        time_main, milliseconds = time_str.split('.')
+        milliseconds = float(f"0.{milliseconds}")
+    else:
+        time_main = time_str
+        milliseconds = 0.0
+
+    parts = list(map(int, time_main.split(":")))
+
+    if len(parts) == 2:
+        minutes, seconds = parts
+        total_seconds = minutes * 60 + seconds
+    elif len(parts) == 3:
+        hours, minutes, seconds = parts
+        total_seconds = hours * 3600 + minutes * 60 + seconds
+    else:
+        raise ValueError(f"Invalid time format: {time_str}")
+
+    return total_seconds + milliseconds
+
+
+def extract_outer_json(text):
+    stack = []
+    start_idx = None
+    opening = {'{': '}', '[': ']'}
+    closing = {'}': '{', ']': '['}
+
+    for i, char in enumerate(text):
+        if char in opening:
+            if not stack:
+                start_idx = i  # 最外层起点
+            stack.append(char)
+        elif char in closing:
+            if stack and stack[-1] == closing[char]:
+                stack.pop()
+                if not stack and start_idx is not None:
+                    candidate = text[start_idx:i + 1]
+                    try:
+                        return json.dumps(json.loads(candidate))
+                    except json.JSONDecodeError:
+                        continue  # 尝试下一个 JSON 块
+    return None
+
+
+def compute_tiou(t1, t2):
+    """Temporal IoU"""
+    inter_start = max(t1[0], t2[0])
+    inter_end = min(t1[1], t2[1])
+    inter = max(0.0, inter_end - inter_start)
+    union = max(t1[1], t2[1]) - min(t1[0], t2[0])
+    return inter / union if union > 0 else 0.0
+
+
+def compute_sIoU(box1, box2):
+    """
+    Complete IoU (sIoU) between two bounding boxes.
+    Args:
+        box1 (list or np.array): [x1, y1, x2, y2] of ground truth box
+        box2 (list or np.array): [x1, y1, x2, y2] of predicted box
+
+    Returns:
+        IoU (float): The IoU score between the two boxes.
+    """
+
+    # Ensure the coordinates are ordered: [min_x, min_y, max_x, max_y]
+    box1 = np.array([min(box1[0], box1[2]), min(box1[1], box1[3]),
+                     max(box1[0], box1[2]), max(box1[1], box1[3])])
+    box2 = np.array([min(box2[0], box2[2]), min(box2[1], box2[3]),
+                     max(box2[0], box2[2]), max(box2[1], box2[3])])
+
+    # Compute the intersection area
+    inter_x1 = max(box1[0], box2[0])
+    inter_y1 = max(box1[1], box2[1])
+    inter_x2 = min(box1[2], box2[2])
+    inter_y2 = min(box1[3], box2[3])
+
+    inter_area = max(0, inter_x2 - inter_x1) * max(0, inter_y2 - inter_y1)
+
+    # Compute areas of the individual boxes
+    area1 = (box1[2] - box1[0]) * (box1[3] - box1[1])
+    area2 = (box2[2] - box2[0]) * (box2[3] - box2[1])
+
+    # Compute union area
+    union = area1 + area2 - inter_area
+    iou = inter_area / union if union > 0 else 0.0
+
+    return iou
+
+
+def greedy_matching(gt_instances, pred_instances, iou_func):
+    """Greedy matching based on maximum IoU"""
+    unmatched_gt = set(range(len(gt_instances)))
+    unmatched_pred = set(range(len(pred_instances)))
+    matches = []
+
+    while unmatched_gt and unmatched_pred:
+        max_iou = -1
+        best_match = None
+        for gt_idx in unmatched_gt:
+            for pred_idx in unmatched_pred:
+                iou = iou_func(gt_instances[gt_idx], pred_instances[pred_idx])
+                if iou > max_iou:
+                    max_iou = iou
+                    best_match = (gt_idx, pred_idx)
+
+        if best_match:
+            gt_idx, pred_idx = best_match
+            matches.append((gt_idx, pred_idx))
+            unmatched_gt.remove(gt_idx)
+            unmatched_pred.remove(pred_idx)
+
+    return matches
+
+
+def compute_cluster_pair_wcs(gt, pred, iou_type):
+    if iou_type == 'tIoU':
+        loc_sum = 0.0
+        for g in gt:
+            loc_sum += max([compute_tiou(g, p) for p in pred] or [0.0])
+        loc_acc = loc_sum / len(gt) if gt else 0.0
+        count_penalty = 1.0 - abs(len(pred) - len(gt)) / max(len(gt), 1)
+        # count_penalty = 1.0
+        return math.sqrt(loc_acc * max(0, count_penalty))
+
+    elif iou_type == 'sIoU':
+        # group by frame index
+        from collections import defaultdict
+        gt_by_f = defaultdict(list)
+        pred_by_f = defaultdict(list)
+        for f, box in gt:
+            gt_by_f[f].append(box)
+        for f, box in pred:
+            pred_by_f[f].append(box)
+
+        all_f = set(gt_by_f) | set(pred_by_f)
+        wcs = 0.0
+        for f in all_f:
+            gt_f = gt_by_f.get(f, [])
+            pred_f = pred_by_f.get(f, [])
+            matches = greedy_matching(gt_f, pred_f, compute_sIoU)
+            loc_sum = sum([compute_sIoU(gt_f[i], pred_f[j]) for i, j in matches])
+            loc_acc = loc_sum / len(gt_f) if gt_f else 0.0
+            count_penalty = 1.0 - abs(len(pred_f) - len(gt_f)) / max(len(gt_f), 1)
+            # count_penalty = 1.0
+            wcs += math.sqrt(loc_acc * max(0, count_penalty))
+        return wcs / max(len(all_f), 1)
+
+    else:
+        raise ValueError("Unsupported iou_type")
+
+
+class TimeoutException(Exception):
+    pass
+
+
+def timeout_handler(signum, frame):
+    raise TimeoutException("Function execution exceeded the time limit.")
+
+
+def compute_wcs_unlabeled(gt_clusters, pred_clusters, iou_type='tIoU',
+                          timeout=10):  # 主要是给attribute用的，但是object和event视作一个cluster也能用
+    from scipy.optimize import linear_sum_assignment
+    # Set the timeout signal handler
+    signal.signal(signal.SIGALRM, timeout_handler)
+    signal.alarm(timeout)  # Set the alarm to go off in 'timeout' seconds
+
+    try:
+        # Original function logic
+        K = len(gt_clusters)
+        M = len(pred_clusters)
+
+        # Build cost matrix (we want max score → min cost)
+        score_matrix = np.zeros((K, M))
+        for i in range(K):
+            for j in range(M):
+                score_matrix[i, j] = compute_cluster_pair_wcs(gt_clusters[i], pred_clusters[j], iou_type)
+
+        cost_matrix = -score_matrix  # maximize score → minimize cost
+
+        row_ind, col_ind = linear_sum_assignment(cost_matrix)
+
+        matched_scores = [score_matrix[i, j] for i, j in zip(row_ind, col_ind)]
+
+        # WCS = average over gt clusters (including unmatched = 0)
+        total_wcs = sum(matched_scores)
+        return total_wcs / K
+
+    except TimeoutException:
+        print(gt_clusters, pred_clusters)
+        print("Function execution exceeded the time limit.")
+        return None  # or you can return some default value to indicate timeout
+
+    finally:
+        signal.alarm(0)  # Cancel the alarm after the function completes or times out
+
+
+def post_process(response, right_answer, task_mode, category):
+    from word2number import w2n
+    if task_mode in ["long_acc", "ref_acc"]:
+        result = {"acc": 0, "oboa": 0, "mae": 0, "rmse": 0}
+        if response:
+            try:
+                pred = w2n.word_to_num(response)
+            except:
+                pred = 0
+            if abs(float(right_answer) - float(pred)) <= 1e-5:
+                result["acc"] = 1
+
+            if abs(float(right_answer) - float(pred)) <= 1:
+                result["oboa"] = 1
+
+            if abs(float(right_answer) - float(pred)) <= max(2 * float(right_answer),100):
+                result["mae"] = abs(float(right_answer) - float(pred))
+                result["rmse"] = abs(float(right_answer) - float(pred)) ** 2
+            else:
+                result["mae"] = abs(float(right_answer) * 2)
+                result["rmse"] = abs(float(right_answer) * 2) ** 2
+    elif task_mode == "clue_acc":
+        result = {"wcs": 0, "ifa": 0}
+        if response:
+            clues = json.loads(right_answer)
+            content_match = re.search(r"<answer>(.*?)</answer>", response, re.DOTALL)
+            student_answer = content_match.group(1).strip() if content_match else response.strip()
+            j = None
+            try:
+                try:
+                    j = json.loads(student_answer)
+                except:
+                    j = json.loads(extract_outer_json(student_answer))
+            except:
+                pass
+            if j is not None:
+                try:
+                    if category == "event":
+                        pred = []
+                        for e in j:
+
+                            if isinstance(e[0],str) and isinstance(e[1],str) and ":" in e[0] and ":" in e[1]:
+                                pred.append([time_str_to_seconds(e[0]), time_str_to_seconds(e[1])])
+                            else:
+                                pred.append([float(e[0].split(" ")[0]) if isinstance(e[0],str) else e[0],
+                                             float(e[1].split(" ")[0]) if isinstance(e[1],str) else e[1]])
+                        gt = []
+                        for e in clues:
+                            gt.append([float(e['start']), float(e['end'])])
+
+                        result["wcs"] = compute_wcs_unlabeled([gt], [pred], "tIoU")
+                        result["ifa"] = 1
+                    elif category == "object":
+                        gt = []
+                        clue_timestamp_list = []
+                        for clue in clues:
+                            if clue["timestamp"] not in clue_timestamp_list:
+                                clue_timestamp_list.append(clue["timestamp"])
+                        for clue in clues:
+                            gt.append((clue_timestamp_list.index(clue["timestamp"]), clue['bbox']))
+                        pred = []
+                        for key in j.keys():
+                            if "Frame" not in key:
+                                continue
+                            idx = int(key.replace("Frame", "")) - 1
+                            if len(j[key]) == 0:
+                                continue
+                            if isinstance(j[key][0],list) and len(j[key][0]) == 4:
+                                for e in j[key]:
+                                    if isinstance(e,list) and len(e) == 4:
+                                        pred.append((idx, e))
+                            elif isinstance(j[key][0],list) and len(j[key][0]) == 2:
+                                for ii in range(int(len(j[key]) // 2)):
+                                    if isinstance(j[key][ii * 2],list) and len(j[key][ii * 2]) == 2 and isinstance(
+                                            j[key][ii * 2 + 1],list) and len(j[key][ii * 2 + 1]) == 2:
+                                        pred.append((idx, [j[key][ii * 2][0], j[key][ii * 2][1], j[key][ii * 2 + 1][0],
+                                                           j[key][ii * 2 + 1][1]]))
+                        result["wcs"] = compute_wcs_unlabeled([gt], [pred], "sIoU")
+                        result["ifa"] = 1
+                    elif category == "attribute":
+                        gt = []
+                        clue_timestamp_list = []
+                        for clue_ in clues:
+                            for clue in clue_:
+                                if clue["timestamp"] not in clue_timestamp_list:
+                                    clue_timestamp_list.append(clue["timestamp"])
+                        for clue_ in clues:
+                            gt_ = []
+                            for clue in clue_:
+                                gt_.append((clue_timestamp_list.index(clue["timestamp"]), clue['bbox']))
+                            gt.append(gt_)
+                        pred = {}
+                        for key in j.keys():
+                            if "Frame" not in key:
+                                continue
+                            idx = int(key.replace("Frame", "")) - 1
+                            for e in j[key]:
+                                if e['label'] not in pred.keys():
+                                    pred[e['label']] = []
+                                if 'bbox' in e:
+                                    if isinstance(e['bbox'],list) and len(e['bbox']) == 4:
+                                        pred[e['label']].append((idx, e['bbox']))
+                                if 'bbox_2d' in e:
+                                    if isinstance(e['bbox_2d'],list) and len(e['bbox_2d']) == 4:
+                                        pred[e['label']].append((idx, e['bbox_2d']))
+                        pred_list = [pred[key] for key in pred]
+                        result["wcs"] = compute_wcs_unlabeled(gt, pred_list, "sIoU")
+                        result["ifa"] = 1
+                except:
+                    pass
+
+    return result
+
+
+def get_chunk_number(filename):
+    try:
+        num = filename.split("chunk_")[1].split(".zip")[0]
+        return int(num)
+    except:
+        return float('inf')
+
+
+def auto_merge_and_unzip_parts(target_dir, extract_dir, zip_prefix=None):
+    target_dir = Path(target_dir)
+    extract_dir = Path(extract_dir)
+    extract_dir.mkdir(parents=True, exist_ok=True)
+
+    # 匹配 zip 分卷：例如 video_chunk_001.zip.part000
+    part_files = sorted(target_dir.glob("*.zip.part*"))
+    groups = {}
+
+    # 分组：根据前缀提取 group 名（即 zip 文件名）
+    for part_file in part_files:
+        match = re.match(r"(.*\.zip)\.part\d+$", part_file.name)
+        if match:
+            zip_name = match.group(1)
+            if zip_prefix is None or Path(zip_name).stem.startswith(zip_prefix):
+                groups.setdefault(zip_name, []).append(part_file)
+
+    if not groups:
+        print(f"No matching zip parts found with prefix: {zip_prefix}")
+        return
+
+    # 合并每一组分卷 -> 解压
+    for zip_name, parts in tqdm(groups.items(), desc="Merging and unzipping"):
+        parts = sorted(parts, key=lambda p: int(p.name.split("part")[-1]))
+        zip_path = target_dir / zip_name
+
+        # 合并分卷
+        with open(zip_path, 'wb') as outfile:
+            for part in parts:
+                with open(part, 'rb') as infile:
+                    outfile.write(infile.read())
+
+        # 解压合并后的 zip 文件
+        with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+            zip_ref.extractall(extract_dir)
+
+        # 删除合并后的 zip 文件（可注释）
+        zip_path.unlink()
+
+
+def unzip_hf_zip(target_dir):
+    target_dir = Path(target_dir)
+
+    videos_dir = target_dir / "cg_videos_720p"
+    ref_videos_dir = target_dir / "ref_videos"
+
+    if videos_dir.exists() and ref_videos_dir.exists():
+        print("all target dirs exist, skip.")
+        return
+
+    videos_dir.mkdir(parents=True, exist_ok=True)
+
+    auto_merge_and_unzip_parts(target_dir,ref_videos_dir, zip_prefix="ref_videos")
+    auto_merge_and_unzip_parts(target_dir,videos_dir, zip_prefix="videos")
+
+    print("sucessfully unzip all files.")

VLMEvalKit-sudoku/vlmeval/dataset/EgoExoBench/README.md

@@ -0,0 +1,79 @@
+# EgoExoBench
+
+This is the official repository of [EgoExoBench: A
+Benchmark for First- and Third-person View Video
+Understanding in MLLMs]()
+
+## 📊 Benchmark Overview
+
+**EgoExoBench** is a large-scale benchmark designed to evaluate cross-view video understanding in multimodal large language models (MLLMs). It contains paired egocentric–exocentric videos and over **7,300 multiple-choice questions** across **11 subtasks**, covering three key dimensions of ego–exo reasoning:
+
+* **Ego-Exo Relation**
+* **Ego-Exo View Transition**
+* **Ego-Exo Temporal Reasoning**
+
+## 📝 Data Preparation
+
+### Video Data
+
+EgoExoBench builds upon six publicly available ego–exo datasets.
+
+* [Ego-Exo4D](https://ego-exo4d-data.org/)
+* [LEMMA](https://sites.google.com/view/lemma-activity)
+* [EgoExoLearn](https://huggingface.co/datasets/hyf015/EgoExoLearn)
+* [TF2023](https://github.com/ziweizhao1993/PEN)
+* [EgoMe](https://huggingface.co/datasets/HeqianQiu/EgoMe)
+* [CVMHAT](https://github.com/RuizeHan/CVMHT)
+
+The script will automatically download the processed video data, **except Ego-Exo4D**, due to license restrictions. You need to manually download it from the [official website](https://ego-exo4d-data.org/) and organize it as shown below.
+
+If you prefer to download all datasets manually, you can simply create empty `processed_videos/` and `processed_frames/` folders and organize the datasets in the following structure:
+
+```
+[LMUData]/videos/EgoExoBench
+├── CVMHAT/
+│   └── data/
+├── EgoExo4D/
+│   └── takes/
+├── EgoExoLearn/
+├── EgoMe/
+├── LEMMA/
+├── TF2023/
+│   └── data/
+├── processed_frames/
+└── processed_videos/
+```
+### Multiple-Choice Questions (MCQs)
+
+The script will automatically download the EgoExoBench **multiple-choice questions (MCQs)** file from this [link](https://huggingface.co/datasets/Heleun/EgoExoBench_MCQ).
+
+## 🚀 Model Evaluation
+
+Use the following commands to evaluate your VLMs on EgoExoBench:
+
+```shell
+# For lightweight vision-language models
+torchrun --nproc-per-node=1 run.py \
+    --data EgoExoBench_MCQ \
+    --model Qwen2.5-VL-7B-Instruct-ForVideo
+
+# For larger models with higher memory usage
+python run.py \
+    --data EgoExoBench_MCQ \
+    --model Qwen2.5-VL-72B-Instruct-ForVideo
+```
+
+To skip evaluation on the **Ego-Exo4D** portion of the benchmark, specify the `EgoExoBench_64frame_skip_EgoExo4D` configuration with the **`--data`** argument.
+
+```
+# Example command to skip Ego-Exo4D
+torchrun --nproc-per-node=1 run.py \
+    --data EgoExoBench_64frame_skip_EgoExo4D \
+    --model [Your_Model_Name]
+```
+
+> 💡 Note: If you encounter errors related to stacking videos with varying frame counts, try using `transformers==4.49.0` as a temporary workaround.
+
+## 🙏 Acknowledgements
+
+EgoExoBench builds upon publicly available ego–exo datasets: [Ego-Exo4D](https://ego-exo4d-data.org/), [LEMMA](https://sites.google.com/view/lemma-activity), [EgoExoLearn](https://huggingface.co/datasets/hyf015/EgoExoLearn), [TF2023](https://github.com/ziweizhao1993/PEN), [EgoMe](https://huggingface.co/datasets/HeqianQiu/EgoMe), [CVMHAT](https://github.com/RuizeHan/CVMHT). Thanks for open-sourcing!

VLMEvalKit-sudoku/vlmeval/dataset/EgoExoBench/cvmhat_preprocess.py

@@ -0,0 +1,45 @@
+import json
+import os
+import xml.etree.ElementTree as ET
+import cv2
+
+# replace with your actual path
+ann_file = 'EgoExoBench/MCQ/Ego-Exo-Relation/person_relation.json'
+
+
+def add_bbox(bbox_img_path):
+    bbox_dir = os.path.dirname(bbox_img_path)
+    os.makedirs(bbox_dir, exist_ok=True)
+    ori_img_dir = os.path.dirname(bbox_img_path).replace('bbox', 'frame_sel')
+    frame_idx, person_id = os.path.basename(bbox_img_path).split('.')[0].split('_')
+    ori_img_path = os.path.join(ori_img_dir, frame_idx + '.jpg')
+    xml_file = ori_img_path.replace('data', 'GT_xml').replace('frame_sel/', '').replace('.jpg', '.xml')
+
+    tree = ET.parse(xml_file)
+    root = tree.getroot()
+    im = cv2.imread(ori_img_path)
+    for object in root.findall('object'):
+        object_name = object.find('name').text
+        if object_name != person_id:
+            continue
+        im_copy = im.copy()
+        Xmin = int(object.find('rectangle').find('xmin').text)
+        Ymin = int(object.find('rectangle').find('ymin').text)
+        Xmax = int(object.find('rectangle').find('xmax').text)
+        Ymax = int(object.find('rectangle').find('ymax').text)
+        color = (255, 0, 0)
+        cv2.rectangle(im_copy,(Xmin,Ymin),(Xmax,Ymax),color,3)
+        cv2.imwrite(bbox_img_path, im_copy)
+        return
+
+
+with open(ann_file, 'r') as f:
+    ann_data = json.load(f)
+    for aitem in ann_data.values():
+        image_paths = []
+        image_paths.extend(aitem['query']['image_paths'])
+        for oitem in aitem['options']:
+            image_paths.extend(oitem['image_paths'])
+
+        for image_path in image_paths:
+            add_bbox(image_path)

VLMEvalKit-sudoku/vlmeval/dataset/EgoExoBench/tf2023_preprocess.py

@@ -0,0 +1,71 @@
+import json
+import os
+import cv2
+import numpy as np
+
+# replace the path with your actual path
+ann_file = 'EgoExoBench/MCQ/Ego-Exo-View-Transition/ego_wearer_identification.json'
+
+
+def add_bbox(bbox_img_path):
+
+    bbox_dir = os.path.dirname(bbox_img_path)
+    os.makedirs(bbox_dir, exist_ok=True)
+    vid, frame_idx, person_id = bbox_img_path.split('/')[-4],bbox_img_path.split('/')[-2], bbox_img_path.split('/')[-1].split('.')[0]  # noqa: E501
+    import os.path as osp
+    json_file = os.path.join(osp.dirname(osp.dirname(osp.dirname(osp.dirname(bbox_img_path)))), vid, 'Segmentation/T', frame_idx + '.json')  # noqa: E501
+    ori_img_path = json_file.replace('.json', '.jpg')
+
+    with open(json_file, mode='r', encoding="utf-8") as f:
+        configs = json.load(f)
+    shapes = configs["shapes"]
+
+    mask = np.zeros((configs["imageHeight"], configs["imageWidth"], 1), np.uint8)
+
+    if not os.path.exists(ori_img_path):
+        ori_img_path = ori_img_path.replace('T/', '')
+
+    if not os.path.exists(ori_img_path):
+        ori_img_path = ori_img_path.replace('Segmentation/', 'frame/T/')
+
+    original_image = cv2.imread(ori_img_path)
+
+    for shape in shapes:
+        if shape['label'] != person_id:
+            continue
+
+        cv2.fillPoly(mask, [np.array(shape["points"], np.int32)], 1)
+
+        retval, labels, stats, centroids = cv2.connectedComponentsWithStats(mask, connectivity=8)
+        stats = stats[stats[:,4].argsort()]
+        bboxs = stats[:-1]
+
+        for b in bboxs:
+            x0, y0 = b[0], b[1]
+            x1 = b[0] + b[2]
+            y1 = b[1] + b[3]
+
+            start_point, end_point = (x0, y0), (x1, y1)
+            color = (0, 0, 255)
+            thickness = 2
+            mask_bboxs = cv2.rectangle(original_image, start_point, end_point, color, thickness)
+            mask_bboxs = cv2.resize(mask_bboxs, (540, 360))
+            cv2.imwrite(bbox_img_path, mask_bboxs)
+        return
+
+
+def rescale_img(img_path, width, height):
+    img = cv2.imread(img_path)
+    resized_img = cv2.resize(img, (width, height))
+    cv2.imwrite(img_path, resized_img)
+
+
+with open(ann_file, 'r') as f:
+    ann_data = json.load(f)
+    for aitem in ann_data.values():
+        image_paths = []
+        for oitem in aitem['options']:
+            add_bbox(oitem['image_paths'][0])
+
+        for img_path in aitem['query']['image_paths']:
+            rescale_img(img_path, 960, 540)

VLMEvalKit-sudoku/vlmeval/dataset/EgoExoBench/utils.py

@@ -0,0 +1,771 @@
+from ...smp import *
+from ..utils.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='subtask_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 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]
+
+
+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 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

VLMEvalKit-sudoku/vlmeval/dataset/GUI/screenspot.py

@@ -0,0 +1,461 @@
+import os
+import re
+import tempfile
+import itertools
+from functools import partial
+
+import pandas as pd
+import ast
+
+from ..image_base import ImageBaseDataset, img_root_map
+from ..utils import build_judge, DEBUG_MESSAGE
+from ...smp import *
+from ...utils import track_progress_rich
+from ipdb import set_trace as st
+
+logger = get_logger("RUN")
+
+"""
+{
+    "img_filename": "web_3b0ad239-da6b-4f6f-8f12-f674dc90ff33.png",
+    "bbox": [42, 1102, 197, 70],
+    "question": "view the details of the item",
+    "data_type": "text",
+    "data_source": "shop"
+},
+{
+    "img_filename": "web_3b0ad239-da6b-4f6f-8f12-f674dc90ff33.png",
+    "bbox": [93, 74, 86, 132],
+    "question": "view the previous photo",
+    "data_type": "icon",
+    "data_source": "shop"
+}
+"""
+
+SYSTEM_PROMPT = """You are a GUI agent. You are given a task and a screenshot of the screen. You need to perform pyautogui click/moveTo action to complete the task. The answer format is `pyautogui.click(x=?, y=?), x and y is necessary`"""  # noqa: E501
+
+USER_INSTRUCTION = """Please complete the following tasks by clicking using `pyautogui.click`:\n{instruction}"""
+
+SYSTEM_PROMPT_V2 = """You are a GUI agent. You are given a screenshot of the screen and the description of a target element. You need to click the target element using `pyautogui.click`. The answer format is `pyautogui.click(x=?, y=?), x and y is necessary`"""  # noqa: E501
+USER_INSTRUCTION_V2 = """Please click the following target element using `pyautogui.click`:\n{description}"""
+
+
+def parse_bbox_aguvis(response):
+    match = re.search(r"x=([\d.]+), y=([\d.]+)", response)
+    if match:
+        click_point = [float(match.group(1)), float(match.group(2))]
+    else:
+        click_point = [0.0, 0.0]
+    return click_point
+
+
+def compute_iou(box1, box2):
+    """
+    Compute the Intersection over Union (IoU) of two bounding boxes.
+
+    Parameters:
+    - box1 (list of float): Bounding box [x_min, y_min, x_max, y_max].
+    - box2 (list of float): Bounding box [x_min, y_min, x_max, y_max].
+
+    Returns:
+    - float: IoU of box1 and box2.
+    """
+    # Determine the coordinates of the intersection rectangle
+    x_left = max(box1[0], box2[0])
+    y_top = max(box1[1], box2[1])
+    x_right = min(box1[2], box2[2])
+    y_bottom = min(box1[3], box2[3])
+
+    # Compute the area of intersection
+    intersection_area = max(0, x_right - x_left) * max(0, y_bottom - y_top)
+
+    # Compute the area of both bounding boxes
+    box1_area = (box1[2] - box1[0]) * (box1[3] - box1[1])
+    box2_area = (box2[2] - box2[0]) * (box2[3] - box2[1])
+
+    # Compute the area of the union
+    union_area = box1_area + box2_area - intersection_area
+
+    # Compute the Intersection over Union
+    iou = intersection_area / union_area
+
+    return iou
+
+
+def compute_accuracy(box1, box2, threshold=0.5):
+    """
+    Compute the accuracy of two bounding boxes based on a specified threshold.
+
+    Parameters:
+    - box1 (list of float): Bounding box [x_min, y_min, x_max, y_max].
+    - box2 (list of float): Bounding box [x_min, y_min, x_max, y_max].
+    - threshold (float): Threshold for the IoU to consider the prediction correct.
+
+    Returns:
+    - float: Accuracy of the prediction based on the IoU threshold.
+    """
+    iou = compute_iou(box1, box2)
+    return iou >= threshold
+
+
+def compute_center_accuracy(box1, box2):
+    """
+    Compute if the center point of box 2 is within box 1.
+
+    Parameters:
+    - box1 (list of float): Bounding box [x_min, y_min, x_max, y_max].
+    - box2 (list of float): Bounding box [x_min, y_min, x_max, y_max].
+
+    Returns:
+    - bool: True if the center point of box 2 is within box 1, False otherwise.
+    """
+    # Compute the center point of box 2
+    center_x = (box2[0] + box2[2]) / 2
+    center_y = (box2[1] + box2[3]) / 2
+
+    # Check if the center point is within box 1
+    return box1[0] <= center_x <= box1[2] and box1[1] <= center_y <= box1[3]
+
+
+def convert_bbox(bbox, image_path):
+    new_bbox = bbox if isinstance(bbox, list) else ast.literal_eval(bbox)
+    new_bbox = [
+        new_bbox[0],
+        new_bbox[1],
+        new_bbox[0] + new_bbox[2],
+        new_bbox[1] + new_bbox[3],
+    ]
+    image = Image.open(image_path)
+    img_size = image.size
+    new_bbox = [
+        new_bbox[0] / img_size[0],
+        new_bbox[1] / img_size[1],
+        new_bbox[2] / img_size[0],
+        new_bbox[3] / img_size[1],
+    ]
+    return new_bbox
+
+
+class ScreenSpot(ImageBaseDataset):
+    MODALITY = "IMAGE"
+    TYPE = "GUI"
+    DATASET_URL = {
+        "ScreenSpot_Mobile": "http://opencompass.openxlab.space/utils/benchmarks/GUI/ScreenSpot/ScreenSpot_Mobile.tsv",  # noqa
+        "ScreenSpot_Desktop": "http://opencompass.openxlab.space/utils/benchmarks/GUI/ScreenSpot/ScreenSpot_Desktop.tsv",  # noqa
+        "ScreenSpot_Web": "http://opencompass.openxlab.space/utils/benchmarks/GUI/ScreenSpot/ScreenSpot_Web.tsv",  # noqa
+        "ScreenSpot_v2_Mobile": "http://opencompass.openxlab.space/utils/benchmarks/GUI/ScreenSpot_v2/ScreenSpot_v2_Mobile.tsv",  # noqa
+        "ScreenSpot_v2_Desktop": "http://opencompass.openxlab.space/utils/benchmarks/GUI/ScreenSpot_v2/ScreenSpot_v2_Desktop.tsv",  # noqa
+        "ScreenSpot_v2_Web": "http://opencompass.openxlab.space/utils/benchmarks/GUI/ScreenSpot_v2/ScreenSpot_v2_Web.tsv",  # noqa
+    }  # path
+    DATASET_URL_V2 = {
+        "ScreenSpot_Mobile": "$WORK_DIR/screenspot_mobile_ug.json",
+        "ScreenSpot_Desktop": "$WORK_DIR/screenspot_desktop_ug.json",
+        "ScreenSpot_Web": "$WORK_DIR/screenspot_web_ug.json",
+    }  # path
+    DATASET_MD5 = {
+        "ScreenSpot_Mobile": "a5b5299843a75c9b9574c47bc13b2c53",
+        "ScreenSpot_Desktop": "e6e7bac21b6b2475276404fce2458132",
+        "ScreenSpot_Web": "e51d168c14b8582427cf3107d236cfc5",
+        "ScreenSpot_v2_Mobile": "234c858ab4f0e787e8388a73df65a4b7",
+        "ScreenSpot_v2_Desktop": "5f2aa2a497327bd33b2512a0c75cf994",
+        "ScreenSpot_v2_Web": "01cd0877ee1b735a6d5190b053ba9482",
+    }
+    EVAL_TYPE = "point"  # point or rectangle
+    RE_TYPE = "functional"  # type of referring expressions: functional or composite
+
+    def __init__(
+        self,
+        dataset="ScreenSpot_Mobile",
+        skip_noimg=True,
+        skeleton=False,
+        re_type="functional",
+    ):
+        # st()
+        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", self.dataset_name)
+        self.RE_TYPE = re_type
+        if skeleton:
+            return
+
+        data = self.load_data(dataset)
+        self.skip_noimg = skip_noimg
+        if skip_noimg and "image" in data:
+            data = data[~pd.isna(data["image"])]
+
+        self.meta_only = True
+        self.parse_response_func = parse_bbox_aguvis  # TODO: parse function can be specified through kwargs when initializing the dataset # noqa: E501
+
+        # 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
+
+        self.data = data
+
+    def prepare_tsv(self, url, file_md5=None):
+        # st()
+        if self.RE_TYPE == "functional":
+            return super().prepare_tsv(url=url, file_md5=file_md5)
+        else:
+            data_path = self.DATASET_URL_V2[self.dataset_name]
+        return pd.DataFrame(load(data_path))
+
+    @classmethod
+    def get_action_space(self):
+        return ""
+
+    @classmethod
+    def get_trajectory(self, line):
+        traj_dict = {}
+        if self.RE_TYPE == "functional":
+            traj_dict["task"] = line["question"]
+        else:
+            traj_dict["task"] = line["description"]
+        return traj_dict
+
+    def build_prompt(self, line):
+        # st()
+        if isinstance(line, int):
+            line = self.data.iloc[line]
+        tgt_path = self.dump_image(line)
+
+        if self.RE_TYPE == "functional":
+            user_instruction = USER_INSTRUCTION.format(instruction=line["question"])
+        else:
+            user_instruction = USER_INSTRUCTION_V2.format(
+                description=line["description"]
+            )
+
+        msgs = []
+        # add system prompt
+        if self.RE_TYPE == "functional":
+            msgs.append(dict(role="system", type="text", value=SYSTEM_PROMPT))
+        else:
+            msgs.append(dict(role="system", type="text", value=SYSTEM_PROMPT_V2))
+        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=user_instruction))
+        return msgs
+
+    def evaluate(self, eval_file, **judge_kwargs):
+        # st()
+        if self.EVAL_TYPE == "point":
+            return self.evaluate_point(eval_file, **judge_kwargs)
+
+        elif self.EVAL_TYPE == "rectangle":
+            return self.evaluate_rectangle(eval_file, **judge_kwargs)
+
+    def evaluate_rectangle(self, eval_file, **judge_kwargs):
+        scorers = {
+            "IoU": compute_iou,
+            "ACC@0.1": lambda x, y: compute_accuracy(x, y, 0.1),
+            "ACC@0.3": lambda x, y: compute_accuracy(x, y, 0.3),
+            "ACC@0.5": lambda x, y: compute_accuracy(x, y, 0.5),
+            "ACC@0.7": lambda x, y: compute_accuracy(x, y, 0.7),
+            "ACC@0.9": lambda x, y: compute_accuracy(x, y, 0.9),
+            "Center_ACC": compute_center_accuracy,
+        }
+        results_dict = {}
+        for key in scorers.keys():
+            results_dict.update(
+                {
+                    key: [],
+                    key + "_text": [],
+                    key + "_icon": [],
+                }
+            )
+
+        result = []
+        data = load(eval_file)
+
+        assert "bbox" in data and "prediction" in data
+        lt = len(data)
+        lines = [data.iloc[i] for i in range(lt)]
+        for i in tqdm(range(len(lines))):
+            line = lines[i]
+            bbox = convert_bbox(
+                line["bbox"], os.path.join(self.img_root, line["image_path"])
+            )
+            prediction = str(line["prediction"])
+            try:
+                click_point = parse_bbox_aguvis(prediction)
+
+                match = {}
+                for score_key, score_value in scorers.items():
+                    score = score_value(bbox, click_point)
+                    if score_key != "IoU":
+                        match[score_key.replace("ACC", "match")] = score
+                    results_dict[score_key].append(score)
+                    if line["data_type"] == "text":
+                        results_dict[score_key + "_text"].append(score)
+                    else:
+                        results_dict[score_key + "_icon"].append(score)
+            except:
+                click_point = None
+                match = {score_key: False for score_key in scorers.keys() if score_key != "IoU"}
+            result.append(
+                {
+                    "img_path": os.path.join(self.img_root, line["image_path"]),
+                    "text": line["question"],
+                    "bbox": line["bbox"],
+                    "parsed_bbox": bbox,
+                    "type": line["data_type"],
+                    "source": line["data_source"],
+                    "pred": click_point,
+                    "num_matched": sum(match.values()),
+                    **match,
+                }
+            )
+        for key in results_dict:
+            if len(results_dict[key]) == 0:
+                results_dict[key] = str(0)
+            else:
+                results_dict[key] = str(sum(results_dict[key]) / len(results_dict[key]))
+        score_pth = get_intermediate_file_path(eval_file, '_score', 'json')
+        dump(results_dict, score_pth)
+
+        failure_cases_path = os.environ.get("FAILURE_CASES_PATH", None)
+        if failure_cases_path is not None:
+            failure_cases = [res for res in result if not res["match"] and res["is_wrong_format"]]
+            failure_cases.sort(key=lambda r: r["num_matched"], reverse=True)
+
+            with open(failure_cases_path, "w") as f:
+                json.dump(failure_cases, f, indent=4, ensure_ascii=False)
+        return results_dict
+
+    def evaluate_point(self, eval_file, **judge_kwargs):
+        # -1: format_err, 0: wrong, 1: correct
+        stats = defaultdict(list)
+        # Will include instance-level results
+        result = []
+
+        data = load(eval_file)
+        assert "bbox" in data and "prediction" in data
+        lt = len(data)
+        lines = [data.iloc[i] for i in range(lt)]
+        for i in tqdm(range(len(lines))):
+            line = lines[i]
+            bbox = (
+                line["bbox"]
+                if isinstance(line["bbox"], list)
+                else ast.literal_eval(line["bbox"])
+            )
+            # The format of bbox is (x1, y1, w, h)
+            x1, y1, w, h = bbox
+            bbox = (x1, y1, x1 + w - 1, y1 + h - 1)
+
+            image = Image.open(os.path.join(self.img_root, line["image_path"]))
+            img_size = image.size
+
+            def make_safe(value):
+                if value == -1:
+                    # we can tolerate -1 as a special value and nomalize it to 0
+                    return 0
+                else:
+                    return value
+
+            bbox = [
+                make_safe(bbox[0]) / img_size[0],
+                make_safe(bbox[1]) / img_size[1],
+                make_safe(bbox[2]) / img_size[0],
+                make_safe(bbox[3]) / img_size[1],
+            ]
+
+            if any([x < 0 or x > 1 for x in bbox]):
+                raise ValueError(f"bbox out of range: {bbox} | {line['bbox']} | {img_size}")
+
+            key = line['data_type'] if 'category' not in line else line['category'] + ":" + line['data_type']
+            prediction = str(line["prediction"])
+            try:
+                click_point = parse_bbox_aguvis(prediction)
+                # Do Normalization By Default
+                if click_point[0] > 1 or click_point[1] > 1:
+                    click_point = (click_point[0] / img_size[0], click_point[1] / img_size[1])
+
+                match = (bbox[0] <= click_point[0] <= bbox[2]) and \
+                    (bbox[1] <= click_point[1] <= bbox[3])
+
+                if match:
+                    stats[key].append(1)
+                else:
+                    stats[key].append(0)
+                is_wrong_format = False
+
+            except Exception as e:
+                logger.warning(f"exception in screenspot eval:{e}")
+                stats[key].append(-1)
+                match, is_wrong_format, click_point = False, True, None
+
+            result.append(
+                {
+                    "img_path": os.path.join(self.img_root, line["image_path"]),
+                    "text": line["question"],
+                    "bbox": line["bbox"],
+                    "parsed_bbox": bbox,
+                    "type": line["data_type"],
+                    "source": line["data_source"],
+                    "match": match,
+                    "is_wrong_format": is_wrong_format,
+                    "pred": click_point,
+                }
+            )
+
+        final_score_dict = {}
+        # Record the number of each category
+        final_score_dict.update({k + ':cnt': len(stats[k]) for k in stats})
+        # Calculate the Overall stats
+        full_stats = []
+        for v in stats.values():
+            full_stats.extend(v)
+        final_score_dict['Overall_Accuracy'] = np.mean([x > 0 for x in full_stats]) * 100
+        final_score_dict['Format_Err_Rate'] = np.mean([x < 0 for x in full_stats]) * 100
+        # Calculate the Accuracy of Text / Icon
+        text_stats = [v for k, v in stats.items() if k.endswith('text') for x in v]
+        text_stats = itertools.chain(*text_stats)
+        final_score_dict['Text_Accuracy'] = np.mean([x > 0 for x in text_stats]) * 100
+        icon_stats = [v for k, v in stats.items() if k.endswith('icon') for x in v]
+        icon_stats = itertools.chain(*icon_stats)
+        final_score_dict['Icon_Accuracy'] = np.mean([x > 0 for x in icon_stats]) * 100
+        # Calculate the Accuracy of Each Category
+        if 'category' in data:
+            cates = list(set(data['category']))
+            for c in cates:
+                sub_stats = [v for k, v in stats.items() if k.split(":")[0] == c for x in v]
+                sub_stats = itertools.chain(*sub_stats)
+                final_score_dict[c + '_Accuracy'] = np.mean([x > 0 for x in sub_stats]) * 100
+
+        score_pth = get_intermediate_file_path(eval_file, '_score', 'json')
+        dump(final_score_dict, score_pth)
+
+        failure_cases_path = os.environ.get("FAILURE_CASES_PATH", None)
+        if failure_cases_path is not None:
+            def click_distance(bbox, click_point):
+                x, y = click_point
+                x1, y1, x2, y2 = bbox
+                xc, yc = (x1 + x2) / 2, (y1 + y2) / 2
+                w, h = x2 - x1, y2 - y1
+                abs_shift_to_center = [abs(x - xc), abs(y - yc)]  # noqa: E501
+                width_outside, height_outside = [max(0, abs_shift_to_center[0] - w / 2), max(0, abs_shift_to_center[1] - h / 2)]  # noqa: E501
+                return (width_outside ** 2 + height_outside ** 2) ** 0.5  # noqa: E501
+
+            wrong_format_result = [res for res in result if res["is_wrong_format"]]
+            missed_result = [res for res in result if not res["match"] and not res["is_wrong_format"]]
+            missed_result.sort(key=lambda r: click_distance(r["parsed_bbox"], r["pred"]), reverse=True)
+            failure_cases = wrong_format_result + missed_result
+
+            with open(failure_cases_path, "w") as f:
+                json.dump(failure_cases, f, indent=4, ensure_ascii=False)
+        return final_score_dict

VLMEvalKit-sudoku/vlmeval/dataset/GUI/screenspot_pro.py

@@ -0,0 +1,460 @@
+import os
+import re
+import tempfile
+import itertools
+from functools import partial
+
+import pandas as pd
+import ast
+
+from ..image_base import ImageBaseDataset, img_root_map
+from ..utils import build_judge, DEBUG_MESSAGE
+from ...smp import *
+from ...utils import track_progress_rich
+from ipdb import set_trace as st
+
+logger = get_logger("RUN")
+
+"""
+{
+    "img_filename": "web_3b0ad239-da6b-4f6f-8f12-f674dc90ff33.png",
+    "bbox": [42, 1102, 197, 70],
+    "question": "view the details of the item",
+    "data_type": "text",
+    "data_source": "shop"
+},
+{
+    "img_filename": "web_3b0ad239-da6b-4f6f-8f12-f674dc90ff33.png",
+    "bbox": [93, 74, 86, 132],
+    "question": "view the previous photo",
+    "data_type": "icon",
+    "data_source": "shop"
+}
+"""
+
+SYSTEM_PROMPT = """You are a GUI agent. You are given a task and a screenshot of the screen. You need to perform pyautogui click/moveTo action to complete the task. The answer format is `pyautogui.click(x=?, y=?), x and y is necessary`"""  # noqa: E501
+
+USER_INSTRUCTION = """Please complete the following tasks by clicking using `pyautogui.click`:\n{instruction}"""  # noqa: E501
+
+SYSTEM_PROMPT_V2 = """You are a GUI agent. You are given a screenshot of the screen and the description of a target element. You need to click the target element using `pyautogui.click`. The answer format is `pyautogui.click(x=?, y=?), x and y is necessary`"""  # noqa: E501
+USER_INSTRUCTION_V2 = """Please click the following target element using `pyautogui.click`:\n{description}"""
+
+
+def parse_bbox_aguvis(response):
+    match = re.search(r"x=([\d.]+), y=([\d.]+)", response)
+    if match:
+        click_point = [float(match.group(1)), float(match.group(2))]
+    else:
+        click_point = [0.0, 0.0]
+    return click_point
+
+
+def compute_iou(box1, box2):
+    """
+    Compute the Intersection over Union (IoU) of two bounding boxes.
+
+    Parameters:
+    - box1 (list of float): Bounding box [x_min, y_min, x_max, y_max].
+    - box2 (list of float): Bounding box [x_min, y_min, x_max, y_max].
+
+    Returns:
+    - float: IoU of box1 and box2.
+    """
+    # Determine the coordinates of the intersection rectangle
+    x_left = max(box1[0], box2[0])
+    y_top = max(box1[1], box2[1])
+    x_right = min(box1[2], box2[2])
+    y_bottom = min(box1[3], box2[3])
+
+    # Compute the area of intersection
+    intersection_area = max(0, x_right - x_left) * max(0, y_bottom - y_top)
+
+    # Compute the area of both bounding boxes
+    box1_area = (box1[2] - box1[0]) * (box1[3] - box1[1])
+    box2_area = (box2[2] - box2[0]) * (box2[3] - box2[1])
+
+    # Compute the area of the union
+    union_area = box1_area + box2_area - intersection_area
+
+    # Compute the Intersection over Union
+    iou = intersection_area / union_area
+
+    return iou
+
+
+def compute_accuracy(box1, box2, threshold=0.5):
+    """
+    Compute the accuracy of two bounding boxes based on a specified threshold.
+
+    Parameters:
+    - box1 (list of float): Bounding box [x_min, y_min, x_max, y_max].
+    - box2 (list of float): Bounding box [x_min, y_min, x_max, y_max].
+    - threshold (float): Threshold for the IoU to consider the prediction correct.
+
+    Returns:
+    - float: Accuracy of the prediction based on the IoU threshold.
+    """
+    iou = compute_iou(box1, box2)
+    return iou >= threshold
+
+
+def compute_center_accuracy(box1, box2):
+    """
+    Compute if the center point of box 2 is within box 1.
+
+    Parameters:
+    - box1 (list of float): Bounding box [x_min, y_min, x_max, y_max].
+    - box2 (list of float): Bounding box [x_min, y_min, x_max, y_max].
+
+    Returns:
+    - bool: True if the center point of box 2 is within box 1, False otherwise.
+    """
+    # Compute the center point of box 2
+    center_x = (box2[0] + box2[2]) / 2
+    center_y = (box2[1] + box2[3]) / 2
+
+    # Check if the center point is within box 1
+    return box1[0] <= center_x <= box1[2] and box1[1] <= center_y <= box1[3]
+
+
+def convert_bbox(bbox, image_path, convert_xywh_to_x1y1x2y2=True):
+    new_bbox = bbox if isinstance(bbox, list) else ast.literal_eval(bbox)
+    if convert_xywh_to_x1y1x2y2:
+        new_bbox = [
+            new_bbox[0],
+            new_bbox[1],
+            new_bbox[0] + new_bbox[2],
+            new_bbox[1] + new_bbox[3],
+        ]
+    image = Image.open(image_path)
+    img_size = image.size
+    new_bbox = [
+        new_bbox[0] / img_size[0],
+        new_bbox[1] / img_size[1],
+        new_bbox[2] / img_size[0],
+        new_bbox[3] / img_size[1],
+    ]
+    return new_bbox
+
+
+class ScreenSpot_Pro(ImageBaseDataset):
+    MODALITY = "IMAGE"
+    TYPE = "GUI"
+    DATASET_URL = {
+        "ScreenSpot_Pro_Development": "http://opencompass.openxlab.space/utils/benchmarks/GUI/ScreenSpot_Pro/ScreenSpot_Pro_Development.tsv",  # noqa
+        "ScreenSpot_Pro_Creative": "http://opencompass.openxlab.space/utils/benchmarks/GUI/ScreenSpot_Pro/ScreenSpot_Pro_Creative.tsv",  # noqa
+        "ScreenSpot_Pro_CAD": "http://opencompass.openxlab.space/utils/benchmarks/GUI/ScreenSpot_Pro/ScreenSpot_Pro_CAD.tsv",  # noqa
+        "ScreenSpot_Pro_Scientific": "http://opencompass.openxlab.space/utils/benchmarks/GUI/ScreenSpot_Pro/ScreenSpot_Pro_Scientific.tsv",  # noqa
+        "ScreenSpot_Pro_Office": "http://opencompass.openxlab.space/utils/benchmarks/GUI/ScreenSpot_Pro/ScreenSpot_Pro_Office.tsv",  # noqa
+        "ScreenSpot_Pro_OS": "http://opencompass.openxlab.space/utils/benchmarks/GUI/ScreenSpot_Pro/ScreenSpot_Pro_OS.tsv",  # noqa
+    }  # path
+    DATASET_MD5 = {
+        'ScreenSpot_Pro_Development': '45b93df1d5814885011d682fe1b0f959',
+        'ScreenSpot_Pro_Creative': 'a15867fee82ba8cd95581895c55f03cd',
+        'ScreenSpot_Pro_CAD': '0faa3bc29eba359766c3a7ca2c4d8917',
+        'ScreenSpot_Pro_Scientific': 'edc2e1f2b53af5fff6480b77c4986b81',
+        'ScreenSpot_Pro_Office': '8756c128cf567274c2647423ccc4eaf0',
+        'ScreenSpot_Pro_OS': '49c3eaaa7df6d22475c39120fe8f1c06'
+    }
+    EVAL_TYPE = "point"  # point or rectangle
+    RE_TYPE = "functional"  # type of referring expressions: functional or composite
+
+    def __init__(
+        self,
+        dataset="ScreenSpot_Pro_Development",
+        skip_noimg=True,
+        skeleton=False,
+        re_type="functional",
+    ):
+        # st()
+        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", self.dataset_name)
+        self.RE_TYPE = re_type
+        if skeleton:
+            return
+
+        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(idx + 1) for idx, x in enumerate(data["bbox"])]
+
+        self.meta_only = True
+        self.parse_response_func = parse_bbox_aguvis  # TODO: parse function can be specified through kwargs when initializing the dataset # noqa: E501
+
+        # The image field can store the base64 encoded image or another question index (for saving space) # noqa: E501
+        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
+
+        self.data = data
+
+    @classmethod
+    def get_action_space(self):
+        return ""
+
+    @classmethod
+    def get_trajectory(self, line):
+        traj_dict = {}
+        if self.RE_TYPE == "functional":
+            traj_dict["task"] = line["question"]
+        else:
+            traj_dict["task"] = line["description"]
+        return traj_dict
+
+    def build_prompt(self, line):
+        if isinstance(line, int):
+            line = self.data.iloc[line]
+        tgt_path = self.dump_image(line)
+
+        if self.RE_TYPE == "functional":
+            user_instruction = USER_INSTRUCTION.format(instruction=line["question"])
+        else:
+            user_instruction = USER_INSTRUCTION_V2.format(
+                description=line["description"]
+            )
+
+        msgs = []
+        # add system prompt
+        if self.RE_TYPE == "functional":
+            msgs.append(dict(role="system", type="text", value=SYSTEM_PROMPT))
+        else:
+            msgs.append(dict(role="system", type="text", value=SYSTEM_PROMPT_V2))
+        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=user_instruction))
+        return msgs
+
+    def evaluate(self, eval_file, **judge_kwargs):
+        # st()
+        if self.EVAL_TYPE == "point":
+            return self.evaluate_point(eval_file, **judge_kwargs)
+
+        elif self.EVAL_TYPE == "rectangle":
+            return self.evaluate_rectangle(eval_file, **judge_kwargs)
+
+    def evaluate_rectangle(self, eval_file, **judge_kwargs):
+        scorers = {
+            "IoU": compute_iou,
+            "ACC@0.1": lambda x, y: compute_accuracy(x, y, 0.1),
+            "ACC@0.3": lambda x, y: compute_accuracy(x, y, 0.3),
+            "ACC@0.5": lambda x, y: compute_accuracy(x, y, 0.5),
+            "ACC@0.7": lambda x, y: compute_accuracy(x, y, 0.7),
+            "ACC@0.9": lambda x, y: compute_accuracy(x, y, 0.9),
+            "Center_ACC": compute_center_accuracy,
+        }
+        results_dict = {}
+        for key in scorers.keys():
+            results_dict.update(
+                {
+                    key: [],
+                    key + "_text": [],
+                    key + "_icon": [],
+                }
+            )
+
+        result = []
+        data = load(eval_file)
+        assert "bbox" in data and "prediction" in data
+        lt = len(data)
+        lines = [data.iloc[i] for i in range(lt)]
+        for i in tqdm(range(len(lines))):
+            line = lines[i]
+            bbox = convert_bbox(
+                line["bbox"], os.path.join(self.img_root, line["image_path"]), convert_xywh_to_x1y1x2y2=False
+            )
+            prediction = str(line["prediction"])
+            try:
+                click_point = parse_bbox_aguvis(prediction)
+
+                match = {}
+                for score_key, score_value in scorers.items():
+                    score = score_value(bbox, click_point)
+                    if score_key != "IoU":
+                        match[score_key.replace("ACC", "match")] = score
+                    results_dict[score_key].append(score)
+                    if line["ui_type"] == "text":
+                        results_dict[score_key + "_text"].append(score)
+                    else:
+                        results_dict[score_key + "_icon"].append(score)
+            except:
+                click_point = None
+                match = {score_key: False for score_key in scorers.keys() if score_key != "IoU"}
+            result.append(
+                {
+                    "img_path": os.path.join(self.img_root, line["image_path"]),
+                    "text": line["question"],
+                    "bbox": line["bbox"],
+                    "parsed_bbox": bbox,
+                    "type": line["ui_type"],
+                    "source": line["application"],
+                    "pred": click_point,
+                    "num_matched": sum(match.values()),
+                    **match,
+                }
+            )
+        for key in results_dict:
+            if len(results_dict[key]) == 0:
+                results_dict[key] = str(0)
+            else:
+                results_dict[key] = str(sum(results_dict[key]) / len(results_dict[key]))
+        score_pth = get_intermediate_file_path(eval_file, '_score', 'json')
+        dump(results_dict, score_pth)
+
+        failure_cases_path = os.environ.get("FAILURE_CASES_PATH", None)
+        if failure_cases_path is not None:
+            failure_cases = [res for res in result if not res["match"] and res["is_wrong_format"]]
+            failure_cases.sort(key=lambda r: r["num_matched"], reverse=True)
+
+            with open(failure_cases_path, "w") as f:
+                json.dump(failure_cases, f, indent=4, ensure_ascii=False)
+        return results_dict
+
+    def evaluate_point(self, eval_file, **judge_kwargs):
+        # -1: format_err, 0: wrong, 1: correct
+        stats = defaultdict(list)
+        # Will include instance-level results
+        result = []
+
+        data = load(eval_file)
+        assert "bbox" in data and "prediction" in data
+        lt = len(data)
+        lines = [data.iloc[i] for i in range(lt)]
+        for i in tqdm(range(len(lines))):
+            line = lines[i]
+            bbox = (
+                line["bbox"]
+                if isinstance(line["bbox"], list)
+                else ast.literal_eval(line["bbox"])
+            )
+            # The format of bbox is (x1, y1, x2, y2)
+
+            image = Image.open(os.path.join(self.img_root, line["image_path"]))
+            img_size = image.size
+
+            def make_safe(value):
+                if value == -1:
+                    # we can tolerate -1 as a special value and nomalize it to 0
+                    return 0
+                else:
+                    return value
+
+            bbox = [
+                make_safe(bbox[0]) / img_size[0],
+                make_safe(bbox[1]) / img_size[1],
+                make_safe(bbox[2]) / img_size[0],
+                make_safe(bbox[3]) / img_size[1],
+            ]
+
+            if any([x < 0 or x > 1 for x in bbox]):
+                raise ValueError(f"bbox out of range: {bbox} | {line['bbox']} | {img_size}")
+
+            key = line["category"] + ":" + line['ui_type']
+            prediction = str(line["prediction"])
+            try:
+                click_point = self.parse_response_func(prediction)
+                # Do Normalization By Default
+                if click_point[0] > 1 or click_point[1] > 1:
+                    click_point = (click_point[0] / img_size[0], click_point[1] / img_size[1])
+
+                match = (bbox[0] <= click_point[0] <= bbox[2]) and \
+                    (bbox[1] <= click_point[1] <= bbox[3])
+
+                if match:
+                    stats[key].append(1)
+                else:
+                    stats[key].append(0)
+                is_wrong_format = False
+
+            except Exception as e:
+                logger.warning(f"exception in screenspot eval:{e}")
+                stats[key].append(-1)
+                match, is_wrong_format, click_point = False, True, None
+
+            result.append(
+                {
+                    "img_path": os.path.join(self.img_root, line["image_path"]),
+                    "text": line["question"],
+                    "bbox": line["bbox"],
+                    "parsed_bbox": bbox,
+                    "type": line["ui_type"],
+                    "source": line["application"],
+                    "match": match,
+                    "is_wrong_format": is_wrong_format,
+                    "pred": click_point,
+                }
+            )
+
+        final_score_dict = {}
+        # Record the number of each category
+        final_score_dict.update({k + ':cnt': len(stats[k]) for k in stats})
+        # Calculate the Overall stats
+        full_stats = []
+        for v in stats.values():
+            full_stats.extend(v)
+        final_score_dict['Overall_Accuracy'] = np.mean([x > 0 for x in full_stats]) * 100
+        final_score_dict['Format_Err_Rate'] = np.mean([x < 0 for x in full_stats]) * 100
+        # Calculate the Accuracy of Text / Icon
+        text_stats = [v for k, v in stats.items() if k.split(":")[1] == "text" for x in v]
+        text_stats = itertools.chain(*text_stats)
+        final_score_dict['Text_Accuracy'] = np.mean([x > 0 for x in text_stats]) * 100
+        icon_stats = [v for k, v in stats.items() if k.split(":")[1] == "icon" for x in v]
+        icon_stats = itertools.chain(*icon_stats)
+        final_score_dict['Icon_Accuracy'] = np.mean([x > 0 for x in icon_stats]) * 100
+        # Calculate the Accuracy of Each Category
+        cates = list(set(data['category']))
+        for c in cates:
+            sub_stats = [v for k, v in stats.items() if k.split(":")[0] == c for x in v]
+            sub_stats = itertools.chain(*sub_stats)
+            final_score_dict[c + '_Accuracy'] = np.mean([x > 0 for x in sub_stats]) * 100
+
+        score_pth = get_intermediate_file_path(eval_file, '_score', 'json')
+        dump(final_score_dict, score_pth)
+
+        failure_cases_path = os.environ.get("FAILURE_CASES_PATH", None)
+        if failure_cases_path is not None:
+            def click_distance(bbox, click_point):
+                x, y = click_point
+                x1, y1, x2, y2 = bbox
+                xc, yc = (x1 + x2) / 2, (y1 + y2) / 2
+                w, h = x2 - x1, y2 - y1
+                abs_shift_to_center = [abs(x - xc), abs(y - yc)]  # noqa: E501
+                width_outside, height_outside = [max(0, abs_shift_to_center[0] - w / 2), max(0, abs_shift_to_center[1] - h / 2)]  # noqa: E501
+                return (width_outside ** 2 + height_outside ** 2) ** 0.5  # noqa: E501
+
+            wrong_format_result = [res for res in result if res["is_wrong_format"]]
+            missed_result = [res for res in result if not res["match"] and not res["is_wrong_format"]]
+            missed_result.sort(key=lambda r: click_distance(r["parsed_bbox"], r["pred"]), reverse=True)
+            failure_cases = wrong_format_result + missed_result
+
+            with open(failure_cases_path, "w") as f:
+                json.dump(failure_cases, f, indent=4, ensure_ascii=False)
+
+        successful_cases_path = os.environ.get("SUCCESSFUL_CASES_PATH", None)
+        if successful_cases_path is not None:
+            def _click_distance(bbox, click_point):
+                x, y = click_point
+                x1, y1, x2, y2 = bbox
+                xc, yc = (x1 + x2) / 2, (y1 + y2) / 2
+                x_shift, y_shift = x - xc, y - yc
+                return (x_shift ** 2 + y_shift ** 2) ** 0.5
+
+            successful_cases = [res for res in result if res["match"]]
+            successful_cases.sort(key=lambda r: _click_distance(r["parsed_bbox"], r["pred"]), reverse=True)
+            with open(successful_cases_path, "w") as f:
+                json.dump(successful_cases, f, indent=4, ensure_ascii=False)
+        return final_score_dict

VLMEvalKit-sudoku/vlmeval/dataset/OmniDocBench/data_preprocess.py

@@ -0,0 +1,447 @@
+import re
+import unicodedata
+from pylatexenc.latex2text import LatexNodes2Text
+from bs4 import BeautifulSoup
+import subprocess
+import shutil
+import uuid
+import html
+import os
+
+def remove_markdown_fences(content):
+    content = re.sub(r'^```markdown\n?', '', content, flags=re.MULTILINE)
+    content = re.sub(r'```\n?$', '', content, flags=re.MULTILINE)
+    return content
+
+# Standardize all consecutive characters
+def replace_repeated_chars(input_str):
+    input_str = re.sub(r'_{4,}', '____', input_str) # Replace more than 4 consecutive underscores with 4 underscores
+    input_str = re.sub(r' {4,}', '    ', input_str)   # Replace more than 4 consecutive spaces with 4 spaces
+    return re.sub(r'([^a-zA-Z0-9])\1{10,}', r'\1\1\1\1', input_str) # For other consecutive symbols (except numbers and letters), replace more than 10 occurrences with 4
+
+# Special Unicode handling
+def fullwidth_to_halfwidth(s):
+    result = []
+    for char in s:
+        code = ord(char)
+        # Convert full-width space to half-width space
+        if code == 0x3000:
+            code = 0x0020
+        # Convert other full-width characters to half-width
+        elif 0xFF01 <= code <= 0xFF5E:
+            code -= 0xFEE0
+        result.append(chr(code))
+    return ''.join(result)
+
+def find_special_unicode(s):
+    special_chars = {}
+    for char in s:
+        if ord(char) > 127:  # Non-ASCII characters
+            # unicode_name = unicodedata.name(char, None)
+            unicode_name = unicodedata.category(char)
+            special_chars[char] = f'U+{ord(char):04X} ({unicode_name})'
+    return special_chars
+
+# # Define dictionary for Unicode character replacements
+# unicode_replacements = {
+#     "\u00A9": r"$\copyright$",  # Copyright symbol © to latex
+#     "\u00AE": r"$^\circledR$",  # Registered trademark ® to latex
+#     "\u2122": r"$^\text{TM}$",   # Trademark ™ to latex
+#     "\u2018": "'",             # Left single quote to straight quote
+#     "\u2019": "'",             # Right single quote to straight quote
+#     "\u201C": "\"",            # Left double quote to straight quote
+#     "\u201D": "\"",            # Right double quote to straight quote
+#     "\u2013": "-",             # En dash to hyphen
+#     "\u2014": "-",             # Em dash to hyphen
+#     "\u2026": "...",           # Unicode ellipsis to three dots
+#     "\u2103": r"$\textdegree C$",  # ℃
+#     "\u03B1": r"$\alpha$",         # α
+#     "\u03B2": r"$\beta$",          # β
+#     "\u03A3": r"$\Sigma$",         # Σ
+# }
+
+# # Use regex to replace Unicode characters
+# def replace_unicode(match):
+#     char = match.group(0)
+#     return unicode_replacements.get(char, char)
+
+inline_reg = re.compile(
+    r'\$(.*?)\$|'
+    r'\\\((.*?)\\\)',
+)
+
+def textblock2unicode(text):
+    inline_matches = inline_reg.finditer(text)
+    removal_positions = []
+    for match in inline_matches:
+        position = [match.start(), match.end()]
+        content = match.group(1) if match.group(1) is not None else match.group(2)
+        # print('-------- content-------', content)
+        # Remove escape characters \
+        clean_content = re.sub(r'\\([\\_&%^])', '', content)
+
+        try:
+            if any(char in clean_content for char in r'\^_'):
+                if clean_content.endswith('\\'):
+                    clean_content += ' '
+                # inline_array.append(match.group(0))
+                unicode_content = LatexNodes2Text().latex_to_text(clean_content)
+                removal_positions.append((position[0], position[1], unicode_content))
+        except:
+            continue
+
+    # Remove inline formulas from original text
+    for start, end, unicode_content in sorted(removal_positions, reverse=True):
+        text = text[:start] + unicode_content.strip() + text[end:]
+
+    return text
+
+def normalized_formula(text):
+    # Normalize math formulas before matching
+    filter_list = ['\\mathbf', '\\mathrm', '\\mathnormal', '\\mathit', '\\mathbb', '\\mathcal', '\\mathscr', '\\mathfrak', '\\mathsf', '\\mathtt',
+                   '\\textbf', '\\text', '\\boldmath', '\\boldsymbol', '\\operatorname', '\\bm',
+                   '\\symbfit', '\\mathbfcal', '\\symbf', '\\scriptscriptstyle', '\\notag',
+                   '\\setlength', '\\coloneqq', '\\space', '\\thickspace', '\\thinspace', '\\medspace', '\\nobreakspace', '\\negmedspace',
+                   '\\quad', '\\qquad', '\\enspace', '\\substackw', ' ']
+                #    '\\left', '\\right', '{', '}', ' ']
+
+    # delimiter_filter
+    pattern = re.compile(r"\\\[(.+?)(?<!\\)\\\]")
+    match = pattern.search(text)
+
+    if match:
+        text = match.group(1).strip()
+
+    tag_pattern = re.compile(r"\\tag\{.*?\}")
+    text = tag_pattern.sub('', text)
+    hspace_pattern = re.compile(r"\\hspace\{.*?\}")
+    text = hspace_pattern.sub('', text)
+    begin_pattern = re.compile(r"\\begin\{.*?\}")
+    text = begin_pattern.sub('', text)
+    end_pattern = re.compile(r"\\end\{.*?\}")
+    text = end_pattern.sub('', text)
+    col_sep = re.compile(r"\\arraycolsep.*?\}")
+    text = col_sep.sub('', text)
+    text = text.strip('.')
+
+    for filter_text in filter_list:
+        text = text.replace(filter_text, '')
+
+    # text = normalize_text(delimiter_filter(text))
+    # text = delimiter_filter(text)
+    text = text.lower()
+    return text
+
+def normalized_html_table(text):
+    def process_table_html(md_i):
+        """
+        pred_md format edit
+        """
+        def process_table_html(html_content):
+            soup = BeautifulSoup(html_content, 'html.parser')
+            th_tags = soup.find_all('th')
+            for th in th_tags:
+                th.name = 'td'
+            thead_tags = soup.find_all('thead')
+            for thead in thead_tags:
+                thead.unwrap()  # unwrap()会移除标签但保留其内容
+            math_tags = soup.find_all('math')
+            for math_tag in math_tags:
+                alttext = math_tag.get('alttext', '')
+                alttext = f'${alttext}$'
+                if alttext:
+                    math_tag.replace_with(alttext)
+            span_tags = soup.find_all('span')
+            for span in span_tags:
+                span.unwrap()
+            return str(soup)
+
+        table_res=''
+        table_res_no_space=''
+        if '<table' in md_i.replace(" ","").replace("'",'"'):
+            md_i = process_table_html(md_i)
+            table_res = html.unescape(md_i).replace('\n', '')
+            table_res = unicodedata.normalize('NFKC', table_res).strip()
+            pattern = r'<table\b[^>]*>(.*)</table>'
+            tables = re.findall(pattern, table_res, re.DOTALL | re.IGNORECASE)
+            table_res = ''.join(tables)
+            # table_res = re.sub('<table.*?>','',table_res)
+            table_res = re.sub('( style=".*?")', "", table_res)
+            table_res = re.sub('( height=".*?")', "", table_res)
+            table_res = re.sub('( width=".*?")', "", table_res)
+            table_res = re.sub('( align=".*?")', "", table_res)
+            table_res = re.sub('( class=".*?")', "", table_res)
+            table_res = re.sub('</?tbody>',"",table_res)
+
+            table_res = re.sub(r'\s+', " ", table_res)
+            table_res_no_space = '<html><body><table border="1" >' + table_res.replace(' ','') + '</table></body></html>'
+            # table_res_no_space = re.sub(' (style=".*?")',"",table_res_no_space)
+            # table_res_no_space = re.sub(r'[ ]', " ", table_res_no_space)
+            table_res_no_space = re.sub('colspan="', ' colspan="', table_res_no_space)
+            table_res_no_space = re.sub('rowspan="', ' rowspan="', table_res_no_space)
+            table_res_no_space = re.sub('border="', ' border="', table_res_no_space)
+
+            table_res = '<html><body><table border="1" >' + table_res + '</table></body></html>'
+            # table_flow.append(table_res)
+            # table_flow_no_space.append(table_res_no_space)
+
+        return table_res, table_res_no_space
+
+    def clean_table(input_str,flag=True):
+        if flag:
+            input_str = input_str.replace('<sup>', '').replace('</sup>', '')
+            input_str = input_str.replace('<sub>', '').replace('</sub>', '')
+            input_str = input_str.replace('<span>', '').replace('</span>', '')
+            input_str = input_str.replace('<div>', '').replace('</div>', '')
+            input_str = input_str.replace('<p>', '').replace('</p>', '')
+            input_str = input_str.replace('<spandata-span-identity="">', '')
+            input_str = re.sub('<colgroup>.*?</colgroup>','',input_str)
+        return input_str
+
+    norm_text, _ = process_table_html(text)
+    norm_text = clean_table(norm_text)
+    return norm_text
+
+def normalized_latex_table(text):
+    def latex_template(latex_code):
+        template = r'''
+        \documentclass[border=20pt]{article}
+        \usepackage{subcaption}
+        \usepackage{url}
+        \usepackage{graphicx}
+        \usepackage{caption}
+        \usepackage{multirow}
+        \usepackage{booktabs}
+        \usepackage{color}
+        \usepackage{colortbl}
+        \usepackage{xcolor,soul,framed}
+        \usepackage{fontspec}
+        \usepackage{amsmath,amssymb,mathtools,bm,mathrsfs,textcomp}
+        \setlength{\parindent}{0pt}''' + \
+        r'''
+        \begin{document}
+        ''' + \
+        latex_code + \
+        r'''
+        \end{document}'''
+
+        return template
+
+    def process_table_latex(latex_code):
+        SPECIAL_STRINGS= [
+            ['\\\\vspace\\{.*?\\}', ''],
+            ['\\\\hspace\\{.*?\\}', ''],
+            ['\\\\rule\{.*?\\}\\{.*?\\}', ''],
+            ['\\\\addlinespace\\[.*?\\]', ''],
+            ['\\\\addlinespace', ''],
+            ['\\\\renewcommand\\{\\\\arraystretch\\}\\{.*?\\}', ''],
+            ['\\\\arraystretch\\{.*?\\}', ''],
+            ['\\\\(row|column)?colors?\\{[^}]*\\}(\\{[^}]*\\}){0,2}', ''],
+            ['\\\\color\\{.*?\\}', ''],
+            ['\\\\textcolor\\{.*?\\}', ''],
+            ['\\\\rowcolor(\\[.*?\\])?\\{.*?\\}', ''],
+            ['\\\\columncolor(\\[.*?\\])?\\{.*?\\}', ''],
+            ['\\\\cellcolor(\\[.*?\\])?\\{.*?\\}', ''],
+            ['\\\\colorbox\\{.*?\\}', ''],
+            ['\\\\(tiny|scriptsize|footnotesize|small|normalsize|large|Large|LARGE|huge|Huge)', ''],
+            [r'\s+', ' '],
+            ['\\\\centering', ''],
+            ['\\\\begin\\{table\\}\\[.*?\\]', '\\\\begin{table}'],
+            ['\t', ''],
+            ['@{}', ''],
+            ['\\\\toprule(\\[.*?\\])?', '\\\\hline'],
+            ['\\\\bottomrule(\\[.*?\\])?', '\\\\hline'],
+            ['\\\\midrule(\\[.*?\\])?', '\\\\hline'],
+            ['p\\{[^}]*\\}', 'l'],
+            ['m\\{[^}]*\\}', 'c'],
+            ['\\\\scalebox\\{[^}]*\\}\\{([^}]*)\\}', '\\1'],
+            ['\\\\textbf\\{([^}]*)\\}', '\\1'],
+            ['\\\\textit\\{([^}]*)\\}', '\\1'],
+            ['\\\\cmidrule(\\[.*?\\])?\\(.*?\\)\\{([0-9]-[0-9])\\}', '\\\\cline{\\2}'],
+            ['\\\\hline', ''],
+            [r'\\multicolumn\{1\}\{[^}]*\}\{((?:[^{}]|(?:\{[^{}]*\}))*)\}', r'\1']
+        ]
+        pattern = r'\\begin\{tabular\}.*\\end\{tabular\}'  # 注意这里不用 .*?
+        matches = re.findall(pattern, latex_code, re.DOTALL)
+        latex_code = ' '.join(matches)
+
+        for special_str in SPECIAL_STRINGS:
+            latex_code = re.sub(fr'{special_str[0]}', fr'{special_str[1]}', latex_code)
+
+        return latex_code
+
+    def convert_latex_to_html(latex_content, cache_dir='./temp'):
+        if not os.path.exists(cache_dir):
+            os.makedirs(cache_dir)
+
+        uuid_str = str(uuid.uuid1())
+        with open(f'{cache_dir}/{uuid_str}.tex', 'w') as f:
+            f.write(latex_template(latex_content))
+
+        cmd = ['latexmlc', '--quiet', '--nocomments', f'--log={cache_dir}/{uuid_str}.log',
+               f'{cache_dir}/{uuid_str}.tex', f'--dest={cache_dir}/{uuid_str}.html']
+        try:
+            subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            with open(f'{cache_dir}/{uuid_str}.html', 'r') as f:
+                html_content = f.read()
+
+            pattern = r'<table\b[^>]*>(.*)</table>'
+            tables = re.findall(pattern, html_content, re.DOTALL | re.IGNORECASE)
+            tables = [f'<table>{table}</table>' for table in tables]
+            html_content = '\n'.join(tables)
+
+        except Exception as e:
+            html_content = ''
+
+        shutil.rmtree(cache_dir)
+        return html_content
+
+    html_text = convert_latex_to_html(text)
+    normlized_tables = normalized_html_table(html_text)
+    return normlized_tables
+
+
+def normalized_table(text, format='html'):
+    if format not in ['html', 'latex']:
+        raise ValueError('Invalid format: {}'.format(format))
+    else:
+        return globals()['normalized_{}_table'.format(format)](text)
+
+
+def textblock_with_norm_formula(text):
+    inline_matches = inline_reg.finditer(text)
+    removal_positions = []
+    for match in inline_matches:
+        position = [match.start(), match.end()]
+        content = match.group(1) if match.group(1) is not None else match.group(2)
+        # print('-------- content-------', content)
+
+        norm_content = normalized_formula(content)
+        removal_positions.append((position[0], position[1], norm_content))
+
+    # Remove inline formulas from original text
+    for start, end, norm_content in sorted(removal_positions, reverse=True):
+        text = text[:start] + norm_content.strip() + text[end:]
+
+    return text
+
+# def inline_filter_unicode(text):
+#     # Ensure text is string type
+#     if not isinstance(text, str):
+#         text = str(text)
+
+#     # Convert LaTeX content to Unicode representation
+#     text = LatexNodes2Text().latex_to_text(text)
+
+#     inline_array = []
+#     inline_matches = inline_reg.finditer(text)
+
+#     for match in inline_matches:
+#         position = [match.start(), match.end()]
+#         content = match.group(1) if match.group(1) is not None else match.group(2)
+
+#         # Remove escape characters \
+#         clean_content = re.sub(r'\\([\\_&%^])', '', content)
+
+#         if any(char in clean_content for char in r'\^_'):
+#             # inline_array.append(match.group(0))
+#             inline_array.append({
+#                 'category_type': 'equation_inline',
+#                 'position': position,
+#                 'content': match.group(0),
+#             })
+#             text = text.replace(match.group(0), '')
+#             # print('-----Found inline formula: ', match.group(0))
+#         else:
+#             text = text.replace(match.group(0), content)
+#         # # Add to inline_array
+#         # inline_array.append({
+#         #     'category_type': 'equation_inline',
+#         #     'position': position,
+#         #     'content': content,
+#         # })
+
+#         # # Remove matched formula from original text, can choose to replace with spaces or remove directly
+#         # text = text[:position[0]] + ' '*(position[1]-position[0]) + text[position[1]:]
+
+#     return text, inline_array
+
+def inline_filter_unicode(text):
+    # Ensure text is string type
+    if not isinstance(text, str):
+        text = str(text)
+
+    # Replace inline formula boundary markers
+    #print('--------text-------',text)
+    placeholder = '__INLINE_FORMULA_BOUNDARY__'
+    text_copy = text.replace('$', placeholder).replace('\\(', placeholder).replace('\\)', placeholder)
+    #print('--------text_copy-------',text_copy)
+    # Convert LaTeX content to Unicode representation
+    text_copy = LatexNodes2Text().latex_to_text(text_copy)
+    #print('--------text_copy---unicode----',text_copy)
+    # Restore boundary markers
+    text_copy = text_copy.replace(placeholder, '$')
+
+    inline_array = []
+    inline_matches = inline_reg.finditer(text_copy)
+    # Record positions of inline formulas to be removed
+    removal_positions = []
+
+    for match in inline_matches:
+        position = [match.start(), match.end()]
+        content = match.group(1) if match.group(1) is not None else match.group(2)
+        print('-------- content-------', content)
+        # Remove escape characters \
+        clean_content = re.sub(r'\\([\\_&%^])', '', content)
+
+        if any(char in clean_content for char in r'\^_'):
+            # inline_array.append(match.group(0))
+            inline_array.append({
+                'category_type': 'equation_inline',
+                'position': position,
+                'content': content,
+            })
+            removal_positions.append((position[0], position[1]))
+
+    # Remove inline formulas from original text
+    for start, end in sorted(removal_positions, reverse=True):
+        text = text[:start] + text[end:]
+
+    return text, inline_array
+
+def inline_filter(text):
+    # Ensure text is string type
+    if not isinstance(text, str):
+        text = str(text)
+
+    inline_array = []
+    inline_matches = inline_reg.finditer(text)
+
+    for match in inline_matches:
+        position = [match.start(), match.end()]
+        content = match.group(1) if match.group(1) is not None else match.group(2)
+        # print('inline_content: ', content)
+
+        # Remove escape characters \
+        clean_content = re.sub(r'\\([\\_&%^])', '', content)
+
+        if any(char in clean_content for char in r'\^_'):
+            # inline_array.append(match.group(0))
+            inline_array.append({
+                'category_type': 'equation_inline',
+                'position': position,
+                'content': match.group(0),
+            })
+            text = text.replace(match.group(0), '')
+            # print('-----Found inline formula: ', match.group(0))
+        else:
+            text = text.replace(match.group(0), content)
+
+    return text, inline_array
+
+# Text OCR quality check processing:
+def clean_string(input_string):
+    # Use regex to keep Chinese characters, English letters and numbers
+    input_string = input_string.replace('\\t', '').replace('\\n', '').replace('\t', '').replace('\n', '').replace('/t', '').replace('/n', '')
+    cleaned_string = re.sub(r'[^\w\u4e00-\u9fff]', '', input_string)
+    return cleaned_string

VLMEvalKit-sudoku/vlmeval/dataset/OmniDocBench/requirements.txt

@@ -0,0 +1,13 @@
+accelerate>=0.26.0
+apted
+BeautifulSoup4
+evaluate
+func_timeout
+jmespath
+Levenshtein
+lxml
+nltk
+pylatexenc
+qwen_vl_utils
+scipy
+torchvision

VLMEvalKit-sudoku/vlmeval/dataset/OmniDocBench/utils.py

@@ -0,0 +1,1916 @@
+import re
+import unicodedata
+import subprocess
+import shutil
+import uuid
+import html
+import os
+import sys
+import pdb
+import json
+import copy
+import unicodedata
+
+import Levenshtein
+import numpy as np
+from bs4 import BeautifulSoup
+from pylatexenc.latex2text import LatexNodes2Text
+from scipy.optimize import linear_sum_assignment
+from pylatexenc.latexencode import unicode_to_latex
+from pylatexenc.latex2text import LatexNodes2Text
+from pylatexenc.latexwalker import LatexWalker, LatexEnvironmentNode, LatexCharsNode, LatexGroupNode, LatexMacroNode, LatexSpecialsNode
+from collections import defaultdict
+
+
+def read_md_file(filepath):
+    with open(filepath, 'r', encoding='utf-8') as file:
+        content = file.read()
+
+    return content
+
+def save_paired_result(preds, gts, save_path):
+    save_result = []
+    formula_id = 0
+    for gt, pred in zip(gts, preds):
+        save_result.append({
+            "gt": gt,
+            "pred": pred,
+            "img_id": formula_id
+        })
+        formula_id += 1
+    with open(save_path, 'w', encoding='utf-8') as f:
+        json.dump(save_result, f, indent=4, ensure_ascii=False)
+
+def remove_markdown_fences(content):
+    content = re.sub(r'^```markdown\n?', '', content, flags=re.MULTILINE)
+    content = re.sub(r'```\n?$', '', content, flags=re.MULTILINE)
+    return content
+
+# Standardize all consecutive characters
+def replace_repeated_chars(input_str):
+    input_str = re.sub(r'_{4,}', '____', input_str) # Replace more than 4 consecutive underscores with 4 underscores
+    input_str = re.sub(r' {4,}', '    ', input_str)   # Replace more than 4 consecutive spaces with 4 spaces
+    return re.sub(r'([^a-zA-Z0-9])\1{10,}', r'\1\1\1\1', input_str) # For other consecutive symbols (except numbers and letters), replace more than 10 occurrences with 4
+
+# Special Unicode handling
+def fullwidth_to_halfwidth(s):
+    result = []
+    for char in s:
+        code = ord(char)
+        # Convert full-width space to half-width space
+        if code == 0x3000:
+            code = 0x0020
+        # Convert other full-width characters to half-width
+        elif 0xFF01 <= code <= 0xFF5E:
+            code -= 0xFEE0
+        result.append(chr(code))
+    return ''.join(result)
+
+def find_special_unicode(s):
+    special_chars = {}
+    for char in s:
+        if ord(char) > 127:  # Non-ASCII characters
+            # unicode_name = unicodedata.name(char, None)
+            unicode_name = unicodedata.category(char)
+            special_chars[char] = f'U+{ord(char):04X} ({unicode_name})'
+    return special_chars
+
+
+inline_reg = re.compile(
+    r'\$(.*?)\$|'
+    r'\\\((.*?)\\\)',
+)
+
+def textblock2unicode(text):
+    inline_matches = inline_reg.finditer(text)
+    removal_positions = []
+    for match in inline_matches:
+        position = [match.start(), match.end()]
+        content = match.group(1) if match.group(1) is not None else match.group(2)
+        # print('-------- content-------', content)
+        # Remove escape characters \
+        clean_content = re.sub(r'\\([\\_&%^])', '', content)
+
+        try:
+            if any(char in clean_content for char in r'\^_'):
+                if clean_content.endswith('\\'):
+                    clean_content += ' '
+                # inline_array.append(match.group(0))
+                unicode_content = LatexNodes2Text().latex_to_text(clean_content)
+                removal_positions.append((position[0], position[1], unicode_content))
+        except:
+            continue
+
+    # Remove inline formulas from original text
+    for start, end, unicode_content in sorted(removal_positions, reverse=True):
+        text = text[:start] + unicode_content.strip() + text[end:]
+
+    return text
+
+def normalized_formula(text):
+    # Normalize math formulas before matching
+    filter_list = ['\\mathbf', '\\mathrm', '\\mathnormal', '\\mathit', '\\mathbb', '\\mathcal', '\\mathscr', '\\mathfrak', '\\mathsf', '\\mathtt',
+                   '\\textbf', '\\text', '\\boldmath', '\\boldsymbol', '\\operatorname', '\\bm',
+                   '\\symbfit', '\\mathbfcal', '\\symbf', '\\scriptscriptstyle', '\\notag',
+                   '\\setlength', '\\coloneqq', '\\space', '\\thickspace', '\\thinspace', '\\medspace', '\\nobreakspace', '\\negmedspace',
+                   '\\quad', '\\qquad', '\\enspace', '\\substackw', ' ']
+                #    '\\left', '\\right', '{', '}', ' ']
+
+    # delimiter_filter
+    pattern = re.compile(r"\\\[(.+?)(?<!\\)\\\]")
+    match = pattern.search(text)
+
+    if match:
+        text = match.group(1).strip()
+
+    tag_pattern = re.compile(r"\\tag\{.*?\}")
+    text = tag_pattern.sub('', text)
+    hspace_pattern = re.compile(r"\\hspace\{.*?\}")
+    text = hspace_pattern.sub('', text)
+    begin_pattern = re.compile(r"\\begin\{.*?\}")
+    text = begin_pattern.sub('', text)
+    end_pattern = re.compile(r"\\end\{.*?\}")
+    text = end_pattern.sub('', text)
+    col_sep = re.compile(r"\\arraycolsep.*?\}")
+    text = col_sep.sub('', text)
+    text = text.strip('.')
+
+    for filter_text in filter_list:
+        text = text.replace(filter_text, '')
+
+    # text = normalize_text(delimiter_filter(text))
+    # text = delimiter_filter(text)
+    text = text.lower()
+    return text
+
+def normalized_html_table(text):
+    def process_table_html(md_i):
+        """
+        pred_md format edit
+        """
+        def process_table_html(html_content):
+            soup = BeautifulSoup(html_content, 'html.parser')
+            th_tags = soup.find_all('th')
+            for th in th_tags:
+                th.name = 'td'
+            thead_tags = soup.find_all('thead')
+            for thead in thead_tags:
+                thead.unwrap()  # unwrap()会移除标签但保留其内容
+            math_tags = soup.find_all('math')
+            for math_tag in math_tags:
+                alttext = math_tag.get('alttext', '')
+                alttext = f'${alttext}$'
+                if alttext:
+                    math_tag.replace_with(alttext)
+            span_tags = soup.find_all('span')
+            for span in span_tags:
+                span.unwrap()
+            return str(soup)
+
+        table_res=''
+        table_res_no_space=''
+        if '<table' in md_i.replace(" ","").replace("'",'"'):
+            md_i = process_table_html(md_i)
+            table_res = html.unescape(md_i).replace('\n', '')
+            table_res = unicodedata.normalize('NFKC', table_res).strip()
+            pattern = r'<table\b[^>]*>(.*)</table>'
+            tables = re.findall(pattern, table_res, re.DOTALL | re.IGNORECASE)
+            table_res = ''.join(tables)
+            # table_res = re.sub('<table.*?>','',table_res)
+            table_res = re.sub('( style=".*?")', "", table_res)
+            table_res = re.sub('( height=".*?")', "", table_res)
+            table_res = re.sub('( width=".*?")', "", table_res)
+            table_res = re.sub('( align=".*?")', "", table_res)
+            table_res = re.sub('( class=".*?")', "", table_res)
+            table_res = re.sub('</?tbody>',"",table_res)
+
+            table_res = re.sub(r'\s+', " ", table_res)
+            table_res_no_space = '<html><body><table border="1" >' + table_res.replace(' ','') + '</table></body></html>'
+            # table_res_no_space = re.sub(' (style=".*?")',"",table_res_no_space)
+            # table_res_no_space = re.sub(r'[ ]', " ", table_res_no_space)
+            table_res_no_space = re.sub('colspan="', ' colspan="', table_res_no_space)
+            table_res_no_space = re.sub('rowspan="', ' rowspan="', table_res_no_space)
+            table_res_no_space = re.sub('border="', ' border="', table_res_no_space)
+
+            table_res = '<html><body><table border="1" >' + table_res + '</table></body></html>'
+            # table_flow.append(table_res)
+            # table_flow_no_space.append(table_res_no_space)
+
+        return table_res, table_res_no_space
+
+    def clean_table(input_str,flag=True):
+        if flag:
+            input_str = input_str.replace('<sup>', '').replace('</sup>', '')
+            input_str = input_str.replace('<sub>', '').replace('</sub>', '')
+            input_str = input_str.replace('<span>', '').replace('</span>', '')
+            input_str = input_str.replace('<div>', '').replace('</div>', '')
+            input_str = input_str.replace('<p>', '').replace('</p>', '')
+            input_str = input_str.replace('<spandata-span-identity="">', '')
+            input_str = re.sub('<colgroup>.*?</colgroup>','',input_str)
+        return input_str
+
+    norm_text, _ = process_table_html(text)
+    norm_text = clean_table(norm_text)
+    return norm_text
+
+def normalized_latex_table(text):
+    def latex_template(latex_code):
+        template = r'''
+        \documentclass[border=20pt]{article}
+        \usepackage{subcaption}
+        \usepackage{url}
+        \usepackage{graphicx}
+        \usepackage{caption}
+        \usepackage{multirow}
+        \usepackage{booktabs}
+        \usepackage{color}
+        \usepackage{colortbl}
+        \usepackage{xcolor,soul,framed}
+        \usepackage{fontspec}
+        \usepackage{amsmath,amssymb,mathtools,bm,mathrsfs,textcomp}
+        \setlength{\parindent}{0pt}''' + \
+        r'''
+        \begin{document}
+        ''' + \
+        latex_code + \
+        r'''
+        \end{document}'''
+
+        return template
+
+    def process_table_latex(latex_code):
+        SPECIAL_STRINGS= [
+            ['\\\\vspace\\{.*?\\}', ''],
+            ['\\\\hspace\\{.*?\\}', ''],
+            ['\\\\rule\{.*?\\}\\{.*?\\}', ''],
+            ['\\\\addlinespace\\[.*?\\]', ''],
+            ['\\\\addlinespace', ''],
+            ['\\\\renewcommand\\{\\\\arraystretch\\}\\{.*?\\}', ''],
+            ['\\\\arraystretch\\{.*?\\}', ''],
+            ['\\\\(row|column)?colors?\\{[^}]*\\}(\\{[^}]*\\}){0,2}', ''],
+            ['\\\\color\\{.*?\\}', ''],
+            ['\\\\textcolor\\{.*?\\}', ''],
+            ['\\\\rowcolor(\\[.*?\\])?\\{.*?\\}', ''],
+            ['\\\\columncolor(\\[.*?\\])?\\{.*?\\}', ''],
+            ['\\\\cellcolor(\\[.*?\\])?\\{.*?\\}', ''],
+            ['\\\\colorbox\\{.*?\\}', ''],
+            ['\\\\(tiny|scriptsize|footnotesize|small|normalsize|large|Large|LARGE|huge|Huge)', ''],
+            [r'\s+', ' '],
+            ['\\\\centering', ''],
+            ['\\\\begin\\{table\\}\\[.*?\\]', '\\\\begin{table}'],
+            ['\t', ''],
+            ['@{}', ''],
+            ['\\\\toprule(\\[.*?\\])?', '\\\\hline'],
+            ['\\\\bottomrule(\\[.*?\\])?', '\\\\hline'],
+            ['\\\\midrule(\\[.*?\\])?', '\\\\hline'],
+            ['p\\{[^}]*\\}', 'l'],
+            ['m\\{[^}]*\\}', 'c'],
+            ['\\\\scalebox\\{[^}]*\\}\\{([^}]*)\\}', '\\1'],
+            ['\\\\textbf\\{([^}]*)\\}', '\\1'],
+            ['\\\\textit\\{([^}]*)\\}', '\\1'],
+            ['\\\\cmidrule(\\[.*?\\])?\\(.*?\\)\\{([0-9]-[0-9])\\}', '\\\\cline{\\2}'],
+            ['\\\\hline', ''],
+            [r'\\multicolumn\{1\}\{[^}]*\}\{((?:[^{}]|(?:\{[^{}]*\}))*)\}', r'\1']
+        ]
+        pattern = r'\\begin\{tabular\}.*\\end\{tabular\}'  # 注意这里不用 .*?
+        matches = re.findall(pattern, latex_code, re.DOTALL)
+        latex_code = ' '.join(matches)
+
+        for special_str in SPECIAL_STRINGS:
+            latex_code = re.sub(fr'{special_str[0]}', fr'{special_str[1]}', latex_code)
+
+        return latex_code
+
+    def convert_latex_to_html(latex_content, cache_dir='./temp'):
+        if not os.path.exists(cache_dir):
+            os.makedirs(cache_dir)
+
+        uuid_str = str(uuid.uuid1())
+        with open(f'{cache_dir}/{uuid_str}.tex', 'w') as f:
+            f.write(latex_template(latex_content))
+
+        cmd = ['latexmlc', '--quiet', '--nocomments', f'--log={cache_dir}/{uuid_str}.log',
+               f'{cache_dir}/{uuid_str}.tex', f'--dest={cache_dir}/{uuid_str}.html']
+        try:
+            subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            with open(f'{cache_dir}/{uuid_str}.html', 'r') as f:
+                html_content = f.read()
+
+            pattern = r'<table\b[^>]*>(.*)</table>'
+            tables = re.findall(pattern, html_content, re.DOTALL | re.IGNORECASE)
+            tables = [f'<table>{table}</table>' for table in tables]
+            html_content = '\n'.join(tables)
+
+        except Exception as e:
+            html_content = ''
+
+        shutil.rmtree(cache_dir)
+        return html_content
+
+    html_text = convert_latex_to_html(text)
+    normlized_tables = normalized_html_table(html_text)
+    return normlized_tables
+
+
+def normalized_table(text, format='html'):
+    if format not in ['html', 'latex']:
+        raise ValueError('Invalid format: {}'.format(format))
+    else:
+        return globals()['normalized_{}_table'.format(format)](text)
+
+
+def textblock_with_norm_formula(text):
+    inline_matches = inline_reg.finditer(text)
+    removal_positions = []
+    for match in inline_matches:
+        position = [match.start(), match.end()]
+        content = match.group(1) if match.group(1) is not None else match.group(2)
+        # print('-------- content-------', content)
+
+        norm_content = normalized_formula(content)
+        removal_positions.append((position[0], position[1], norm_content))
+
+    # Remove inline formulas from original text
+    for start, end, norm_content in sorted(removal_positions, reverse=True):
+        text = text[:start] + norm_content.strip() + text[end:]
+
+    return text
+
+
+def inline_filter_unicode(text):
+    # Ensure text is string type
+    if not isinstance(text, str):
+        text = str(text)
+
+    # Replace inline formula boundary markers
+    #print('--------text-------',text)
+    placeholder = '__INLINE_FORMULA_BOUNDARY__'
+    text_copy = text.replace('$', placeholder).replace('\\(', placeholder).replace('\\)', placeholder)
+    #print('--------text_copy-------',text_copy)
+    # Convert LaTeX content to Unicode representation
+    text_copy = LatexNodes2Text().latex_to_text(text_copy)
+    #print('--------text_copy---unicode----',text_copy)
+    # Restore boundary markers
+    text_copy = text_copy.replace(placeholder, '$')
+
+    inline_array = []
+    inline_matches = inline_reg.finditer(text_copy)
+    # Record positions of inline formulas to be removed
+    removal_positions = []
+
+    for match in inline_matches:
+        position = [match.start(), match.end()]
+        content = match.group(1) if match.group(1) is not None else match.group(2)
+        print('-------- content-------', content)
+        # Remove escape characters \
+        clean_content = re.sub(r'\\([\\_&%^])', '', content)
+
+        if any(char in clean_content for char in r'\^_'):
+            # inline_array.append(match.group(0))
+            inline_array.append({
+                'category_type': 'equation_inline',
+                'position': position,
+                'content': content,
+            })
+            removal_positions.append((position[0], position[1]))
+
+    # Remove inline formulas from original text
+    for start, end in sorted(removal_positions, reverse=True):
+        text = text[:start] + text[end:]
+
+    return text, inline_array
+
+def inline_filter(text):
+    # Ensure text is string type
+    if not isinstance(text, str):
+        text = str(text)
+
+    inline_array = []
+    inline_matches = inline_reg.finditer(text)
+
+    for match in inline_matches:
+        position = [match.start(), match.end()]
+        content = match.group(1) if match.group(1) is not None else match.group(2)
+        # print('inline_content: ', content)
+
+        # Remove escape characters \
+        clean_content = re.sub(r'\\([\\_&%^])', '', content)
+
+        if any(char in clean_content for char in r'\^_'):
+            # inline_array.append(match.group(0))
+            inline_array.append({
+                'category_type': 'equation_inline',
+                'position': position,
+                'content': match.group(0),
+            })
+            text = text.replace(match.group(0), '')
+            # print('-----Found inline formula: ', match.group(0))
+        else:
+            text = text.replace(match.group(0), content)
+
+    return text, inline_array
+
+# Text OCR quality check processing:
+def clean_string(input_string):
+    # Use regex to keep Chinese characters, English letters and numbers
+    input_string = input_string.replace('\\t', '').replace('\\n', '').replace('\t', '').replace('\n', '').replace('/t', '').replace('/n', '')
+    cleaned_string = re.sub(r'[^\w\u4e00-\u9fff]', '', input_string)
+    return cleaned_string
+
+def extract_tabular(text):
+    begin_pattern = r'\\begin{tabular}'
+    end_pattern = r'\\end{tabular}'
+
+    tabulars = []
+    positions = []
+    current_pos = 0
+    stack = []
+
+    while current_pos < len(text):
+        begin_match = re.search(begin_pattern, text[current_pos:])
+        end_match = re.search(end_pattern, text[current_pos:])
+
+        if not begin_match and not end_match:
+            break
+
+        if begin_match and (not end_match or begin_match.start() < end_match.start()):
+            stack.append(current_pos + begin_match.start())
+            current_pos += begin_match.start() + len(end_pattern)
+        elif end_match:
+            if stack:
+                start_pos = stack.pop()
+                if not stack:
+                    end_pos = current_pos + end_match.start() + len(end_pattern)
+                    tabular_code = text[start_pos:end_pos]
+                    tabulars.append(tabular_code)
+                    positions.append((start_pos, end_pos))
+            current_pos += end_match.start() + len(end_pattern)
+        else:
+            current_pos += 1
+
+    if stack:
+        new_start = stack[0] + len(begin_pattern)
+        new_tabulars, new_positions = extract_tabular(text[new_start:])
+        new_positions = [(start + new_start, end + new_start) for start, end in new_positions]
+        tabulars.extend(new_tabulars)
+        positions.extend(new_positions)
+
+    return tabulars, positions
+
+# math reg
+    # r'\\begin{equation\*?}(.*?)\\end{equation\*?}|'
+    # r'\\begin{align\*?}(.*?)\\end{align\*?}|'
+    # r'\\begin{gather\*?}(.*?)\\end{gather\*?}|'
+display_reg = re.compile(
+    r'\$\$(.*?)\$\$|'
+    r'\\\[(.*?)\\\]|'
+    r'\$(.*?)\$|'
+    r'\\\((.*?)\\\)',
+    re.DOTALL
+)
+
+# inline_reg = re.compile(
+#     r'(?<!\$)\$(?!\$)(.*?)(?<!\$)\$(?!\$)|'
+#     r'\\\((.*?)\\\)',
+# )
+inline_reg = re.compile(
+    r'\$(.*?)\$|'
+    r'\\\((.*?)\\\)',
+)
+
+# table
+table_reg = re.compile(
+    r'\\begin{table\*?}(.*?)\\end{table\*?}|'
+    r'\\begin{tabular\*?}(.*?)\\end{tabular\*?}',
+    re.DOTALL
+)
+md_table_reg = re.compile(
+    r'\|\s*.*?\s*\|\n',
+    re.DOTALL)
+html_table_reg = re.compile(
+    r'(<table.*?</table>)',
+    re.DOTALL
+)
+
+# title
+title_reg = re.compile(
+    r'^\s*#.*$',
+    re.MULTILINE)
+
+# img
+img_pattern = r'!\[.*?\]\(.*?\)'
+
+# code block
+code_block_reg = re.compile(
+    r'```(\w+)\n(.*?)```',
+    re.DOTALL
+)
+
+
+def md_tex_filter(content):
+    '''
+    Input: 1 page md or tex content - String
+    Output: text, display, inline, table, title, code - list
+    '''
+    content = re.sub(img_pattern, '', content)  # remove image
+    content = remove_markdown_fences(content)   # remove markdown fences
+    content = replace_repeated_chars(content) # replace all consecutive characters
+
+
+
+    pred_all = []
+    latex_table_array, table_positions = extract_tex_table(content)
+    for latex_table, position in zip(latex_table_array, table_positions):
+        position = [position[0], position[0]+len(latex_table)]   # !!!
+        pred_all.append({
+            'category_type': 'latex_table',
+            'position': position,
+            'content': latex_table
+        })
+        content = content[:position[0]] + ' '*(position[1]-position[0]) + content[position[1]:]  # replace latex table with space
+
+
+    # extract html table
+    html_table_array, table_positions = extract_html_table(content)
+    for html_table, position in zip(html_table_array, table_positions):
+        position = [position[0], position[0]+len(html_table)]
+        pred_all.append({
+            'category_type': 'html_table',
+            'position': position,
+            'content': html_table
+        })
+        content = content[:position[0]] + ' '*(position[1]-position[0]) + content[position[1]:]  # replace html table with space
+
+    # extract interline formula
+    display_matches = display_reg.finditer(content)
+    for match in display_matches:
+        matched = match.group(0)
+        if matched:
+            single_line = ''.join(matched.split())
+            position = [match.start(), match.end()]
+            # replace $$ with \[\]
+            dollar_pattern = re.compile(r'\$\$(.*?)\$\$|\$(.*?)\$|\\\((.*?)\\\)', re.DOTALL)
+            sub_match = dollar_pattern.search(single_line)
+            if sub_match is None:
+                # pass
+                content = content[:position[0]] + ' '*(position[1]-position[0]) + content[position[1]:]
+                pred_all.append({
+                    'category_type': 'equation_isolated',
+                    'position': position,
+                    'content': single_line
+                })
+            elif sub_match.group(1):
+                single_line = re.sub(dollar_pattern, r'\\[\1\\]', single_line)
+                content = content[:position[0]] + ' '*(position[1]-position[0]) + content[position[1]:]  # replace equation with space
+                pred_all.append({
+                    'category_type': 'equation_isolated',
+                    'position': position,
+                    'content': single_line
+                })
+            else:
+                single_line = re.sub(dollar_pattern, r'\\[\2\3\\]', single_line)
+                pred_all.append({
+                    'category_type': 'equation_isolated',
+                    'position': position,
+                    'content': single_line,
+                    'fine_category_type': 'equation_inline'
+                })
+
+
+    # extract md table with ||
+    md_table_mathces = md_table_reg.findall(content+'\n')
+    if len(md_table_mathces) >= 2:
+        # print("md table found!")
+        # print("content:", content)
+        content = convert_markdown_to_html(content)
+        # print('----------content after converting md table to html:', content)
+        html_table_matches = html_table_reg.finditer(content)
+        if html_table_matches:
+            for match in html_table_matches:
+                matched = match.group(0)
+                position = [match.start(), match.end()]
+                # content = content.replace(match, '')
+                # print('content after removing the md table:', content)
+                content = content[:position[0]] + ' '*(position[1]-position[0]) + content[position[1]:]  # replace md table with space
+                pred_all.append({
+                    'category_type': 'html_table',
+                    'position': position,
+                    'content': matched.strip(),
+                    'fine_category_type': 'md2html_table'
+                })
+    # print('---------After md table: \n', content)
+
+    # extract code blocks
+    code_matches = code_block_reg.finditer(content)
+    if code_matches:
+        for match in code_matches:
+            position = [match.start(), match.end()]
+            language = match.group(1)
+            code = match.group(2).strip()
+            # content = content.replace(match.group(0), '')
+            content = content[:position[0]] + ' '*(position[1]-position[0]) + content[position[1]:]  # replace code block with space
+            pred_all.append({
+                'category_type': 'text_all',
+                'position': position,
+                'content': code,
+                'language': language,
+                'fine_category_type': 'code'
+            })
+
+
+    # Remove latex style
+    content = re.sub(r'\\title\{(.*?)\}', r'\1', content)
+    content = re.sub(r'\\title\s*\{\s*(.*?)\s*\}', r'\1', content, flags=re.DOTALL)
+    content = re.sub(r'\\text\s*\{\s*(.*?)\s*\}', r'\1', content, flags=re.DOTALL)
+    content = re.sub(r'\\section\*?\{(.*?)\}', r'\1', content)
+    content = re.sub(r'\\section\*?\{\s*(.*?)\s*\}', r'\1', content, flags=re.DOTALL)
+
+    # extract texts
+    res = content.split('\n\n')
+    if len(res) == 1:
+        res = content.split('\n')  # some models do not use double newlines, so use single newlines to split
+
+    content_position = 0
+    for text in res:
+        position = [content_position, content_position+len(text)]
+        content_position += len(text)
+        text = text.strip()
+        text = text.strip('\n')
+        # print('ori_text: ', text)
+        text = '\n'.join([_.strip() for _ in text.split('\n') if _.strip()])   # avoid some single newline content with many spaces
+        # print('after strip text: ', text)
+
+        if text:  # Check if the stripped text is not empty
+            if text.startswith('<table') and text.endswith('</table>'):
+                pred_all.append({
+                    'category_type': 'html_table',
+                    'position': position,
+                    'content': text,
+                })
+
+            elif text.startswith('$') and text.endswith('$'):
+                if text.replace('$', '').strip():
+                    pred_all.append({
+                        'category_type': 'equation_isolated',
+                        'position': position,
+                        'content': text.strip(),
+                    })
+            else:
+                text = text.strip()
+                if text:
+                    pred_all.append({
+                        'category_type': 'text_all',
+                        'position': position,
+                        'content': text,
+                        'fine_category_type': 'text_block'
+                    })
+
+    pred_dataset = defaultdict(list)
+    pred_all = sorted(pred_all, key=lambda x: x['position'][0])
+    for item in pred_all:
+        pred_dataset[item['category_type']].append(item)
+    # pdb.set_trace()
+    return pred_dataset
+
+
+def extract_tex_table(content):
+    tables = []
+    tables_positions = []
+
+    pattern = r'\\begin{table}(.*?)\\end{table}'
+    for match in re.finditer(pattern, content, re.DOTALL):
+        start_pos = match.start()
+        end_pos = match.end()
+        table_content = match.group(0)
+        tables.append(table_content)
+        tables_positions.append((start_pos, end_pos))
+        content = content[:start_pos] + ' '*(end_pos-start_pos) + content[end_pos:]
+
+    tabulars, tabular_positions = extract_tabular(content)
+    all_tables = tables + tabulars
+    all_positions = tables_positions + tabular_positions
+
+    all_result = sorted([[pos, table]for pos, table in zip(all_positions, all_tables)], key=lambda x: x[0][0])
+    all_tables = [x[1] for x in all_result]
+    all_positions = [x[0] for x in all_result]
+
+    return all_tables, all_positions
+
+
+def extract_html_table(text):
+    begin_pattern = r'<table(?:[^>]*)>'
+    end_pattern = r'</table>'
+
+    tabulars = []
+    positions = []
+    current_pos = 0
+    stack = []
+
+    while current_pos < len(text):
+        begin_match = re.search(begin_pattern, text[current_pos:])
+        end_match = re.search(end_pattern, text[current_pos:])
+
+        if not begin_match and not end_match:
+            break
+
+        if begin_match and (not end_match or begin_match.start() < end_match.start()):
+            stack.append(current_pos + begin_match.start())
+            current_pos += begin_match.start() + len(end_pattern)
+        elif end_match:
+            if stack:
+                start_pos = stack.pop()
+                if not stack:
+                    end_pos = current_pos + end_match.start() + len(end_pattern)
+                    tabular_code = text[start_pos:end_pos]
+                    tabulars.append(tabular_code)
+                    positions.append((start_pos, end_pos))
+            current_pos += end_match.start() + len(end_pattern)
+        else:
+            current_pos += 1
+
+    if stack:
+        new_start = stack[0] + len(begin_pattern)
+        new_tabulars, new_positions = extract_html_table(text[new_start:])
+        new_positions = [(start + new_start, end + new_start) for start, end in new_positions]
+        tabulars.extend(new_tabulars)
+        positions.extend(new_positions)
+
+    return tabulars, positions
+
+
+def extract_node_content(node):
+    """ Recursively extract content from LatexEnvironmentNode and rebuild LaTeX table representation """
+    if isinstance(node, LatexCharsNode):
+        return node.chars  # Use chars attribute
+    elif isinstance(node, LatexGroupNode):
+        return "{" + "".join(extract_node_content(n) for n in node.nodelist) + "}"
+    elif isinstance(node, LatexMacroNode):
+        # Extract macro command and its arguments
+        macro_content = "\\" + node.macroname
+        if node.nodeargs:
+            macro_content += "".join([extract_node_content(arg) for arg in node.nodeargs])
+        return macro_content
+    elif isinstance(node, LatexEnvironmentNode):
+        # Extract environment, preserve environment name and arguments
+        content = "\\begin{" + node.environmentname + "}"
+        if node.nodeargd and node.nodeargd.argnlist:
+            # content += "".join("{" + extract_node_content(arg) + "}" for arg in node.nodeargd)
+            # content += "".join("{" + extract_node_content(node.nodeargd) + "}")
+            content += "{" + extract_node_content(node.nodeargd.argnlist[0]) + "}"
+        if node.nodelist:
+            content += "".join(extract_node_content(n) for n in node.nodelist)
+        content += "\\end{" + node.environmentname + "}"
+        return content
+    elif isinstance(node, LatexSpecialsNode):  # Changed to LatexSpecialsNode
+        return node.specials_chars
+    else:
+        return ""
+
+def get_node_end_pos(node):
+    """Recursively determine the end position of a node"""
+    if hasattr(node, 'nodelist') and node.nodelist:
+        # If the node has child nodes, recursively find the end position of the last child node
+        return get_node_end_pos(node.nodelist[-1])
+    elif hasattr(node, 'pos_end'):
+        # If the node has pos_end attribute, return it directly
+        return node.pos_end
+    else:
+        # If there are no child nodes, assume the node ends at the last character of its content
+        return node.pos + len(str(node))
+
+def remove_tex_table(content):
+    tables, positions = extract_tex_table(content)
+
+    # Delete in reverse order by position to avoid affecting unprocessed start positions
+    for start, end in sorted(positions, reverse=True):
+        content = content[:start] + content[end:]  # Remove table content
+
+    return content
+
+
+
+def get_pred_category_type(pred_idx, pred_items):
+    # if pred_idx:
+    if pred_items[pred_idx].get('fine_category_type'):
+        pred_pred_category_type = pred_items[pred_idx]['fine_category_type']
+    else:
+        pred_pred_category_type = pred_items[pred_idx]['category_type']
+    # else:
+    #     pred_pred_category_type = ""
+    return pred_pred_category_type
+
+
+def compute_edit_distance_matrix_new(gt_lines, matched_lines):
+    try:
+        distance_matrix = np.zeros((len(gt_lines), len(matched_lines)))
+        for i, gt_line in enumerate(gt_lines):
+            for j, matched_line in enumerate(matched_lines):
+                if len(gt_line) == 0 and len(matched_line) == 0:
+                    distance_matrix[i][j] = 0
+                else:
+                    distance_matrix[i][j] = Levenshtein.distance(gt_line, matched_line) / max(len(matched_line), len(gt_line))
+        return distance_matrix
+    except ZeroDivisionError:
+        #print("ZeroDivisionError occurred. Outputting norm_gt_lines and norm_pred_lines:")
+        # print("norm_gt_lines:", gt_lines)
+        # print("norm_pred_lines:", matched_lines)
+        raise
+
+def get_gt_pred_lines(gt_items, pred_items, line_type):
+    norm_html_lines = []
+    gt_lines = []
+    gt_cat_list = []
+    for item in gt_items:
+        if item.get('fine_category_type'):
+            gt_cat_list.append(item['fine_category_type'])
+        else:
+            gt_cat_list.append(item['category_type'])
+        if item.get('content'):
+            gt_lines.append(str(item['content']))
+            norm_html_lines.append(str(item['content']))
+        elif line_type == 'text':
+            gt_lines.append(str(item['text']))
+        elif line_type == 'html_table':
+            gt_lines.append(str(item['html']))
+        elif line_type == 'formula':
+            gt_lines.append(str(item['latex']))
+        elif line_type == 'latex_table':
+            gt_lines.append(str(item['latex']))
+            norm_html_lines.append(str(item['html']))
+
+    pred_lines = [str(item['content']) for item in pred_items]
+
+
+    if line_type == 'formula':
+        norm_gt_lines = [normalized_formula(_) for _ in gt_lines]
+        norm_pred_lines = [normalized_formula(_) for _ in pred_lines]
+    elif line_type == 'text':
+        # norm_gt_lines = [textblock_with_norm_formula(_) for _ in gt_lines]
+        # norm_pred_lines = [textblock_with_norm_formula(_) for _ in pred_lines]
+        norm_gt_lines = [clean_string(textblock2unicode(_)) for _ in gt_lines]
+        norm_pred_lines = [clean_string(textblock2unicode(_)) for _ in pred_lines]
+        # norm_gt_lines = get_norm_text_lines(gt_lines)
+        # norm_pred_lines = get_norm_text_lines(pred_lines)
+    else:
+        norm_gt_lines = gt_lines
+        norm_pred_lines = pred_lines
+
+    if line_type == 'latex_table':
+        gt_lines = norm_html_lines
+
+
+    filtered_lists = [(a, b, c) for a, b, c in zip(gt_lines, norm_gt_lines, gt_cat_list) if a and b]
+
+    # decompress to three lists
+    if filtered_lists:
+        gt_lines_c, norm_gt_lines_c, gt_cat_list_c = zip(*filtered_lists)
+
+        # convert to lists
+        gt_lines_c = list(gt_lines_c)
+        norm_gt_lines_c = list(norm_gt_lines_c)
+        gt_cat_list_c = list(gt_cat_list_c)
+    else:
+        gt_lines_c = []
+        norm_gt_lines_c = []
+        gt_cat_list_c = []
+
+    # pred's empty values
+    filtered_lists = [(a, b) for a, b in zip(pred_lines, norm_pred_lines) if a and b]
+
+    # decompress to two lists
+    if filtered_lists:
+        pred_lines_c, norm_pred_lines_c = zip(*filtered_lists)
+
+        # convert to lists
+        pred_lines_c = list(pred_lines_c)
+        norm_pred_lines_c = list(norm_pred_lines_c)
+    else:
+        pred_lines_c = []
+        norm_pred_lines_c = []
+
+    return gt_lines_c, norm_gt_lines_c, gt_cat_list_c, pred_lines_c, norm_pred_lines_c
+    # return gt_lines, norm_gt_lines, gt_cat_list, pred_lines, norm_pred_lines
+
+
+def match_gt2pred_simple(gt_items, pred_items, line_type, img_name):
+
+    gt_lines, norm_gt_lines, gt_cat_list, pred_lines, norm_pred_lines = get_gt_pred_lines(gt_items, pred_items, line_type)
+
+    match_list = []
+    if not norm_gt_lines: # not matched pred should be concatenated
+        # print("One of the lists is empty. Returning an empty gt result.")
+        # for pred_idx in range(len(norm_pred_lines)):
+        pred_idx_list = range(len(norm_pred_lines))
+        match_list.append({
+            'gt_idx': [""],
+            'gt': "",
+            'pred_idx': pred_idx_list,
+            'pred': ''.join(pred_lines[_] for _ in pred_idx_list),
+            'gt_position': [""],
+            'pred_position': pred_items[pred_idx_list[0]]['position'][0],  # get the first pred's position
+            'norm_gt': "",
+            'norm_pred': ''.join(norm_pred_lines[_] for _ in pred_idx_list),
+            'gt_category_type': "",
+            'pred_category_type': get_pred_category_type(pred_idx_list[0], pred_items), # get the first pred's category
+            'gt_attribute': [{}],
+            'edit': 1,
+            'img_id': img_name
+        })
+        return match_list
+    elif not norm_pred_lines: # not matched gt should be separated
+        # print("One of the lists is empty. Returning an empty pred result.")
+        for gt_idx in range(len(norm_gt_lines)):
+            match_list.append({
+                'gt_idx': [gt_idx],
+                'gt': gt_lines[gt_idx],
+                'pred_idx': [""],
+                'pred': "",
+                'gt_position': [gt_items[gt_idx].get('order') if gt_items[gt_idx].get('order') else gt_items[gt_idx].get('position', [""])[0]],
+                'pred_position': "",
+                'norm_gt': norm_gt_lines[gt_idx],
+                'norm_pred': "",
+                'gt_category_type': gt_cat_list[gt_idx],
+                'pred_category_type': "",
+                'gt_attribute': [gt_items[gt_idx].get("attribute", {})],
+                'edit': 1,
+                'img_id': img_name
+            })
+        return match_list
+
+    cost_matrix = compute_edit_distance_matrix_new(norm_gt_lines, norm_pred_lines)
+
+    row_ind, col_ind = linear_sum_assignment(cost_matrix)
+
+
+    for gt_idx in range(len(norm_gt_lines)):
+        if gt_idx in row_ind:
+            row_i = list(row_ind).index(gt_idx)
+            pred_idx = int(col_ind[row_i])
+            pred_line = pred_lines[pred_idx]
+            norm_pred_line = norm_pred_lines[pred_idx]
+            edit = cost_matrix[gt_idx][pred_idx]
+            # print('edit_dist', edit)
+            # if edit > 0.7:
+            #     print('! Not match')
+        else:
+            # print('No match pred')
+            pred_idx = ""
+            pred_line = ""
+            norm_pred_line = ""
+            edit = 1
+
+        match_list.append({
+            'gt_idx': [gt_idx],
+            'gt': gt_lines[gt_idx],
+            'norm_gt': norm_gt_lines[gt_idx],
+            'gt_category_type': gt_cat_list[gt_idx],
+            'gt_position': [gt_items[gt_idx].get('order') if gt_items[gt_idx].get('order') else gt_items[gt_idx].get('position', [""])[0]],
+            'gt_attribute': [gt_items[gt_idx].get("attribute", {})],
+            'pred_idx': [pred_idx],
+            'pred': pred_line,
+            'norm_pred': norm_pred_line,
+            'pred_category_type': get_pred_category_type(pred_idx, pred_items) if pred_idx else "",
+            'pred_position': pred_items[pred_idx]['position'][0] if pred_idx else "",
+            'edit': edit,
+            'img_id': img_name
+        })
+        # print('-'*10)
+        # [([0,1], 0),(2, 1), (1,2)] --> [0,2,1]/[0,1,2]
+
+    pred_idx_list = [pred_idx for pred_idx in range(len(norm_pred_lines)) if pred_idx not in col_ind] # get not matched preds
+    if pred_idx_list: # if there are still remaining pred_idx, concatenate all preds
+        match_list.append({
+            'gt_idx': [""],
+            'gt': "",
+            'pred_idx': pred_idx_list,
+            'pred': ''.join(pred_lines[_] for _ in pred_idx_list),
+            'gt_position': [""],
+            'pred_position': pred_items[pred_idx_list[0]]['position'][0],  # get the first pred's position
+            'norm_gt': "",
+            'norm_pred': ''.join(norm_pred_lines[_] for _ in pred_idx_list),
+            'gt_category_type': "",
+            'pred_category_type': get_pred_category_type(pred_idx_list[0], pred_items), # get the first pred's category
+            'gt_attribute': [{}],
+            'edit': 1,
+            'img_id': img_name
+        })
+    return match_list
+
+
+def match_gt2pred_no_split(gt_items, pred_items, line_type, img_name):
+    # directly concatenate gt and pred by position
+    gt_lines, norm_gt_lines, gt_cat_list, pred_lines, norm_pred_lines = get_gt_pred_lines(gt_items, pred_items, line_type)
+    gt_line_with_position = []
+    for gt_line, norm_gt_line, gt_item in zip(gt_lines, norm_gt_lines, gt_items):
+        gt_position = gt_item['order'] if gt_item.get('order') else gt_item.get('position', [""])[0]
+        if gt_position:
+            gt_line_with_position.append((gt_position, gt_line, norm_gt_line))
+    sorted_gt_lines = sorted(gt_line_with_position, key=lambda x: x[0])
+    gt = '\n\n'.join([_[1] for _ in sorted_gt_lines])
+    norm_gt = '\n\n'.join([_[2] for _ in sorted_gt_lines])
+    pred_line_with_position = [(pred_item['position'], pred_line, pred_norm_line) for pred_line, pred_norm_line, pred_item in zip(pred_lines, norm_pred_lines, pred_items)]
+    sorted_pred_lines = sorted(pred_line_with_position, key=lambda x: x[0])
+    pred = '\n\n'.join([_[1] for _ in sorted_pred_lines])
+    norm_pred = '\n\n'.join([_[2] for _ in sorted_pred_lines])
+    # edit = Levenshtein.distance(norm_gt, norm_pred)/max(len(norm_gt), len(norm_pred))
+    if norm_gt or norm_pred:
+        return [{
+                'gt_idx': [0],
+                'gt': gt,
+                'norm_gt': norm_gt,
+                'gt_category_type': "text_merge",
+                'gt_position': [""],
+                'gt_attribute': [{}],
+                'pred_idx': [0],
+                'pred': pred,
+                'norm_pred': norm_pred,
+                'pred_category_type': "text_merge",
+                'pred_position': "",
+                # 'edit': edit,
+                'img_id': img_name
+            }]
+    else:
+        return []
+
+
+from scipy.optimize import linear_sum_assignment
+# from rapidfuzz.distance import Levenshtein
+import Levenshtein
+from collections import defaultdict
+import copy
+import pdb
+import numpy as np
+import evaluate
+from collections import Counter
+from Levenshtein import distance as Levenshtein_distance
+
+
+def match_gt2pred_quick(gt_items, pred_items, line_type, img_name):
+
+    gt_lines, norm_gt_lines, gt_cat_list, pred_lines, norm_pred_lines= get_gt_pred_lines(gt_items, pred_items, line_type)
+    all_gt_indices = set(range(len(norm_gt_lines)))
+    all_pred_indices = set(range(len(norm_pred_lines)))
+
+    if not norm_gt_lines:
+        match_list = []
+        for pred_idx in range(len(norm_pred_lines)):
+            match_list.append({
+                'gt_idx': [""],
+                'gt': "",
+                'pred_idx': [pred_idx],
+                'pred': pred_lines[pred_idx],
+                'gt_position': "",
+                'pred_position': pred_items[pred_idx]['position'][0],
+                'norm_gt': "",
+                'norm_pred': norm_pred_lines[pred_idx],
+                'gt_category_type': "",
+                'pred_category_type': get_pred_category_type(pred_idx, pred_items),
+                'gt_attribute': [{}],
+                'edit': 1,
+                'img_id': img_name
+            })
+        return match_list
+    elif not norm_pred_lines:
+        match_list = []
+        for gt_idx in range(len(norm_gt_lines)):
+            match_list.append({
+                'gt_idx': [gt_idx],
+                'gt': gt_lines[gt_idx],
+                'pred_idx': [""],
+                'pred': "",
+                'gt_position': [gt_items[gt_idx].get('order') if gt_items[gt_idx].get('order') else gt_items[gt_idx].get('position', [""])[0]],
+                'pred_position': "",
+                'norm_gt': norm_gt_lines[gt_idx],
+                'norm_pred': "",
+                'gt_category_type': gt_cat_list[gt_idx],
+                'pred_category_type': "",
+                'gt_attribute': [gt_items[gt_idx].get("attribute", {})],
+                'edit': 1,
+                'img_id': img_name
+            })
+        return match_list
+    elif len(norm_gt_lines) == 1 and len(norm_pred_lines) == 1:
+        edit_distance = Levenshtein_distance(norm_gt_lines[0], norm_pred_lines[0])
+        normalized_edit_distance = edit_distance / max(len(norm_gt_lines[0]), len(norm_pred_lines[0]))
+        return [{
+            'gt_idx': [0],
+            'gt': gt_lines[0],
+            'pred_idx': [0],
+            'pred': pred_lines[0],
+            'gt_position': [gt_items[0].get('order') if gt_items[0].get('order') else gt_items[0].get('position', [""])[0]],
+            'pred_position': pred_items[0]['position'][0],
+            'norm_gt': norm_gt_lines[0],
+            'norm_pred': norm_pred_lines[0],
+            'gt_category_type': gt_cat_list[0],
+            'pred_category_type': get_pred_category_type(0, pred_items),
+            'gt_attribute': [gt_items[0].get("attribute", {})],
+            'edit': normalized_edit_distance,
+            'img_id': img_name
+        }]
+
+    cost_matrix = compute_edit_distance_matrix_new(norm_gt_lines, norm_pred_lines)
+
+    matched_col_idx, row_ind, cost_list = cal_final_match(cost_matrix, norm_gt_lines, norm_pred_lines)
+
+    gt_lens_dict, pred_lens_dict = initialize_indices(norm_gt_lines, norm_pred_lines)
+
+    matches, unmatched_gt_indices, unmatched_pred_indices = process_matches(matched_col_idx, row_ind, cost_list, norm_gt_lines, norm_pred_lines, pred_lines)
+
+    matching_dict = fuzzy_match_unmatched_items(unmatched_gt_indices, norm_gt_lines, norm_pred_lines)
+
+    final_matches = merge_matches(matches, matching_dict)
+
+    recalculate_edit_distances(final_matches, gt_lens_dict, norm_gt_lines, norm_pred_lines)
+
+    converted_results = convert_final_matches(final_matches, norm_gt_lines, norm_pred_lines)
+
+    merged_results = merge_duplicates_add_unmatched(converted_results, norm_gt_lines, norm_pred_lines, gt_lines, pred_lines, all_gt_indices, all_pred_indices)
+
+    for entry in merged_results:
+            entry['gt_idx'] = [entry['gt_idx']] if not isinstance(entry['gt_idx'], list) else entry['gt_idx']
+            entry['pred_idx'] = [entry['pred_idx']] if not isinstance(entry['pred_idx'], list) else entry['pred_idx']
+            entry['gt_position'] = [gt_items[_].get('order') if gt_items[_].get('order') else gt_items[_].get('position', [""])[0] for _ in entry['gt_idx']] if entry['gt_idx'] != [""] else [""]
+            entry['pred_position'] = pred_items[entry['pred_idx'][0]]['position'][0] if entry['pred_idx'] != [""] else ""
+            entry['gt'] = ''.join([gt_lines[_] for _ in entry['gt_idx']]) if entry['gt_idx'] != [""] else ""
+            entry['pred'] = ''.join([pred_lines[_] for _ in entry['pred_idx']]) if entry['pred_idx'] != [""] else ""
+            entry['norm_gt'] = ''.join([norm_gt_lines[_] for _ in entry['gt_idx']]) if entry['gt_idx'] != [""] else ""
+            entry['norm_pred'] = ''.join([norm_pred_lines[_] for _ in entry['pred_idx']]) if entry['pred_idx'] != [""] else ""
+
+            if entry['gt_idx'] != [""]:
+                ignore_type = ['figure_caption', 'figure_footnote', 'table_caption', 'table_footnote', 'code_algorithm', 'code_algorithm_caption', 'header', 'footer', 'page_footnote', 'page_number', 'equation_caption']
+                gt_cagegory_clean = [gt_cat_list[_] for _ in entry['gt_idx'] if gt_cat_list[_] not in ignore_type]
+                if gt_cagegory_clean:
+                    entry['gt_category_type'] = Counter(gt_cagegory_clean).most_common(1)[0][0]
+                else:
+                    entry['gt_category_type'] = Counter([gt_cat_list[_] for _ in entry['gt_idx']]).most_common(1)[0][0]
+            else:
+                entry['gt_category_type'] = ""
+            entry['pred_category_type'] = get_pred_category_type(entry['pred_idx'][0], pred_items) if entry['pred_idx'] != [""] else ""
+            entry['gt_attribute'] = [gt_items[_].get("attribute", {}) for _ in entry['gt_idx']] if entry['gt_idx'] != [""] else [{}]
+            entry['img_id'] = img_name
+
+    return merged_results
+
+
+def merge_duplicates_add_unmatched(converted_results, norm_gt_lines, norm_pred_lines, gt_lines, pred_lines, all_gt_indices, all_pred_indices):
+    merged_results = []
+    processed_pred = set()
+    processed_gt = set()
+
+    for entry in converted_results:
+        pred_idx = tuple(entry['pred_idx']) if isinstance(entry['pred_idx'], list) else (entry['pred_idx'],)
+        if pred_idx not in processed_pred and pred_idx != ("",):
+            merged_entry = {
+                'gt_idx': [entry['gt_idx']],
+                'gt': entry['gt'],
+                'pred_idx': entry['pred_idx'],
+                'pred': entry['pred'],
+                'edit': entry['edit']
+            }
+            for other_entry in converted_results:
+                other_pred_idx = tuple(other_entry['pred_idx']) if isinstance(other_entry['pred_idx'], list) else (other_entry['pred_idx'],)
+                if other_pred_idx == pred_idx and other_entry is not entry:
+                    merged_entry['gt_idx'].append(other_entry['gt_idx'])
+                    merged_entry['gt'] += other_entry['gt']
+                    processed_gt.add(other_entry['gt_idx'])
+            merged_results.append(merged_entry)
+            processed_pred.add(pred_idx)
+            processed_gt.add(entry['gt_idx'])
+
+    for entry in converted_results:
+        if entry['gt_idx'] not in processed_gt:
+            merged_results.append(entry)
+
+    for gt_idx in range(len(norm_gt_lines)):
+        if gt_idx not in processed_gt:
+            merged_results.append({
+                'gt_idx': [gt_idx],
+                'gt': gt_lines[gt_idx],
+                'pred_idx': [""],
+                'pred': "",
+                'edit': 1
+            })
+    return merged_results
+
+
+
+
+def formula_format(formula_matches, img_name):
+    return [
+        {
+            "gt": item["gt"],
+            "pred": item["pred"],
+            "img_id": f"{img_name}_{i}"
+        }
+        for i, item in enumerate(formula_matches)
+    ]
+
+
+def merge_lists_with_sublists(main_list, sub_lists):
+    main_list_final = list(copy.deepcopy(main_list))
+    for sub_list in sub_lists:
+        pop_idx = main_list_final.index(sub_list[0])
+        for _ in sub_list:
+            main_list_final.pop(pop_idx)
+        main_list_final.insert(pop_idx, sub_list)
+    return main_list_final
+
+
+def sub_pred_fuzzy_matching(gt, pred):
+
+    min_d = float('inf')
+    # pos = -1
+
+    gt_len = len(gt)
+    pred_len = len(pred)
+
+    if gt_len >= pred_len and pred_len > 0:
+        for i in range(gt_len - pred_len + 1):
+            sub = gt[i:i + pred_len]
+            dist = Levenshtein_distance(sub, pred)/pred_len
+            if dist < min_d:
+                min_d = dist
+                pos = i
+
+        return min_d
+    else:
+        return False
+
+def sub_gt_fuzzy_matching(pred, gt):
+
+    min_d = float('inf')
+    pos = ""
+    matched_sub = ""
+    gt_len = len(gt)
+    pred_len = len(pred)
+
+    if pred_len >= gt_len and gt_len > 0:
+        for i in range(pred_len - gt_len + 1):
+            sub = pred[i:i + gt_len]
+            dist = Levenshtein.distance(sub, gt)  /gt_len
+            if dist < min_d:
+                min_d = dist
+                pos = i
+                matched_sub = sub
+        return min_d, pos, gt_len, matched_sub
+    else:
+        return 1, "", gt_len, ""
+
+
+def get_final_subset(subset_certain, subset_certain_cost):
+    if not subset_certain or not subset_certain_cost:
+        return []
+
+    subset_turple = sorted([(a, b) for a, b in zip(subset_certain, subset_certain_cost)], key=lambda x: x[0][0])
+
+    group_list = defaultdict(list)
+    group_idx = 0
+    group_list[group_idx].append(subset_turple[0])
+
+    for item in subset_turple[1:]:
+        overlap_flag = False
+        for subset in group_list[group_idx]:
+            for idx in item[0]:
+                if idx in subset[0]:
+                    overlap_flag = True
+                    break
+            if overlap_flag:
+                break
+        if overlap_flag:
+            group_list[group_idx].append(item)
+        else:
+            group_idx += 1
+            group_list[group_idx].append(item)
+
+    final_subset = []
+    for _, group in group_list.items():
+        if len(group) == 1:
+            final_subset.append(group[0][0])
+        else:
+            path_dict = defaultdict(list)
+            path_idx = 0
+            path_dict[path_idx].append(group[0])
+
+            for subset in group[1:]:
+                new_path = True
+                for path_idx_s, path_items in path_dict.items():
+                    is_dup = False
+                    is_same = False
+                    for path_item in path_items:
+                        if path_item[0] == subset[0]:
+                            is_dup = True
+                            is_same = True
+                            if path_item[1] > subset[1]:
+                                path_dict[path_idx_s].pop(path_dict[path_idx_s].index(path_item))
+                                path_dict[path_idx_s].append(subset)
+                        else:
+                            for num_1 in path_item[0]:
+                                for num_2 in subset[0]:
+                                    if num_1 == num_2:
+                                        is_dup = True
+                    if not is_dup:
+                        path_dict[path_idx_s].append(subset)
+                        new_path = False
+                    if is_same:
+                        new_path = False
+                if new_path:
+                    path_idx = len(path_dict.keys())
+                    path_dict[path_idx].append(subset)
+
+            saved_cost = float('inf')
+            saved_subset = []
+            for path_idx, path in path_dict.items():
+                avg_cost = sum([i[1] for i in path]) / len(path)
+                if avg_cost < saved_cost:
+                    saved_subset = [i[0] for i in path]
+                    saved_cost = avg_cost
+
+            final_subset.extend(saved_subset)
+
+    return final_subset
+
+def judge_pred_merge(gt_list, pred_list, threshold=0.6):
+    if len(pred_list) == 1:
+        return False, False
+
+    cur_pred = ' '.join(pred_list[:-1])
+    merged_pred = ' '.join(pred_list)
+
+    cur_dist = Levenshtein.distance(gt_list[0], cur_pred) / max(len(gt_list[0]), len(cur_pred))
+    merged_dist = Levenshtein.distance(gt_list[0], merged_pred) / max(len(gt_list[0]), len(merged_pred))
+
+    if merged_dist > cur_dist:
+        return False, False
+
+    cur_fuzzy_dists = [sub_pred_fuzzy_matching(gt_list[0], cur_pred) for cur_pred in pred_list[:-1]]
+    if any(dist is False or dist > threshold for dist in cur_fuzzy_dists):
+        return False, False
+
+    add_fuzzy_dist = sub_pred_fuzzy_matching(gt_list[0], pred_list[-1])
+    if add_fuzzy_dist is False:
+        return False, False
+
+    merged_pred_flag = add_fuzzy_dist < threshold
+    continue_flag = len(merged_pred) <= len(gt_list[0])
+
+    return merged_pred_flag, continue_flag
+
+def deal_with_truncated(cost_matrix, norm_gt_lines, norm_pred_lines):
+    matched_first = np.argwhere(cost_matrix < 0.25)
+    masked_gt_idx = [i[0] for i in matched_first]
+    unmasked_gt_idx = [i for i in range(cost_matrix.shape[0]) if i not in masked_gt_idx]
+    masked_pred_idx = [i[1] for i in matched_first]
+    unmasked_pred_idx = [i for i in range(cost_matrix.shape[1]) if i not in masked_pred_idx]
+
+    merges_gt_dict = {}
+    merges_pred_dict = {}
+    merged_gt_subsets = []
+
+    for gt_idx in unmasked_gt_idx:
+        check_merge_subset = []
+        merged_dist = []
+
+        for pred_idx in unmasked_pred_idx:
+            step = 1
+            merged_pred = [norm_pred_lines[pred_idx]]
+
+            while True:
+                if pred_idx + step in masked_pred_idx or pred_idx + step >= len(norm_pred_lines):
+                    break
+                else:
+                    merged_pred.append(norm_pred_lines[pred_idx + step])
+                    merged_pred_flag, continue_flag = judge_pred_merge([norm_gt_lines[gt_idx]], merged_pred)
+                    if not merged_pred_flag:
+                        break
+                    else:
+                        step += 1
+                    if not continue_flag:
+                        break
+
+            check_merge_subset.append(list(range(pred_idx, pred_idx + step)))
+            matched_line = ' '.join([norm_pred_lines[i] for i in range(pred_idx, pred_idx + step)])
+            dist = Levenshtein_distance(norm_gt_lines[gt_idx], matched_line) / max(len(matched_line), len(norm_gt_lines[gt_idx]))
+            merged_dist.append(dist)
+
+        if not merged_dist:
+            subset_certain = []
+            min_cost_idx = ""
+            min_cost = float('inf')
+        else:
+            min_cost = min(merged_dist)
+            min_cost_idx = merged_dist.index(min_cost)
+            subset_certain = check_merge_subset[min_cost_idx]
+
+        merges_gt_dict[gt_idx] = {
+            'merge_subset': check_merge_subset,
+            'merged_cost': merged_dist,
+            'min_cost_idx': min_cost_idx,
+            'subset_certain': subset_certain,
+            'min_cost': min_cost
+        }
+
+    subset_certain = [merges_gt_dict[gt_idx]['subset_certain'] for gt_idx in unmasked_gt_idx if merges_gt_dict[gt_idx]['subset_certain']]
+    subset_certain_cost = [merges_gt_dict[gt_idx]['min_cost'] for gt_idx in unmasked_gt_idx if merges_gt_dict[gt_idx]['subset_certain']]
+
+    subset_certain_final = get_final_subset(subset_certain, subset_certain_cost)
+
+    if not subset_certain_final:
+        return cost_matrix, norm_pred_lines, range(len(norm_pred_lines))
+
+    final_pred_idx_list = merge_lists_with_sublists(range(len(norm_pred_lines)), subset_certain_final)
+    final_norm_pred_lines = [' '.join(norm_pred_lines[idx_list[0]:idx_list[-1]+1]) if isinstance(idx_list, list) else norm_pred_lines[idx_list] for idx_list in final_pred_idx_list]
+
+    new_cost_matrix = compute_edit_distance_matrix_new(norm_gt_lines, final_norm_pred_lines)
+
+    return new_cost_matrix, final_norm_pred_lines, final_pred_idx_list
+
+def cal_move_dist(gt, pred):
+    assert len(gt) == len(pred), 'Not right length'
+    step = 0
+    for i, gt_c in enumerate(gt):
+        if gt_c != pred[i]:
+            step += abs(i - pred.index(gt_c))
+            pred[i], pred[pred.index(gt_c)] = pred[pred.index(gt_c)], pred[i]
+    return step / len(gt)
+
+def cal_final_match(cost_matrix, norm_gt_lines, norm_pred_lines):
+    min_indice = cost_matrix.argmax(axis=1)
+
+    new_cost_matrix, final_norm_pred_lines, final_pred_idx_list = deal_with_truncated(cost_matrix, norm_gt_lines, norm_pred_lines)
+
+    row_ind, col_ind = linear_sum_assignment(new_cost_matrix)
+
+    cost_list = [new_cost_matrix[r][c] for r, c in zip(row_ind, col_ind)]
+    matched_col_idx = [final_pred_idx_list[i] for i in col_ind]
+
+    return matched_col_idx, row_ind, cost_list
+
+def initialize_indices(norm_gt_lines, norm_pred_lines):
+    gt_lens_dict = {idx: len(gt_line) for idx, gt_line in enumerate(norm_gt_lines)}
+    pred_lens_dict = {idx: len(pred_line) for idx, pred_line in enumerate(norm_pred_lines)}
+    return gt_lens_dict, pred_lens_dict
+
+def process_matches(matched_col_idx, row_ind, cost_list, norm_gt_lines, norm_pred_lines, pred_lines):
+    matches = {}
+    unmatched_gt_indices = []
+    unmatched_pred_indices = []
+
+    for i in range(len(norm_gt_lines)):
+        if i in row_ind:
+            idx = list(row_ind).index(i)
+            pred_idx = matched_col_idx[idx]
+
+            if pred_idx is None or (isinstance(pred_idx, list) and None in pred_idx):
+                unmatched_pred_indices.append(pred_idx)
+                continue
+
+            if isinstance(pred_idx, list):
+                pred_line = ' | '.join(norm_pred_lines[pred_idx[0]:pred_idx[-1]+1])
+                ori_pred_line = ' | '.join(pred_lines[pred_idx[0]:pred_idx[-1]+1])
+                matched_pred_indices_range = list(range(pred_idx[0], pred_idx[-1]+1))
+            else:
+                pred_line = norm_pred_lines[pred_idx]
+                ori_pred_line = pred_lines[pred_idx]
+                matched_pred_indices_range = [pred_idx]
+
+            edit = cost_list[idx]
+
+            if edit > 0.7:
+                unmatched_pred_indices.extend(matched_pred_indices_range)
+                unmatched_gt_indices.append(i)
+            else:
+                matches[i] = {
+                    'pred_indices': matched_pred_indices_range,
+                    'edit_distance': edit,
+                }
+                for matched_pred_idx in matched_pred_indices_range:
+                    if matched_pred_idx in unmatched_pred_indices:
+                        unmatched_pred_indices.remove(matched_pred_idx)
+        else:
+            unmatched_gt_indices.append(i)
+
+    return matches, unmatched_gt_indices, unmatched_pred_indices
+
+def fuzzy_match_unmatched_items(unmatched_gt_indices, norm_gt_lines, norm_pred_lines):
+    matching_dict = {}
+
+    for pred_idx, pred_content in enumerate(norm_pred_lines):
+        if isinstance(pred_idx, list):
+            continue
+
+        matching_indices = []
+
+        for unmatched_gt_idx in unmatched_gt_indices:
+            gt_content = norm_gt_lines[unmatched_gt_idx]
+            cur_fuzzy_dist_unmatch, cur_pos, gt_lens, matched_field = sub_gt_fuzzy_matching(pred_content, gt_content)
+            if cur_fuzzy_dist_unmatch < 0.4:
+                matching_indices.append(unmatched_gt_idx)
+
+        if matching_indices:
+            matching_dict[pred_idx] = matching_indices
+
+    return matching_dict
+
+def merge_matches(matches, matching_dict):
+    final_matches = {}
+    processed_gt_indices = set()
+
+    for gt_idx, match_info in matches.items():
+        pred_indices = match_info['pred_indices']
+        edit_distance = match_info['edit_distance']
+
+        pred_key = tuple(sorted(pred_indices))
+
+        if pred_key in final_matches:
+            if gt_idx not in processed_gt_indices:
+                final_matches[pred_key]['gt_indices'].append(gt_idx)
+                processed_gt_indices.add(gt_idx)
+        else:
+            final_matches[pred_key] = {
+                'gt_indices': [gt_idx],
+                'edit_distance': edit_distance
+            }
+            processed_gt_indices.add(gt_idx)
+
+    for pred_idx, gt_indices in matching_dict.items():
+        pred_key = (pred_idx,) if not isinstance(pred_idx, (list, tuple)) else tuple(sorted(pred_idx))
+
+        if pred_key in final_matches:
+            for gt_idx in gt_indices:
+                if gt_idx not in processed_gt_indices:
+                    final_matches[pred_key]['gt_indices'].append(gt_idx)
+                    processed_gt_indices.add(gt_idx)
+        else:
+            final_matches[pred_key] = {
+                'gt_indices': [gt_idx for gt_idx in gt_indices if gt_idx not in processed_gt_indices],
+                'edit_distance': None
+            }
+            processed_gt_indices.update(final_matches[pred_key]['gt_indices'])
+
+    return final_matches
+
+
+
+def recalculate_edit_distances(final_matches, gt_lens_dict, norm_gt_lines, norm_pred_lines):
+    for pred_key, info in final_matches.items():
+        gt_indices = sorted(set(info['gt_indices']))
+
+        if not gt_indices:
+            info['edit_distance'] = 1
+            continue
+
+        if len(gt_indices) > 1:
+            merged_gt_content = ''.join(norm_gt_lines[gt_idx] for gt_idx in gt_indices)
+            pred_content = norm_pred_lines[pred_key[0]] if isinstance(pred_key[0], int) else ''
+
+            try:
+                edit_distance = Levenshtein_distance(merged_gt_content, pred_content)
+                normalized_edit_distance = edit_distance / max(len(merged_gt_content), len(pred_content))
+            except ZeroDivisionError:
+                normalized_edit_distance = 1
+
+            info['edit_distance'] = normalized_edit_distance
+        else:
+            gt_idx = gt_indices[0]
+            pred_content = ' '.join(norm_pred_lines[pred_idx] for pred_idx in pred_key if isinstance(pred_idx, int))
+
+            try:
+                edit_distance = Levenshtein_distance(norm_gt_lines[gt_idx], pred_content)
+                normalized_edit_distance = edit_distance / max(len(norm_gt_lines[gt_idx]), len(pred_content))
+            except ZeroDivisionError:
+                normalized_edit_distance = 1
+
+            info['edit_distance'] = normalized_edit_distance
+            info['pred_content'] = pred_content
+
+
+def convert_final_matches(final_matches, norm_gt_lines, norm_pred_lines):
+    converted_results = []
+
+    all_gt_indices = set(range(len(norm_gt_lines)))
+    all_pred_indices = set(range(len(norm_pred_lines)))
+
+    for pred_key, info in final_matches.items():
+        pred_content = ' '.join(norm_pred_lines[pred_idx] for pred_idx in pred_key if isinstance(pred_idx, int))
+
+        for gt_idx in sorted(set(info['gt_indices'])):
+            result_entry = {
+                'gt_idx': int(gt_idx),
+                'gt': norm_gt_lines[gt_idx],
+                'pred_idx': list(pred_key),
+                'pred': pred_content,
+                'edit': info['edit_distance']
+            }
+            converted_results.append(result_entry)
+
+    matched_gt_indices = set().union(*[set(info['gt_indices']) for info in final_matches.values()])
+    unmatched_gt_indices = all_gt_indices - matched_gt_indices
+    matched_pred_indices = set(idx for pred_key in final_matches.keys() for idx in pred_key if isinstance(idx, int))
+    unmatched_pred_indices = all_pred_indices - matched_pred_indices
+
+    if unmatched_pred_indices:
+        if unmatched_gt_indices:
+            distance_matrix = [
+                [Levenshtein_distance(norm_gt_lines[gt_idx], norm_pred_lines[pred_idx]) for pred_idx in unmatched_pred_indices]
+                for gt_idx in unmatched_gt_indices
+            ]
+
+            row_ind, col_ind = linear_sum_assignment(distance_matrix)
+
+            for i, j in zip(row_ind, col_ind):
+                gt_idx = list(unmatched_gt_indices)[i]
+                pred_idx = list(unmatched_pred_indices)[j]
+                result_entry = {
+                    'gt_idx': int(gt_idx),
+                    'gt': norm_gt_lines[gt_idx],
+                    'pred_idx': [pred_idx],
+                    'pred': norm_pred_lines[pred_idx],
+                    'edit': 1
+                }
+                converted_results.append(result_entry)
+
+            matched_gt_indices.update(list(unmatched_gt_indices)[i] for i in row_ind)
+        else:
+            result_entry = {
+                'gt_idx': "",
+                'gt': '',
+                'pred_idx': list(unmatched_pred_indices),
+                'pred': ' '.join(norm_pred_lines[pred_idx] for pred_idx in unmatched_pred_indices),
+                'edit': 1
+            }
+            converted_results.append(result_entry)
+    else:
+        for gt_idx in unmatched_gt_indices:
+            result_entry = {
+                'gt_idx': int(gt_idx),
+                'gt': norm_gt_lines[gt_idx],
+                'pred_idx': "",
+                'pred': '',
+                'edit': 1
+            }
+            converted_results.append(result_entry)
+
+    return converted_results
+
+import json
+
+def read_md_file(filepath):
+    with open(filepath, 'r', encoding='utf-8') as file:
+        content = file.read()
+
+    return content
+
+def save_paired_result(preds, gts, save_path):
+    save_result = []
+    formula_id = 0
+    for gt, pred in zip(gts, preds):
+        save_result.append({
+            "gt": gt,
+            "pred": pred,
+            "img_id": formula_id
+        })
+        formula_id += 1
+    with open(save_path, 'w', encoding='utf-8') as f:
+        json.dump(save_result, f, indent=4, ensure_ascii=False)
+
+
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+import re
+import matplotlib.font_manager as fm
+font = fm.FontProperties(fname=r'font/SimHei.ttf')
+
+
+def print_aligned_dict(data):
+    # Find the maximum length of all keys
+    max_key_length = max(len(key) for key in data['testcase1'])
+
+    # Print header
+    print(f"{' ' * (max_key_length + 4)}", end="")
+    for key in data:
+        print(f"{key:>{max_key_length}}", end="")
+    print()
+
+    # Print dictionary content
+    for subkey in data['testcase1']:
+        print(f"{subkey:<{max_key_length + 4}}", end="")
+        for key in data:
+            print(f"{data[key][subkey]:>{max_key_length}}", end="")
+        print()
+def create_dict_from_folders(directory):
+    body = {}
+    for folder_name in os.listdir(directory):
+        folder_path = os.path.join(directory, folder_name)
+        if os.path.isdir(folder_path):
+            body[folder_name] = {}
+    return body
+
+
+def create_radar_chart(df, title, filename):
+    labels = df.columns
+
+    # Calculate angles
+    angles = np.linspace(0, 2 * np.pi, len(labels), endpoint=False).tolist()
+    angles += angles[:1]
+
+    # Initialize radar chart
+    fig, ax = plt.subplots(figsize=(10, 6), subplot_kw=dict(polar=True), dpi=200)
+    # ax.spines['polar'].set_visible(False)
+
+    # Draw radar chart for each dataset
+    for index, row in df.iterrows():
+        values = row.tolist()
+        values += values[:1]
+        ax.fill(angles, values, alpha=0.1)
+        ax.plot(angles, values, label=index)
+
+        # Add percentage labels next to each data point
+        for angle, value in zip(angles, values):
+            ax.text(angle, value, '{:.1%}'.format(value), ha='center', va='center', fontsize=7, alpha=0.7)
+
+    # Set labels
+    ax.set_yticklabels([])
+    ax.set_xticks(angles[:-1])
+    ax.set_xticklabels(labels, fontproperties=font)
+    ax.spines['polar'].set_visible(False)  # Hide the outermost circle
+    ax.grid(False)
+    for j in np.arange(0, 1.2, 0.2):
+        ax.plot(angles, len(values) * [j], '-.', lw=0.5, color='black', alpha=0.5)
+    for j in range(len(values)):
+        ax.plot([angles[j], angles[j]], [0, 1], '-.', lw=0.5, color='black', alpha=0.5)
+
+    # Add title and legend
+    plt.legend(loc='upper right', bbox_to_anchor=(0.1, 0.1))
+
+    ax.tick_params(pad=30)
+    ax.set_theta_zero_location('N')
+    # Save chart to file
+    plt.savefig(filename)
+
+# The function is from https://github.com/intsig-textin/markdown_tester
+def markdown_to_html(markdown_table):
+    rows = [row.strip() for row in markdown_table.strip().split('\n')]
+    num_columns = len(rows[0].split('|')) - 2
+
+    html_table = '<table>\n  <thead>\n    <tr>\n'
+
+    header_cells = [cell.strip() for cell in rows[0].split('|')[1:-1]]
+    for cell in header_cells:
+        html_table += f'      <th>{cell}</th>\n'
+    html_table += '    </tr>\n  </thead>\n  <tbody>\n'
+
+    for row in rows[2:]:
+        cells = [cell.strip() for cell in row.split('|')[1:-1]]
+        html_table += '    <tr>\n'
+        for cell in cells:
+            html_table += f'      <td>{cell}</td>\n'
+        html_table += '    </tr>\n'
+
+    html_table += '  </tbody>\n</table>\n'
+    return html_table
+def convert_markdown_to_html(self, markdown_content, md_type):
+    # Define a regex pattern to find Markdown tables with newlines
+    markdown_content = markdown_content.replace('\r', '')
+    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
+def convert_table_str(s):
+    s = re.sub(r'<table.*?>','<table>',s)
+    s = re.sub(r'<th','<td',s)
+    s = re.sub(r'</th>','</td>',s)
+    # s = re.sub(r'<td rowspan="(.)">',lambda x:f'<td colspan="1" rowspan="{x.group(1)}">',s)
+    # s = re.sub(r'<td colspan="(.)">',lambda x:f'<td colspan="{x.group(1)}" rowspan="1">',s)
+    res = ''
+    res += '\n\n'
+    temp_item = ''
+    for c in s:
+        temp_item += c
+        if c == '>' and not re.search(r'<td.*?>\$',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'</?t(able|head|body)>',line):
+            res.append(line)
+    return res
+def merge_tables(input_str):
+    # Delete HTML comments
+    input_str = re.sub(r'<!--[\s\S]*?-->', '', input_str)
+
+    # Use regex to find each <table> block
+    table_blocks = re.findall(r'<table>[\s\S]*?</table>', input_str)
+
+    # Process each <table> block, replace <th> with <td>
+    output_lines = []
+    for block in table_blocks:
+        block_lines = block.split('\n')
+        for i, line in enumerate(block_lines):
+            if '<th>' in line:
+                block_lines[i] = line.replace('<th>', '<td>').replace('</th>', '</td>')
+        final_tr = delete_table_and_body(block_lines)
+        if len(final_tr) > 2:
+            output_lines.extend(final_tr)  # Ignore <table> and </table> tags, keep only table content
+
+    # Rejoin the processed strings
+    merged_output = '<table>\n{}\n</table>'.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 "<table>" not in last_line and in_table_block == False and temp_block != "":
+        #     output_lines.append(merge_tables(temp_block))
+        #     temp_block = ""
+        if "<table>" in line:
+            # if "<table><tr" in line:
+            #     org_table_list.append(line)
+            #     in_org_table = True
+            #     output_lines.append(last_line)
+            #     continue
+            # else:
+            in_table_block = True
+            temp_block += last_line
+        elif in_table_block:
+            if not find_md_table_mode(last_line) and "</thead>" not in last_line:
+                temp_block += "\n" + last_line
+            if "</table>" in last_line:
+                if "<table>" 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 "</table" in line:
+        #         in_org_table = False
+        #         last_line = merge_table(org_table_list)
+        #         org_table_list = []
+
+    if last_line:
+        if in_table_block or "</table>" in last_line:
+            temp_block += "\n" + last_line
+            output_lines.append(merge_tables(temp_block))
+        else:
+            output_lines.append(last_line)
+    # if "</table>" in last_line:
+    #     output_lines.append(merge_tables(temp_block))
+
+    return '\n'.join(output_lines)
+
+def convert_table(input_str):
+    # Replace <table>
+    output_str = input_str.replace("<table>", "<table border=\"1\" >")
+
+    # Replace <td>
+    output_str = output_str.replace("<td>", "<td colspan=\"1\" rowspan=\"1\">")
+
+    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

VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/IoUscore_metric.py

@@ -0,0 +1,87 @@
+# flake8: noqa
+import os
+import re
+import ast
+import ipdb
+from vlmeval.dataset.utils.Ocrbench_v2.vqa_metric import vqa_evaluation
+
+
+def calculate_iou(box1, box2):
+
+    try:
+        box1 = [int(coordinate) for coordinate in box1]
+        box2 = [int(coordinate) for coordinate in box2]
+    except:
+        return 0
+
+    x1_inter = max(box1[0], box2[0])
+    y1_inter = max(box1[1], box2[1])
+    x2_inter = min(box1[2], box2[2])
+    y2_inter = min(box1[3], box2[3])
+    inter_area = max(0, x2_inter - x1_inter) * max(0, y2_inter - y1_inter)
+    box1_area = (box1[2] - box1[0]) * (box1[3] - box1[1])
+    box2_area = (box2[2] - box2[0]) * (box2[3] - box2[1])
+    union_area = box1_area + box2_area - inter_area
+    iou = inter_area / union_area if union_area != 0 else 0
+    return iou
+
+
+def vqa_with_position_evaluation(predict, img_metas):
+
+    score_content, score_bbox = .0, .0
+    if "answer" in predict.keys():
+        score_content = vqa_evaluation(predict["answer"], img_metas["answers"])
+    if "bbox" in predict.keys():
+        gt_bbox = img_metas["bbox"]
+        try:
+            predict_bbox_list = ast.literal_eval(predict["bbox"])
+            score_bbox = calculate_iou(predict_bbox_list, gt_bbox)
+        except:
+            score_bbox = 0
+    return 0.5 * score_content + 0.5 * score_bbox
+
+
+def extract_coordinates(text):
+    # Regex pattern to match coordinates in either (x1, y1, x2, y2) or [x1, y1, x2, y2] format
+
+    pattern = r'[\(\[]\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*[\)\]]'
+
+    matches = list(re.finditer(pattern, text))
+    coords_list = []
+    coords_set = set()
+    for match in matches:
+
+        x1, y1, x2, y2 = map(int, match.groups())
+
+        if all(0 <= n <= 1000 for n in [x1, y1, x2, y2]):
+            coords = (x1, y1, x2, y2)
+
+            if coords in coords_set:
+                coords_list = [c for c in coords_list if c != coords]
+
+            coords_list.append(coords)
+            coords_set.add(coords)
+    if coords_list:
+        last_coords = coords_list[-1]
+        return list(last_coords)
+    else:
+        return None
+
+
+if __name__ == "__main__":
+
+    print("Example for Text Grounding task.")
+    box1 = [50, 50, 150, 150]
+    box2 = [60, 60, 140, 140]
+    iou_score = calculate_iou(box1, box2)
+    print(f"IoU score: {iou_score}")
+
+    print("Example for VQA with position task.")
+    pred = {"content": "The content is Hello Buddies", "bbox": box1}
+    gt = {"content": "Hello Buddies", "bbox": box2}
+
+    vqa_score = vqa_evaluation(pred["content"], gt["content"])
+    iou_score = calculate_iou(pred["bbox"], gt["bbox"])
+
+    print(f"VQA score: {vqa_score}")
+    print(f"IoU score: {iou_score}")

VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/TEDS_metric.py

@@ -0,0 +1,930 @@
+# flake8: noqa
+# Copyright 2020 IBM
+# Author: peter.zhong@au1.ibm.com
+#
+# This is free software; you can redistribute it and/or modify
+# it under the terms of the Apache 2.0 License.
+#
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# Apache 2.0 License for more details.
+
+import re
+import ast
+import json
+import ipdb
+import distance
+from apted import APTED, Config
+from itertools import product
+from apted.helpers import Tree
+from lxml import etree, html
+from collections import deque
+from vlmeval.dataset.utils.Ocrbench_v2.parallel import parallel_process
+from tqdm import tqdm
+from zss import simple_distance, Node
+import string
+from typing import Any, Callable, Optional, Sequence
+import numpy as np
+import Levenshtein
+import editdistance
+
+
+class TableTree(Tree):
+    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):
+    @staticmethod
+    def maximum(*sequences):
+        """Get maximum possible value
+        """
+        return max(map(len, sequences))
+
+    def normalized_distance(self, *sequences):
+        """Get distance from 0 to 1
+        """
+        return float(distance.levenshtein(*sequences)) / self.maximum(*sequences)
+
+    def rename(self, node1, node2):
+        """Compares attributes of trees"""
+        if (node1.tag != node2.tag) or (node1.colspan != node2.colspan) or (node1.rowspan != node2.rowspan):
+            return 1.
+        if node1.tag == 'td':
+            if node1.content or node2.content:
+                return self.normalized_distance(node1.content, node2.content)
+        return 0.
+
+
+class TEDS(object):
+    ''' Tree Edit Distance basead Similarity
+    '''
+    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('</%s>' % 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
+        '''
+        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
+
+    def batch_evaluate(self, pred_json, true_json):
+        ''' Computes TEDS score between the prediction and the ground truth of
+            a batch of samples
+            @params pred_json: {'FILENAME': 'HTML CODE', ...}
+            @params true_json: {'FILENAME': {'html': 'HTML CODE'}, ...}
+            @output: {'FILENAME': 'TEDS SCORE', ...}
+        '''
+        samples = true_json.keys()
+        if self.n_jobs == 1:
+            scores = [self.evaluate(pred_json.get(filename, ''), true_json[filename]['html']) for filename in tqdm(samples)]
+        else:
+            #inputs = [{'pred': pred_json.get(filename, ''), 'true': true_json[filename]['html']} for filename in samples]
+            inputs = [{'pred': pred_json.get(filename, ''), 'true': true_json[filename]} for filename in samples]
+            scores = parallel_process(inputs, self.evaluate, use_kwargs=True, n_jobs=self.n_jobs, front_num=1)
+        scores = dict(zip(samples, scores))
+        return scores
+
+
+def convert_table_to_html_str(table_row_list=[]):
+    """
+    Given a list of table rows, build the corresponding html string, which is used to compute the TEDS score.
+    We use the official code of PubTabNet to compute TEDS score, it does not consider '<th>' label.
+    We also remove unneccessary spaces within a table cell and extra '\n' as they will influence the TEDS score.
+    """
+    html_table_str = "<html><body><table>" + '\n'
+    for data_row in table_row_list:
+        html_table_str += "<tr>"
+        for cell_str in data_row:
+            html_table_str += f"<td>{cell_str}</td>"
+        html_table_str += "</tr>"
+        html_table_str += '\n'
+    html_table_str += "</table></body></html>"
+    html_table_str = html_table_str.replace('\n','')
+    return html_table_str
+
+
+def convert_markdown_table_to_html(markdown_table):
+    """
+    Converts a markdown table to the corresponding html string for TEDS computation.
+    """
+    # remove extra code block tokens like '```markdown' and '```
+    markdown_table = markdown_table.strip('```markdown').strip('```').strip()
+    row_str_list = markdown_table.split('\n')
+    # extra the first header row and other data rows
+    valid_row_str_list = [row_str_list[0]]+row_str_list[2:]
+    table_rows = []
+    for row_str in valid_row_str_list:
+        one_row = []
+        for cell in row_str.strip().split('|')[1:-1]:
+            if set(cell) != set(' '):
+                one_row.append(cell.strip())
+            else:
+                one_row.append(' ')
+        table_rows.append(one_row)
+    # build html string based on table rows
+    html_str = convert_table_to_html_str(table_rows)
+    return html_str
+
+
+def dict_to_html(data):
+    html = "<html><body><table>\n"
+    for key, value in data.items():
+        if not isinstance(value, str):
+            value = str(value)
+        value_str = ' '.join(value)
+
+        html += f"  <tr><td>{key}</td><td>{value_str}</td></tr>\n"
+    html += "</table></body></html>"
+    return html
+
+
+def convert_str_to_dict(predict_str: str):
+    """
+    Parses the 'predict' string and returns a dictionary.
+    Missing or unparseable content is handled gracefully.
+
+    Parameters:
+    - predict_str (str): The prediction string containing the output dict.
+
+    Returns:
+    - dict: A dictionary extracted from the predict string.
+    """
+    # Remove code fences like ```python\n...\n```
+    code_fence_pattern = r'```(?:python|json)?\n(.*?)\n```'
+    match = re.search(code_fence_pattern, predict_str, re.DOTALL | re.IGNORECASE)
+    if match:
+        content = match.group(1)
+    else:
+        content = predict_str.strip()
+
+    data = {}
+    success = False
+
+    # try parsing with JSON
+    try:
+        data = json.loads(content)
+        success = True
+    except json.JSONDecodeError:
+        pass
+
+    # try parsing with ast.literal_eval
+    if not success:
+        try:
+            data = ast.literal_eval(content)
+            if isinstance(data, dict):
+                success = True
+        except (ValueError, SyntaxError):
+            pass
+
+    # try parsing with regex
+    if not success:
+        key_value_pattern = r'["\']?([\w\s]+)["\']?\s*[:=]\s*["\']?([^\n,"\'{}]+)["\']?'
+        matches = re.findall(key_value_pattern, content)
+        try:
+            for key, value in matches:
+                data[key.strip()] = value.strip()
+        except:
+            return {}
+
+    if not data:
+        return {}
+
+    try:
+        result = {k.strip(): str(v).strip() for k, v in data.items()}
+    except:
+        return {}
+    return result
+
+
+def convert_str_to_multi_dict(predict_str: str):
+    """
+    Parses the 'predict' string and returns a dictionary.
+    Handles nested dictionaries and missing or unparseable content gracefully.
+
+    Parameters:
+    - predict_str (str): The prediction string containing the output dict.
+
+    Returns:
+    - dict: A dictionary extracted from the predict string.
+    """
+    # Remove code fences like ```python\n...\n```
+    code_fence_pattern = r'```(?:python|json)?\n(.*?)\n```'
+    matches = re.findall(code_fence_pattern, predict_str, re.DOTALL | re.IGNORECASE)
+    if matches:
+        content = max(matches, key=len)
+    else:
+        content = predict_str.strip()
+
+    def strip_variable_assignment(s):
+        variable_assignment_pattern = r'^\s*\w+\s*=\s*'
+        return re.sub(variable_assignment_pattern, '', s.strip(), count=1)
+
+    content = strip_variable_assignment(content)
+
+    def remove_comments(s):
+        return re.sub(r'#.*', '', s)
+
+    content = remove_comments(content)
+
+    last_brace_pos = content.rfind('}')
+    if last_brace_pos != -1:
+        content = content[:last_brace_pos+1]
+
+    data = {}
+    success = False
+
+    # try parsing with ast.literal_eval
+    try:
+        data = ast.literal_eval(content)
+        if isinstance(data, dict):
+            success = True
+    except (ValueError, SyntaxError, TypeError):
+        pass
+
+    if not success:
+        return {}
+
+    def process_data(obj):
+        if isinstance(obj, dict):
+            return {k: process_data(v) for k, v in obj.items()}
+        elif isinstance(obj, list):
+            return [process_data(elem) for elem in obj]
+        else:
+            return obj
+
+    data = process_data(data)
+
+    return data
+
+
+def generate_combinations(input_dict):
+    """
+    Function to generate all possible combinations of values from a dictionary.
+    """
+    kie_answer = input_dict
+    if not isinstance(kie_answer, dict):
+        kie_answer = kie_answer.strip('"')
+        try:
+            kie_answer = json.loads(kie_answer)
+        except json.JSONDecodeError:
+            try:
+                kie_answer = ast.literal_eval(kie_answer)
+                if not isinstance(kie_answer, dict):
+                    kie_answer = ast.literal_eval(kie_answer)
+            except (ValueError, SyntaxError):
+                print(f"Unable to parse 'answers' field: {kie_answer}")
+                return {}
+
+        # Ensure the parsed result is a dictionary.
+        if not isinstance(kie_answer, dict):
+            print("Parsed 'answers' is still not a dictionary.")
+            raise ValueError("Input could not be parsed into a dictionary.")
+
+        keys = list(kie_answer.keys())
+
+        value_lists = []
+        for single_key in keys:
+            sinlge_value = kie_answer[single_key]
+            if not isinstance(sinlge_value, list):
+                sinlge_value = [sinlge_value]
+            value_lists.append(sinlge_value)
+
+        # Compute the Cartesian product of the value lists.
+        combinations = list(product(*value_lists))
+
+        # Create a dictionary for each combination of values.
+        result = [dict(zip(keys, values)) for values in combinations]
+
+        return result
+
+    else:
+        keys = list(input_dict.keys())
+        value_lists = [input_dict[key] for key in keys]
+
+        # Compute the Cartesian product of the value lists.
+        combinations = list(product(*value_lists))
+
+        # Create a dictionary for each combination of values.
+        result = [dict(zip(keys, values)) for values in combinations]
+
+        return result
+
+
+def compute_f1_score(preds, gts, ignores=[]):
+    """Compute the F1-score for KIE task between predicted and ground truth dictionaries.
+
+    Args:
+        preds (dict): The predicted key-value pairs.
+        gts (dict): The ground truth key-value pairs.
+        ignores (list): The list of keys to ignore during evaluation.
+
+    Returns:
+        dict: A dictionary where keys are field names and values are their corresponding F1-scores.
+    """
+    # Optionally remove ignored keys from predictions and ground truths
+    keys = set(preds.keys()).union(set(gts.keys())) - set(ignores)
+    f1_scores = {}
+
+    for key in keys:
+        pred_value = preds.get(key, None)
+        gt_value = gts.get(key, None)
+
+        if pred_value:
+            pred_value = pred_value.lower().strip().replace("\n"," ").replace(" ", "")
+        if gt_value:
+            gt_value = gt_value.lower().strip().replace("\n"," ").replace(" ", "")
+
+        if pred_value is None and gt_value is None:
+            continue
+        elif pred_value is None:
+            precision = 0.0
+            recall = 0.0
+        elif gt_value is None:
+            # false positive
+            precision = 0.0
+            recall = 0.0
+        else:
+            if pred_value == gt_value:
+                # True positive
+                precision = 1.0
+                recall = 1.0
+            else:
+                precision = 0.0
+                recall = 0.0
+
+        # Compute F1-score
+        f1_score = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0.0
+        f1_scores[key] = f1_score
+
+    if len(f1_scores) == 0:
+        return 0
+    average_f1 = sum(f1_scores.values()) / len(f1_scores)
+
+    return average_f1
+
+
+def pre_clean(text):
+    text = re.sub(r'<bos>|<eos>|<pad>|<unk>', '', text)
+    text = re.sub(r'\s##(\S)', r'\1', text)
+    text = re.sub(r'\\\s', r'\\', text)
+    text = re.sub(r'\s\*\s\*\s', r'**', text)
+    text = re.sub(r'{\s', r'{', text)
+    text = re.sub(r'\s}', r'}', text)
+    text = re.sub(r'\s}', r'}', text)
+    text = re.sub(r'\\begin\s', r'\\begin', text)
+    text = re.sub(r'\\end\s', r'\\end', text)
+    text = re.sub(r'\\end{table}', r'\\end{table} \n\n', text)
+    text = text.replace('\n', ' ')
+    text = text.replace('*', ' ')
+    text = text.replace('_', ' ')
+    return text
+
+
+def get_tree(input_str):
+    tree = (Node('ROOT').addkid(Node('TITLE')))
+
+    lines = input_str.split("\n")
+    lines = [pre_clean(line) for line in lines]
+    last_title = ''
+    for line in lines:
+        if line.startswith('#'):
+            child = tree.get('ROOT')
+            line = line.replace('#', '')
+            child.addkid(Node(line))
+            last_title = line
+        else:
+            if last_title == '':
+                child = tree.get('TITLE')
+                child.addkid(Node(line))
+            else:
+                child = tree.get(last_title)
+                child.addkid(Node(line))
+    return tree
+
+def STEDS(pred_tree, ref_tree):
+    def my_distance(pred, ref):
+        if len(pred.split()) == 0 or len(ref.split()) == 0:
+            return 1
+        else:
+            return 0
+    total_distance = simple_distance(pred_tree, ref_tree, label_dist=my_distance)
+    num_of_nodes = max(len(list(pred_tree.iter())), len(list(ref_tree.iter())))
+    return 1-total_distance/num_of_nodes
+
+
+def doc_parsing_evaluation(pred, gt):
+    score = 0
+    if not isinstance(pred, str):
+        return 0
+    pred_tree = get_tree(pred)
+    gt_tree = get_tree(gt)
+    score = STEDS(pred_tree, gt_tree)
+
+    return score
+
+
+def wrap_html_table(html_table):
+    """
+    The TEDS computation from PubTabNet code requires that the input html table should have <html>, <body>, and <table> tags.
+    Add them if they are missing.
+    """
+    html_table = html_table.replace('\n','')
+    # add missing <table> tag if missing
+    if "<table" in html_table and "</table>" not in html_table:
+        html_table = html_table + "</table>"
+    elif "<table" not in html_table and "</table>" in html_table:
+        html_table = "<table>" + html_table
+    elif "<table" not in html_table and "</table>" not in html_table:
+        html_table = "<table>" + html_table + "</table>"
+    else:
+        pass
+    # add <body> and <html> tags if missing
+    if '<body>' not in html_table:
+        html_table = '<body>' + html_table + '</body>'
+    if '<html>' not in html_table:
+        html_table = '<html>' + html_table + '</html>'
+    return html_table
+
+
+def get_anls(s1, s2):
+    try:
+        s1 = s1.lower()
+        s2 = s2.lower()
+    except:
+        pass
+    if s1 == s2:
+        return 1.0
+    iou = 1 - editdistance.eval(s1, s2) / max(len(s1), len(s2))
+    anls = iou
+    return anls
+
+
+def ocr_eval(references,predictions):
+    socre_=0.0
+    None_num=0
+    for idx,ref_value in enumerate(references):
+        pred_value = predictions[idx]
+        pred_values, ref_values = [], []
+        if isinstance(pred_value, str):
+            pred_values.append(pred_value)
+        else:
+            pred_values = pred_value
+        if isinstance(ref_value, str):
+            ref_values.append(ref_value)
+        else:
+            ref_values = ref_value
+
+        temp_score = 0.0
+        temp_num = len(ref_values)
+
+        for tmpidx, tmpref in enumerate(ref_values):
+            tmppred = pred_values[tmpidx] if tmpidx < len(pred_values) else pred_values[0]
+            if len(pred_values) == 1 and tmppred != "None" and "None" not in ref_values:  # pred 1, and not None
+                temp_score = max(temp_score, get_anls(tmppred, tmpref))
+                temp_num = len(ref_values)
+            else:
+                if tmppred=='None' and tmpref!='None':
+                    temp_score += 0.0
+                elif tmpref=='None':
+                    temp_num -= 1
+                else:
+                    temp_score += get_anls(tmppred, tmpref)
+        if temp_num == 0:
+            ocr_score = 0.0
+            None_num += 1
+        else:
+            ocr_score = temp_score / (temp_num)
+        socre_ += ocr_score
+    if None_num == len(references):
+        return 9999
+    else:
+        return round(socre_ / (len(references)-None_num), 5)
+
+
+def csv_eval(predictions,references,easy, pred_type='json'):
+    predictions = predictions
+    labels = references
+    def is_int(val):
+        try:
+            int(val)
+            return True
+        except ValueError:
+            return False
+
+    def is_float(val):
+        try:
+            float(val)
+            return True
+        except ValueError:
+            return False
+
+    def convert_dict_to_list(data):
+        """
+        Convert a dictionary to a list of tuples, handling both simple and nested dictionaries.
+
+        Args:
+        data (dict): The input dictionary, which might be nested or simple.
+
+        Returns:
+        list: A list of tuples generated from the input dictionary.
+        """
+        # print(data)
+        converted_list = []
+        for key, value in data.items():
+            # Check if the value is a dictionary (indicating a nested structure)
+            if isinstance(value, dict):
+                # Handle nested dictionary
+                for subkey, subvalue in value.items():
+                    # converted_list.append((key, subkey, subvalue))
+                    converted_list.append((key, subkey, re.sub(r'[^\d.-]', '', str(subvalue))))
+
+            else:
+                # Handle simple key-value pair
+                # converted_list.append((key, "value", value))
+                converted_list.append((key, "value", re.sub(r'[^\d.-]', '', str(value))))
+        return converted_list
+
+
+    def csv2triples(csv, separator='\\t', delimiter='\\n'):
+        lines = csv.strip().split(delimiter)
+        header = lines[0].split(separator)
+        triples = []
+        for line in lines[1:]:
+            if not line:
+                continue
+            values = line.split(separator)
+            entity = values[0]
+            for i in range(1, len(values)):
+                if i >= len(header):
+                    break
+                #---------------------------------------------------------
+                temp = [entity.strip(), header[i].strip()]
+                temp = [x if len(x)==0 or x[-1] != ':' else x[:-1] for x in temp]
+                value = values[i].strip()
+                value = re.sub(r'[^\d.-]', '', str(value))
+                # value = value.replace("%","")
+                # value = value.replace("$","")
+                triples.append((temp[0], temp[1], value))
+                #---------------------------------------------------------
+        return triples
+
+    def csv2triples_noheader(csv, separator='\\t', delimiter='\\n'):
+        lines = csv.strip().split(delimiter)
+        maybe_header = [x.strip() for x in lines[0].split(separator)]
+        not_header = False
+        if len(maybe_header) > 2:
+            for c in maybe_header[1:]:
+                try:
+                    num = float(c)
+                    not_header = True
+                except:
+                    continue
+                if not_header:
+                    break
+        header = None if not_header else maybe_header
+        data_start = 0 if not_header and separator in lines[0] else 1
+        triples = []
+        for line in lines[data_start:]:
+            if not line:
+                continue
+            values = [x.strip() for x in line.split(separator)]
+            entity = values[0]
+            for i in range(1, len(values)):
+                try:
+                    temp = [entity if entity[-1]!=':' else entity[:-1], ""]
+                except:
+                    temp = [entity, ""]
+                if header is not None:
+                    try:
+                        this_header = header[i]
+                        temp = [entity, this_header]
+                        temp = [x if x[-1] != ':' else x[:-1] for x in temp]
+                    except:
+                        this_header = entity.strip()
+                value = values[i].strip()
+                value = re.sub(r'[^\d.-]', '', str(value))
+                # value = value.replace("%","")
+                # value = value.replace("$","")
+                triples.append((temp[0], temp[1], value))
+                #---------------------------------------------------------
+        return triples
+
+    def process_triplets(triplets):
+        new_triplets = []
+        for triplet in triplets:
+            new_triplet = []
+            triplet_temp = []
+            if len(triplet) > 2:
+                if is_int(triplet[2]) or is_float(triplet[2]):
+                    triplet_temp = (triplet[0].lower(), triplet[1].lower(), float(triplet[2]))
+                else:
+                    triplet_temp = (triplet[0].lower(), triplet[1].lower(), triplet[2].lower())
+            else:
+                triplet_temp = (triplet[0].lower(), triplet[1].lower(), "no meaning")
+            new_triplets.append(triplet_temp)
+        return new_triplets
+
+    def intersection_with_tolerance(a, b, tol_word, tol_num):
+        a = set(a)
+        b = set(b)
+        c = set()
+        for elem1 in a:
+            for elem2 in b:
+                if is_float(elem1[-1]) and is_float(elem2[-1]):
+                    if ((Levenshtein.distance(''.join(elem1[:-1]),''.join(elem2[:-1])) <= tol_word) and (abs(elem1[-1] - elem2[-1]) / (abs(elem2[-1])+0.000001) <= tol_num))or \
+                    ((''.join(elem1[:-1]) in ''.join(elem2[:-1])) and (abs(elem1[-1] - elem2[-1]) / (abs(elem2[-1])+0.000001) <= tol_num)) or \
+                    ((''.join(elem2[:-1]) in ''.join(elem1[:-1])) and (abs(elem1[-1] - elem2[-1]) / (abs(elem2[-1])+0.000001) <= tol_num)):
+                        c.add(elem1)
+                else:
+                    if (Levenshtein.distance(''.join([str(i) for i in elem1]),''.join([str(j) for j in elem2])) <= tol_word):
+                        c.add(elem1)
+        return list(c)
+
+    def union_with_tolerance(a, b, tol_word, tol_num):
+        c = set(a) | set(b)
+        d = set(a) & set(b)
+        e = intersection_with_tolerance(a, b, tol_word, tol_num)
+        f = set(e)
+        g = c-(f-d)
+        return list(g)
+
+    def get_eval_list(pred_csv, label_csv, separator='\\t', delimiter='\\n', tol_word=3, tol_num=0.05, pred_type='json'):
+
+        if pred_type == 'json':
+            pred_triple_list=[]
+            for it in pred_csv:
+                pred_triple_temp = convert_dict_to_list(it)
+                pred_triple_pre = process_triplets(pred_triple_temp)
+                pred_triple_list.append(pred_triple_pre)
+        else:
+            pred_triple_list=[]
+            for it in pred_csv:
+                pred_triple_temp = csv2triples(it, separator=separator, delimiter=delimiter)
+                # pred_triple_temp = csv2triples_noheader(it, separator=separator, delimiter=delimiter)
+                pred_triple_pre = process_triplets(pred_triple_temp)
+                pred_triple_list.append(pred_triple_pre)
+
+        label_triple_list=[]
+        for it in label_csv:
+            label_triple_temp = convert_dict_to_list(it)
+            label_triple_pre = process_triplets(label_triple_temp)
+            label_triple_list.append(label_triple_pre)
+
+
+        intersection_list=[]
+        union_list=[]
+        sim_list=[]
+        # for each chart image
+        for pred,label in zip(pred_triple_list, label_triple_list):
+            for idx in range(len(pred)):
+                try:
+                    if label[idx][1] == "value" and "value" not in pred[idx][:2]:
+                        pred[idx] = (pred[idx][0], "value", pred[idx][2])
+                    temp_pred_head = sorted(pred[idx][:2])
+                    temp_gt_head = sorted(label[idx][:2])
+                    pred[idx] = (temp_pred_head[0], temp_pred_head[1], pred[idx][2])
+                    label[idx] = (temp_gt_head[0], temp_gt_head[1], label[idx][2])
+                except:
+                    continue
+            intersection = intersection_with_tolerance(pred, label, tol_word = tol_word, tol_num=tol_num)
+            union = union_with_tolerance(pred, label, tol_word = tol_word, tol_num=tol_num)
+            sim = len(intersection)/len(union)
+            intersection_list.append(intersection)
+            union_list.append(union)
+            sim_list.append(sim)
+        return intersection_list, union_list, sim_list
+
+    def get_ap(predictions, labels, sim_threhold, tolerance, separator='\\t', delimiter='\\n', easy=1):
+        if tolerance == 'strict':
+            tol_word=0
+            if easy == 1:
+                tol_num=0
+            else:
+                tol_num=0.1
+
+        elif tolerance == 'slight':
+            tol_word=2
+            if easy == 1:
+                tol_num=0.05
+            else:
+                tol_num=0.3
+
+        elif tolerance == 'high':
+            tol_word= 5
+            if easy == 1:
+                tol_num=0.1
+            else:
+                tol_num=0.5
+        intersection_list, union_list, sim_list = get_eval_list(predictions, labels, separator=separator, delimiter=delimiter, tol_word=tol_word, tol_num=tol_num, pred_type=pred_type)
+        ap = len([num for num in sim_list if num >= sim_threhold])/(len(sim_list)+1e-16)
+        return ap
+
+    map_strict = 0
+    map_slight = 0
+    map_high = 0
+    s="\\t"
+    d="\\n"
+
+    for sim_threhold in np.arange (0.5, 1, 0.05):
+        map_temp_strict = get_ap(predictions, labels, sim_threhold=sim_threhold, tolerance='strict', separator=s, delimiter=d, easy=easy)
+        map_temp_slight = get_ap(predictions, labels, sim_threhold=sim_threhold, tolerance='slight', separator=s, delimiter=d, easy=easy)
+        map_temp_high = get_ap(predictions, labels, sim_threhold=sim_threhold, tolerance='high', separator=s, delimiter=d, easy=easy)
+        map_strict += map_temp_strict/10
+        map_slight += map_temp_slight/10
+        map_high += map_temp_high/10
+
+    em = get_ap(predictions, labels, sim_threhold=1, tolerance='strict', separator=s, delimiter=d, easy=easy)
+    ap_50_strict = get_ap(predictions, labels, sim_threhold=0.5, tolerance='strict', separator=s, delimiter=d, easy=easy)
+    ap_75_strict = get_ap(predictions, labels, sim_threhold=0.75, tolerance='strict', separator=s, delimiter=d, easy=easy)
+    ap_90_strict = get_ap(predictions, labels, sim_threhold=0.90, tolerance='strict', separator=s, delimiter=d, easy=easy)
+    ap_50_slight = get_ap(predictions, labels, sim_threhold=0.5, tolerance='slight', separator=s, delimiter=d, easy=easy)
+    ap_75_slight = get_ap(predictions, labels, sim_threhold=0.75, tolerance='slight', separator=s, delimiter=d, easy=easy)
+    ap_90_slight = get_ap(predictions, labels, sim_threhold=0.90, tolerance='slight', separator=s, delimiter=d, easy=easy)
+    ap_50_high = get_ap(predictions, labels, sim_threhold=0.5, tolerance='high', separator=s, delimiter=d, easy=easy)
+    ap_75_high = get_ap(predictions, labels, sim_threhold=0.75, tolerance='high', separator=s, delimiter=d, easy=easy)
+    ap_90_high = get_ap(predictions, labels, sim_threhold=0.90, tolerance='high', separator=s, delimiter=d, easy=easy)
+
+
+    return em, map_strict, map_slight, map_high, ap_50_strict, ap_75_strict, ap_90_strict, ap_50_slight, ap_75_slight, ap_90_slight, ap_50_high, ap_75_high, ap_90_high
+
+def draw_SCRM_table(em, map_strict, map_slight, map_high, ap_50_strict, ap_75_strict, ap_90_strict, ap_50_slight, ap_75_slight, ap_90_slight, ap_50_high, ap_75_high, ap_90_high,title_ocr_socre,source_ocr_socre,x_title_ocr_socre,y_title_ocr_socre,structure_accuracy):
+
+    result=f'''
+            -----------------------------------------------------------\n
+            |  Metrics   |  Sim_threshold  |  Tolerance  |    Value    |\n
+            -----------------------------------------------------------\n
+            |             |                 |   strict    |    {'%.4f' % map_strict}    |     \n
+            |             |                 ----------------------------\n
+            |  mPrecison  |  0.5:0.05:0.95  |   slight    |    {'%.4f' % map_slight}    |\n
+            |             |                  ---------------------------\n
+            |             |                 |    high     |    {'%.4f' % map_high}    |\n
+            -----------------------------------------------------------\n
+            |             |                 |   strict    |    {'%.4f' % ap_50_strict}    |\n
+            |             |                  ---------------------------\n
+            |  Precison   |       0.5       |   slight    |    {'%.4f' % ap_50_slight }    |\n
+            |             |                  ---------------------------\n
+            |             |                 |    high     |    {'%.4f' % ap_50_high }    |\n
+            -----------------------------------------------------------\n
+            |             |                 |   strict    |    {'%.4f' % ap_75_strict}    |\n
+            |             |                  ---------------------------\n
+            |  Precison   |      0.75       |   slight    |    {'%.4f' % ap_75_slight}    |\n
+            |             |                  ---------------------------\n
+            |             |                 |    high     |    {'%.4f' % ap_75_high}    |\n
+            -----------------------------------------------------------\n
+            |             |                 |   strict    |    {'%.4f' % ap_90_strict}    |\n
+            |             |                  ---------------------------\n
+            |  Precison   |       0.9       |   slight    |    {'%.4f' % ap_90_slight }    |\n
+            |             |                  ---------------------------\n
+            |             |                 |    high     |    {'%.4f' % ap_90_high}    |\n
+            -----------------------------------------------------------\n
+            |Precison(EM) |                                    {'%.4f' % em}    |\n
+            -----------------------------------------------------------\n
+            |Title(EM)    |                                    {'%.4f' % title_ocr_socre}    |\n
+            -----------------------------------------------------------\n
+            |Source(EM)   |                                    {'%.4f' % source_ocr_socre}    |\n
+            -----------------------------------------------------------\n
+            |X_title(EM)  |                                    {'%.4f' % x_title_ocr_socre}    |\n
+            -----------------------------------------------------------\n
+            |Y_title(EM)  |                                    {'%.4f' % y_title_ocr_socre}    |\n
+            -----------------------------------------------------------\n
+            |structure_acc|                                    {'%.4f' % structure_accuracy}    |\n
+            -----------------------------------------------------------\n
+
+
+            '''
+    return result
+
+
+if __name__ == '__main__':
+    import json
+    import pprint
+
+    # markdown structure for Table Parsing task
+    pred_markdown = "| 1 | august 5 , 1972 | detroit lions | l 23 - 31 | 0 - 1 |\n| 2 | august 12 , 1972 | green bay packers | l 13 - 14 | 0 - 2 |\n| 3 | august 19 , 1972 | cincinnati bengals | w 35 - 17 | 1 - 2 |\n| 4 | august 25 , 1972 | atlanta falcons | w 24 - 10 | 2 - 2 |\n| 5 | august 31 , 1972 | washington redskins | l 24 - 27 | 2 - 3 |\n| 6 | september 10 , 1972 | minnesota vikings | w 21 - 19 | 3 - 3 |"
+    true_markdown = "| week | date | opponent | result | record |\n| --- | --- | --- | --- | --- |\n| 1 | august 5 , 1972 | detroit lions | l 23 - 31 | 0 - 1 |\n| 2 | august 12 , 1972 | green bay packers | l 13 - 14 | 0 - 2 |\n| 3 | august 19 , 1972 | cincinnati bengals | w 35 - 17 | 1 - 2 |\n| 4 | august 25 , 1972 | atlanta falcons | w 24 - 10 | 2 - 2 |\n| 5 | august 31 , 1972 | washington redskins | l 24 - 27 | 2 - 3 |\n| 6 | september 10 , 1972 | minnesota vikings | w 21 - 19 | 3 - 3 |"
+    teds = TEDS(n_jobs=4)
+    pred_table_html = convert_markdown_table_to_html(pred_markdown)
+    true_table_html = convert_markdown_table_to_html(true_markdown)
+
+    scores = teds.evaluate(pred_table_html, true_table_html)
+
+    pp = pprint.PrettyPrinter()
+    pp.pprint(scores)
+
+    # dict structure for Key Information Extraction task
+    pred_dict = {
+            "company": [
+                "OLD TOWN "
+            ],
+            "date": [
+                "2024"
+            ],
+            "address": [
+                "SRI RAMPAI"
+            ],
+            "total": [
+                "30"
+            ]
+        }
+    true_dict = {
+            "company": [
+                "OLD TOWN KOPITAM SND BHD"
+            ],
+            "date": [
+                "2024/9/27"
+            ],
+            "address": [
+                "SRI RAMPAI"
+            ],
+            "total": [
+                "30"
+            ]
+        }
+    teds = TEDS(n_jobs=4)
+    pred_dict_html = dict_to_html(pred_dict)
+    true_dict_html = dict_to_html(true_dict)
+    print(pred_dict_html)
+    print(true_dict_html)
+
+    scores = teds.evaluate(pred_dict_html, true_dict_html)
+
+    pp = pprint.PrettyPrinter()
+    pp.pprint(scores)

VLMEvalKit-sudoku/vlmeval/dataset/utils/Ocrbench_v2/spotting_eval/rrc_evaluation_funcs_1_1.py

@@ -0,0 +1,456 @@
+# flake8: noqa
+#!/usr/bin/env python3
+
+#File: rrc_evaluation_funcs_1_1.py
+#Version: 1.1
+#Version info: changes for Python 3
+#Date: 2019-12-29
+#Description: File with useful functions to use by the evaluation scripts in the RRC website.
+
+import json
+import sys;
+sys.path.append('./')
+import zipfile
+import re
+import os
+import importlib
+
+def print_help():
+    sys.stdout.write('Usage: python %s.py -g=<gtFile> -s=<submFile> [-o=<outputFolder> -p=<jsonParams>]' %sys.argv[0])
+    sys.exit(2)
+
+
+def load_zip_file_keys(file,fileNameRegExp=''):
+    """
+    Returns an array with the entries of the ZIP file that match with the regular expression.
+    The key's are the names or the file or the capturing group definied in the fileNameRegExp
+    """
+    try:
+        archive=zipfile.ZipFile(file, mode='r', allowZip64=True)
+    except :
+        raise Exception('Error loading the ZIP archive.')
+
+    pairs = []
+
+    for name in archive.namelist():
+        addFile = True
+        keyName = name
+        if fileNameRegExp!="":
+            m = re.match(fileNameRegExp,name)
+            if m == None:
+                addFile = False
+            else:
+                if len(m.groups())>0:
+                    keyName = m.group(1)
+
+        if addFile:
+            pairs.append( keyName )
+
+    return pairs
+
+
+def load_zip_file(file,fileNameRegExp='',allEntries=False):
+    """
+    Returns an array with the contents (filtered by fileNameRegExp) of a ZIP file.
+    The key's are the names or the file or the capturing group definied in the fileNameRegExp
+    allEntries validates that all entries in the ZIP file pass the fileNameRegExp
+    """
+    try:
+        archive=zipfile.ZipFile(file, mode='r', allowZip64=True)
+    except :
+        raise Exception('Error loading the ZIP archive')
+
+    pairs = []
+    for name in archive.namelist():
+        addFile = True
+        keyName = name
+        if fileNameRegExp!="":
+            m = re.match(fileNameRegExp,name)
+            if m == None:
+                addFile = False
+            else:
+                if len(m.groups())>0:
+                    keyName = m.group(1)
+
+        if addFile:
+            pairs.append( [ keyName , archive.read(name)] )
+        else:
+            if allEntries:
+                raise Exception('ZIP entry not valid: %s' %name)
+
+    return dict(pairs)
+
+def decode_utf8(raw):
+    """
+    Returns a Unicode object on success, or None on failure
+    """
+    try:
+        return raw.decode('utf-8-sig',errors = 'replace')
+    except:
+       return None
+
+def validate_lines_in_file(fileName,file_contents,CRLF=True,LTRB=True,withTranscription=False,withConfidence=False,imWidth=0,imHeight=0):
+    """
+    This function validates that all lines of the file calling the Line validation function for each line
+    """
+    utf8File = decode_utf8(file_contents)
+    if (utf8File is None) :
+        raise Exception("The file %s is not UTF-8" %fileName)
+
+    lines = utf8File.split( "\r\n" if CRLF else "\n" )
+    for line in lines:
+        line = line.replace("\r","").replace("\n","")
+        if(line != ""):
+            try:
+                validate_tl_line(line,LTRB,withTranscription,withConfidence,imWidth,imHeight)
+            except Exception as e:
+                raise Exception(("Line in sample not valid. Sample: %s Line: %s Error: %s" %(fileName,line,str(e))).encode('utf-8', 'replace'))
+
+
+
+def validate_tl_line(line,LTRB=True,withTranscription=True,withConfidence=True,imWidth=0,imHeight=0):
+    """
+    Validate the format of the line. If the line is not valid an exception will be raised.
+    If maxWidth and maxHeight are specified, all points must be inside the imgage bounds.
+    Posible values are:
+    LTRB=True: xmin,ymin,xmax,ymax[,confidence][,transcription]
+    LTRB=False: x1,y1,x2,y2,x3,y3,x4,y4[,confidence][,transcription]
+    """
+    get_tl_line_values(line,LTRB,withTranscription,withConfidence,imWidth,imHeight)
+
+
+def get_tl_line_values(line,LTRB=True,withTranscription=False,withConfidence=False,imWidth=0,imHeight=0):
+    """
+    Validate the format of the line. If the line is not valid an exception will be raised.
+    If maxWidth and maxHeight are specified, all points must be inside the imgage bounds.
+    Posible values are:
+    LTRB=True: xmin,ymin,xmax,ymax[,confidence][,transcription]
+    LTRB=False: x1,y1,x2,y2,x3,y3,x4,y4[,confidence][,transcription]
+    Returns values from a textline. Points , [Confidences], [Transcriptions]
+    """
+    confidence = 0.0
+    transcription = "";
+    points = []
+
+    numPoints = 4;
+
+    if LTRB:
+
+        numPoints = 4;
+
+        if withTranscription and withConfidence:
+            m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-1].?[0-9]*)\s*,(.*)$',line)
+            if m == None :
+                m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-1].?[0-9]*)\s*,(.*)$',line)
+                raise Exception("Format incorrect. Should be: xmin,ymin,xmax,ymax,confidence,transcription")
+        elif withConfidence:
+            m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-1].?[0-9]*)\s*$',line)
+            if m == None :
+                raise Exception("Format incorrect. Should be: xmin,ymin,xmax,ymax,confidence")
+        elif withTranscription:
+            m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,(.*)$',line)
+            if m == None :
+                raise Exception("Format incorrect. Should be: xmin,ymin,xmax,ymax,transcription")
+        else:
+            m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,?\s*$',line)
+            if m == None :
+                raise Exception("Format incorrect. Should be: xmin,ymin,xmax,ymax")
+
+        xmin = int(m.group(1))
+        ymin = int(m.group(2))
+        xmax = int(m.group(3))
+        ymax = int(m.group(4))
+        if(xmax<xmin):
+                raise Exception("Xmax value (%s) not valid (Xmax < Xmin)." %(xmax))
+        if(ymax<ymin):
+                raise Exception("Ymax value (%s)  not valid (Ymax < Ymin)." %(ymax))
+
+        points = [ float(m.group(i)) for i in range(1, (numPoints+1) ) ]
+
+        if (imWidth>0 and imHeight>0):
+            validate_point_inside_bounds(xmin,ymin,imWidth,imHeight);
+            validate_point_inside_bounds(xmax,ymax,imWidth,imHeight);
+
+    else:
+
+        numPoints = 8;
+
+        if withTranscription and withConfidence:
+            m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*([0-1].?[0-9]*)\s*,(.*)$',line)
+            if m == None :
+                raise Exception("Format incorrect. Should be: x1,y1,x2,y2,x3,y3,x4,y4,confidence,transcription")
+        elif withConfidence:
+            m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*([0-1].?[0-9]*)\s*$',line)
+            if m == None :
+                raise Exception("Format incorrect. Should be: x1,y1,x2,y2,x3,y3,x4,y4,confidence")
+        elif withTranscription:
+            m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,(.*)$',line)
+            if m == None :
+                raise Exception("Format incorrect. Should be: x1,y1,x2,y2,x3,y3,x4,y4,transcription")
+        else:
+            m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*$',line)
+            if m == None :
+                raise Exception("Format incorrect. Should be: x1,y1,x2,y2,x3,y3,x4,y4")
+
+        points = [ float(m.group(i)) for i in range(1, (numPoints+1) ) ]
+
+        validate_clockwise_points(points)
+
+        if (imWidth>0 and imHeight>0):
+            validate_point_inside_bounds(points[0],points[1],imWidth,imHeight);
+            validate_point_inside_bounds(points[2],points[3],imWidth,imHeight);
+            validate_point_inside_bounds(points[4],points[5],imWidth,imHeight);
+            validate_point_inside_bounds(points[6],points[7],imWidth,imHeight);
+
+
+    if withConfidence:
+        try:
+            confidence = float(m.group(numPoints+1))
+        except ValueError:
+            raise Exception("Confidence value must be a float")
+
+    if withTranscription:
+        posTranscription = numPoints + (2 if withConfidence else 1)
+        transcription = m.group(posTranscription)
+        m2 = re.match(r'^\s*\"(.*)\"\s*$',transcription)
+        if m2 != None : #Transcription with double quotes, we extract the value and replace escaped characters
+            transcription = m2.group(1).replace("\\\\", "\\").replace("\\\"", "\"")
+
+    return points,confidence,transcription
+
+def get_tl_dict_values(detection,withTranscription=False,withConfidence=False,imWidth=0,imHeight=0,validNumPoints=[],validate_cw=True):
+    """
+    Validate the format of the dictionary. If the dictionary is not valid an exception will be raised.
+    If maxWidth and maxHeight are specified, all points must be inside the imgage bounds.
+    Posible values:
+    {"points":[[x1,y1],[x2,y2],[x3,x3],..,[xn,yn]]}
+    {"points":[[x1,y1],[x2,y2],[x3,x3],..,[xn,yn]],"transcription":"###","confidence":0.4,"illegibility":false}
+    {"points":[[x1,y1],[x2,y2],[x3,x3],..,[xn,yn]],"transcription":"###","confidence":0.4,"dontCare":false}
+    Returns values from the dictionary. Points , [Confidences], [Transcriptions]
+    """
+    confidence = 0.0
+    transcription = "";
+    points = []
+
+    if isinstance(detection, dict) == False :
+        raise Exception("Incorrect format. Object has to be a dictionary")
+
+    if not 'points' in detection:
+        raise Exception("Incorrect format. Object has no points key)")
+
+    if isinstance(detection['points'], list) == False :
+        raise Exception("Incorrect format. Object points key have to be an array)")
+
+    num_points = len(detection['points'])
+
+    if num_points<3 :
+        raise Exception("Incorrect format. Incorrect number of points. At least 3 points are necessary. Found: " +  str(num_points))
+
+    if(len(validNumPoints)>0 and num_points in validNumPoints == False ):
+        raise Exception("Incorrect format. Incorrect number of points. Only allowed 4,8 or 12 points)")
+
+    for i in range(num_points):
+        if isinstance(detection['points'][i], list) == False :
+            raise Exception("Incorrect format. Point #" + str(i+1) + " has to be an array)")
+
+        if len(detection['points'][i]) != 2 :
+            raise Exception("Incorrect format. Point #" + str(i+1) + " has to be an array with 2 objects(x,y) )")
+
+        if isinstance(detection['points'][i][0], (int,float) ) == False or isinstance(detection['points'][i][1], (int,float) ) == False :
+            raise Exception("Incorrect format. Point #" + str(i+1) + " childs have to be Integers)")
+
+        if (imWidth>0 and imHeight>0):
+            validate_point_inside_bounds(detection['points'][i][0],detection['points'][i][1],imWidth,imHeight);
+
+        points.append(float(detection['points'][i][0]))
+        points.append(float(detection['points'][i][1]))
+
+    if validate_cw :
+        validate_clockwise_points(points)
+
+    if withConfidence:
+        if not 'confidence' in detection:
+            raise Exception("Incorrect format. No confidence key)")
+
+        if isinstance(detection['confidence'], (int,float)) == False :
+            raise Exception("Incorrect format. Confidence key has to be a float)")
+
+        if detection['confidence']<0 or detection['confidence']>1 :
+            raise Exception("Incorrect format. Confidence key has to be a float between 0.0 and 1.0")
+
+        confidence = detection['confidence']
+
+    if withTranscription:
+        if not 'transcription' in detection:
+            raise Exception("Incorrect format. No transcription key)")
+
+        if isinstance(detection['transcription'], str) == False :
+            raise Exception("Incorrect format. Transcription has to be a string. Detected: " + type(detection['transcription']).__name__ )
+
+        transcription = detection['transcription']
+
+        if 'illegibility' in detection: #Ensures that if illegibility atribute is present and is True the transcription is set to ### (don't care)
+            if detection['illegibility'] == True:
+                transcription = "###"
+
+        if 'dontCare' in detection: #Ensures that if dontCare atribute is present and is True the transcription is set to ### (don't care)
+            if detection['dontCare'] == True:
+                transcription = "###"
+
+    return points,confidence,transcription
+
+def validate_point_inside_bounds(x,y,imWidth,imHeight):
+    if(x<0 or x>imWidth):
+            raise Exception("X value (%s) not valid. Image dimensions: (%s,%s)" %(xmin,imWidth,imHeight))
+    if(y<0 or y>imHeight):
+            raise Exception("Y value (%s)  not valid. Image dimensions: (%s,%s) Sample: %s Line:%s" %(ymin,imWidth,imHeight))
+
+def validate_clockwise_points(points):
+    """
+    Validates that the points are in clockwise order.
+    """
+    edge = []
+    for i in range(len(points)//2):
+        edge.append( (int(points[(i+1)*2 % len(points)]) - int(points[i*2])) * (int(points[ ((i+1)*2+1) % len(points)]) + int(points[i*2+1]))   )
+    if sum(edge)>0:
+        raise Exception("Points are not clockwise. The coordinates of bounding points have to be given in clockwise order. Regarding the correct interpretation of 'clockwise' remember that the image coordinate system used is the standard one, with the image origin at the upper left, the X axis extending to the right and Y axis extending downwards.")
+
+def get_tl_line_values_from_file_contents(content,CRLF=True,LTRB=True,withTranscription=False,withConfidence=False,imWidth=0,imHeight=0,sort_by_confidences=True):
+    """
+    Returns all points, confindences and transcriptions of a file in lists. Valid line formats:
+    xmin,ymin,xmax,ymax,[confidence],[transcription]
+    x1,y1,x2,y2,x3,y3,x4,y4,[confidence],[transcription]
+    """
+    pointsList = []
+    transcriptionsList = []
+    confidencesList = []
+
+    lines = content.split( "\r\n" if CRLF else "\n" )
+    for line in lines:
+        line = line.replace("\r","").replace("\n","")
+        if(line != "") :
+            points, confidence, transcription = get_tl_line_values(line,LTRB,withTranscription,withConfidence,imWidth,imHeight);
+            pointsList.append(points)
+            transcriptionsList.append(transcription)
+            confidencesList.append(confidence)
+
+    if withConfidence and len(confidencesList)>0 and sort_by_confidences:
+        import numpy as np
+        sorted_ind = np.argsort(-np.array(confidencesList))
+        confidencesList = [confidencesList[i] for i in sorted_ind]
+        pointsList = [pointsList[i] for i in sorted_ind]
+        transcriptionsList = [transcriptionsList[i] for i in sorted_ind]
+
+    return pointsList,confidencesList,transcriptionsList
+
+def get_tl_dict_values_from_array(array,withTranscription=False,withConfidence=False,imWidth=0,imHeight=0,sort_by_confidences=True,validNumPoints=[],validate_cw=True):
+    """
+    Returns all points, confindences and transcriptions of a file in lists. Valid dict formats:
+    {"points":[[x1,y1],[x2,y2],[x3,x3],..,[xn,yn]],"transcription":"###","confidence":0.4}
+    """
+    pointsList = []
+    transcriptionsList = []
+    confidencesList = []
+
+    for n in range(len(array)):
+        objectDict = array[n]
+        points, confidence, transcription = get_tl_dict_values(objectDict,withTranscription,withConfidence,imWidth,imHeight,validNumPoints,validate_cw);
+        pointsList.append(points)
+        transcriptionsList.append(transcription)
+        confidencesList.append(confidence)
+
+    if withConfidence and len(confidencesList)>0 and sort_by_confidences:
+        import numpy as np
+        sorted_ind = np.argsort(-np.array(confidencesList))
+        confidencesList = [confidencesList[i] for i in sorted_ind]
+        pointsList = [pointsList[i] for i in sorted_ind]
+        transcriptionsList = [transcriptionsList[i] for i in sorted_ind]
+
+    return pointsList,confidencesList,transcriptionsList
+
+def main_evaluation(p,default_evaluation_params_fn,validate_data_fn,evaluate_method_fn,show_result=True,per_sample=True):
+    """
+    This process validates a method, evaluates it and if it succed generates a ZIP file with a JSON entry for each sample.
+    Params:
+    p: Dictionary of parmeters with the GT/submission locations. If None is passed, the parameters send by the system are used.
+    default_evaluation_params_fn: points to a function that returns a dictionary with the default parameters used for the evaluation
+    validate_data_fn: points to a method that validates the corrct format of the submission
+    evaluate_method_fn: points to a function that evaluated the submission and return a Dictionary with the results
+    """
+
+    if (p == None):
+        p = dict([s[1:].split('=') for s in sys.argv[1:]])
+        if(len(sys.argv)<3):
+            print_help()
+
+    evalParams = default_evaluation_params_fn()
+    if 'p' in p.keys():
+        evalParams.update( p['p'] if isinstance(p['p'], dict) else json.loads(p['p']) )
+
+    resDict={'calculated':True,'Message':'','method':'{}','per_sample':'{}'}
+    try:
+        validate_data_fn(p['g'], p['s'], evalParams)
+        evalData = evaluate_method_fn(p['g'], p['s'], evalParams)
+        resDict.update(evalData)
+
+    except Exception as e:
+        resDict['Message']= str(e)
+        resDict['calculated']=False
+
+    if 'o' in p:
+        if not os.path.exists(p['o']):
+            os.makedirs(p['o'])
+
+        resultsOutputname = p['o'] + '/results.zip'
+        outZip = zipfile.ZipFile(resultsOutputname, mode='w', allowZip64=True)
+
+        del resDict['per_sample']
+        if 'output_items' in resDict.keys():
+            del resDict['output_items']
+
+        outZip.writestr('method.json',json.dumps(resDict))
+
+    if not resDict['calculated']:
+        if show_result:
+            sys.stderr.write('Error!\n'+ resDict['Message']+'\n\n')
+        if 'o' in p:
+            outZip.close()
+        return resDict
+
+    if 'o' in p:
+        if per_sample == True:
+            for k,v in evalData['per_sample'].items():
+                outZip.writestr( k + '.json',json.dumps(v))
+
+        if 'output_items' in evalData.keys():
+            for k, v in evalData['output_items'].items():
+                outZip.writestr( k,v)
+
+        outZip.close()
+
+    # if show_result:
+    #     #sys.stdout.write("Calculated!")
+    #     sys.stdout.write(json.dumps(resDict['method']))
+
+    return resDict
+
+
+def main_validation(default_evaluation_params_fn,validate_data_fn):
+    """
+    This process validates a method
+    Params:
+    default_evaluation_params_fn: points to a function that returns a dictionary with the default parameters used for the evaluation
+    validate_data_fn: points to a method that validates the corrct format of the submission
+    """
+    try:
+        p = dict([s[1:].split('=') for s in sys.argv[1:]])
+        evalParams = default_evaluation_params_fn()
+        if 'p' in p.keys():
+            evalParams.update( p['p'] if isinstance(p['p'], dict) else json.loads(p['p']) )
+
+        validate_data_fn(p['g'], p['s'], evalParams)
+        print ('SUCCESS')
+        sys.exit(0)
+    except Exception as e:
+        print (str(e))
+        sys.exit(101)

VLMEvalKit-sudoku/vlmeval/dataset/utils/__init__.py

@@ -0,0 +1,11 @@
+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 .spatial457 import Spatial457_utils
+
+
+__all__ = [
+    'build_judge', 'extract_answer_from_item', 'prefetch_answer',
+    'levenshtein_distance', 'DEBUG_MESSAGE',
+    'Spatial457_utils'
+]

VLMEvalKit-sudoku/vlmeval/dataset/utils/ccocr_evaluator/ocr_evaluator.py

@@ -0,0 +1,106 @@
+import os
+import sys
+import json
+import re
+from collections import Counter
+
+# local import
+from .common import BaseMetric
+
+
+def token_normalize(token_text, is_lower=False, is_alphanum_only=False):
+    """
+    """
+    if is_lower:
+        token_text = token_text.lower()
+    if is_alphanum_only:
+        token_text = re.sub('[^A-Za-z0-9]+', '', token_text)
+    return token_text
+
+
+def text_normalize_and_tokenize(text, is_keep_blank=True, is_lower=True, is_alphanum_only=False):
+    text = text.replace("\t", " ").replace("\n", " ").replace("###", "").replace("***", "")
+    text = re.sub(r'\s+', ' ', text)
+    if not is_keep_blank:
+        text = text.replace(" ", "")
+    text_tokens = text.split(" ") if is_keep_blank else list(text)
+    text_token_normalized = [token_normalize(t, is_lower, is_alphanum_only) for t in text_tokens]
+    text_token_normalized = [x for x in text_token_normalized if len(x) > 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

VLMEvalKit-sudoku/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

VLMEvalKit-sudoku/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

VLMEvalKit-sudoku/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)

VLMEvalKit-sudoku/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
+        )

VLMEvalKit-sudoku/vlmeval/dataset/utils/mmif/function_and_compare.py

@@ -0,0 +1,429 @@
+# flake8: noqa
+import re
+from typing import List
+import nltk
+# from dotenv import load_dotenv
+
+# load_dotenv()
+
+# # nltk.download("punkt")
+# nltk.data.path.append(
+#     os.environ["NLTK_DATA_PATH"]
+# )
+
+# HumanCheck: True
+
+
+def check_whether_response_paragraph_number_in_range(
+    response: str, lower_bound: int, upper_bound: int
+) -> bool:
+    def clean_text(text: str) -> str:
+        return "\n".join(line.strip() for line in text.splitlines()).strip()
+
+    cleaned_response = clean_text(response)
+
+    # use re to check the number of paragraphs
+    paragraphs = [
+        p for p in re.split(
+            r"\n\s*\n",
+            cleaned_response) if p.strip()]
+
+    actual_count = len(paragraphs)
+    # print(actual_count)
+
+    return lower_bound <= actual_count <= upper_bound
+
+# HumanCheck: True
+
+
+def check_whether_response_sentence_number_in_range(
+    response: str, lower_bound: int, upper_bound: int
+) -> bool:
+    def clean_text(response: str) -> str:
+        return "\n".join(line.strip()
+                         for line in response.splitlines()).strip()
+
+    response = clean_text(response)
+
+    # use nltk to split the response into sentences
+    sentences = nltk.sent_tokenize(response)
+    actual_count = len(sentences)
+    # print(actual_count)
+
+    return lower_bound <= actual_count <= upper_bound
+
+# HumanCheck: True
+
+
+def check_whether_each_paragraph_sentence_number_in_range(
+    response: str, lower_bound: int, upper_bound: int
+) -> bool:
+    def clean_text(text: str) -> str:
+        return "\n".join(line.strip() for line in text.splitlines()).strip()
+
+    cleaned_response = clean_text(response)
+
+    # use re to check the number of paragraphs
+    paragraphs = [
+        p for p in re.split(
+            r"\n\s*\n",
+            cleaned_response) if p.strip()]
+
+    for i, paragraph in enumerate(paragraphs):
+        # use nltk to split the paragraph into sentences
+        sentences = nltk.sent_tokenize(paragraph)
+        actual_count = len(sentences)
+        # print(f"paragraph {i}: {actual_count}")
+        if actual_count < lower_bound or actual_count > upper_bound:
+            return False
+
+    return True
+
+# HumanCheck: True
+
+
+def check_whether_each_paragraph_sentence_number_in_range_list(
+    response: str, ranges: List[List[int]]
+) -> bool:
+    def clean_text(text: str) -> str:
+        return "\n".join(line.strip() for line in text.splitlines()).strip()
+
+    cleaned_response = clean_text(response)
+
+    # use re to check the number of paragraphs
+    paragraphs = [
+        p for p in re.split(
+            r"\n\s*\n",
+            cleaned_response) if p.strip()]
+
+    if len(paragraphs) != len(ranges):
+        return False
+
+    for i, (paragraph, range_pair) in enumerate(zip(paragraphs, ranges)):
+        lower_bound, upper_bound = range_pair
+        sentences = nltk.sent_tokenize(paragraph)
+        actual_count = len(sentences)
+        # print(f"paragraph {i}: {actual_count}")
+        if not (lower_bound <= actual_count <= upper_bound):
+            return False
+
+    return True
+
+# HumanCheck: True
+
+
+def check_whether_response_word_count_in_range(
+    response: str, lower_bound: int, upper_bound: int
+) -> bool:
+    # this line is used to filter out all non-word characters
+    response_clean = re.sub(r"[^\w\s.-]", "", response)
+    word_list = response_clean.split()
+    word_count = len(word_list)
+    # print(word_count)
+    return lower_bound <= word_count <= upper_bound
+
+# HumanCheck: True
+
+
+def check_whether_each_paragraph_word_count_in_range(
+    response: str, lower_bound: int, upper_bound: int
+) -> bool:
+    # Check whether the number of words in each paragraph of the response is greater than or equal to lower_bound and less than or equal to upper_bound.
+    # Here are some examples of calling this function based on constraints:
+    # If the constraint requires that the number of words in each paragraph
+    # should be between 50 and 80, then lower_bound = 50 and upper_bound = 80.
+    def clean_text(text: str) -> str:
+        return "\n".join(line.strip() for line in text.splitlines()).strip()
+
+    cleaned_response = clean_text(response)
+
+    # use re to check the number of paragraphs
+    paragraphs = [
+        p for p in re.split(
+            r"\n\s*\n",
+            cleaned_response) if p.strip()]
+
+    for i, paragraph in enumerate(paragraphs):
+        paragraph_clean = re.sub(r"[^\w\s.-]", "", paragraph)
+        word_count = len(paragraph_clean.split())
+        # print(f"paragraph {i} word count: {word_count}")
+        if not (lower_bound <= word_count <= upper_bound):
+            return False
+
+    return True
+
+# HumanCheck: True
+
+
+def check_whether_whole_response_not_contain_certain_substrings(
+    response: str, substrings: List[str]
+) -> bool:
+    # Check whether the entire response does not contain any of the specified substrings.
+    # Here are some examples of calling this function based on constraints:
+    # If the constraint requires that the response should not contain the
+    # words "apple" and "banana", then substrings = ["apple", "banana"].
+    return all(substring not in response for substring in substrings)
+
+# HumanCheck: True
+
+
+def check_whether_whole_response_not_contain_certain_substring(
+    response: str, substring: str
+) -> bool:
+    return substring not in response
+
+# HumanCheck: True
+
+
+def check_whether_each_sentence_begin_with_certain_substring(
+    response: str, substring: str
+) -> bool:
+    # Check whether each sentence in the response starts with the specified substring.
+    # Here are some examples of calling this function based on constraints:
+    # If the constraint requires that each sentence should start with
+    # exclamation point, then substring = "!".
+    def clean_text(response: str) -> str:
+        return "\n".join(line.strip()
+                         for line in response.splitlines()).strip()
+
+    response = clean_text(response)
+
+    sentences = nltk.sent_tokenize(response)
+
+    return all(sentence.startswith(substring) for sentence in sentences)
+
+# HumanCheck: True
+
+
+def check_whether_each_paragraph_begin_with_certain_substring(
+    response: str, substring: str
+) -> bool:
+    def clean_text(response: str) -> str:
+        return "\n".join(line.strip()
+                         for line in response.splitlines()).strip()
+
+    cleaned_response = clean_text(response)
+
+    paragraphs = [
+        p for p in re.split(
+            r"\n\s*\n",
+            cleaned_response) if p.strip()]
+
+    return all(paragraph.startswith(substring) for paragraph in paragraphs)
+
+# HumanCheck: True
+
+
+def check_whether_each_paragraph_end_with_certain_substring(
+    response: str, substring: str
+) -> bool:
+    def clean_text(response: str) -> str:
+        return "\n".join(line.strip()
+                         for line in response.splitlines()).strip()
+
+    cleaned_response = clean_text(response)
+
+    paragraphs = [
+        p for p in re.split(
+            r"\n\s*\n",
+            cleaned_response) if p.strip()]
+
+    return all(paragraph.endswith(substring) for paragraph in paragraphs)
+
+# HumanCheck: True
+
+
+def check_whether_each_sentence_end_with_certain_substring(
+    response: str, substring: str
+) -> bool:
+    def clean_text(response: str) -> str:
+        return "\n".join(line.strip()
+                         for line in response.splitlines()).strip()
+
+    response = clean_text(response)
+
+    sentences = nltk.sent_tokenize(response)
+
+    return all(sentence.endswith(substring) for sentence in sentences)
+
+# HumanCheck: True
+
+
+def check_whether_whole_response_begin_with_certain_substring(
+    response: str, substring: str
+) -> bool:
+    return response.strip().startswith(substring)
+
+# HumanCheck: True
+
+
+def check_whether_whole_response_end_with_certain_substring(
+    response: str, substring: str
+) -> bool:
+    return response.strip().endswith(substring)
+
+# HumanCheck: True
+
+
+def check_whether_each_keyword_in_list_metioned_in_range(
+        response: str,
+        keywords: List[str],
+        lower_bound_times: int,
+        upper_bound_times: int) -> bool:
+    # should notice case like "Reddit" is counted as "Redditor"
+    def clean_text(response: str) -> str:
+        return "\n".join(line.strip()
+                         for line in response.splitlines()).strip()
+
+    response = clean_text(response)
+    response_lower = response.lower()
+
+    for keyword in keywords:
+        # use \b to match the whole word
+        pattern = r'\b' + re.escape(keyword.lower()) + r'\b'
+        matches = re.findall(pattern, response_lower)
+        if len(matches) < lower_bound_times or len(
+                matches) > upper_bound_times:
+            return False
+
+    return True
+
+# HumanCheck: True
+
+
+def check_whether_total_keyword_in_list_metioned_in_range(
+        response: str,
+        keywords: List[str],
+        lower_bound_times: int,
+        upper_bound_times: int) -> bool:
+    # should notice case like "Reddit" is counted as "Redditor"
+    def clean_text(response: str) -> str:
+        return "\n".join(line.strip()
+                         for line in response.splitlines()).strip()
+
+    response = clean_text(response)
+    response_lower = response.lower()
+
+    count = 0
+    for keyword in keywords:
+        pattern = r'\b' + re.escape(keyword.lower()) + r'\b'
+        matches = re.findall(pattern, response_lower)
+        count += len(matches)
+
+    return lower_bound_times <= count <= upper_bound_times
+
+# HumanCheck: True
+
+
+def check_percentage_number_precision_in_response(
+        response: str, precision: int) -> bool:
+    # All numeric values that appear before a percentage sign (%) must be
+    # rounded and retained to two decimal places.
+    pattern = r'(\d+\.\d+|\d+)\s*%'  # allow numbers and % to have spaces
+
+    matches = re.findall(pattern, response)
+
+    for num_str in matches:
+        if '.' not in num_str:
+            # no decimal point, not a float number
+            return False
+        decimal_part = num_str.split('.')[1]
+        if len(decimal_part) != precision:
+            return False
+
+    return True
+
+# HumanCheck: True
+
+
+def check_number_precision_in_response(response: str, precision: int) -> bool:
+    # Regex pattern to extract numbers, including scientific notation and
+    # percentages
+    number_pattern = r'''
+        (?<!\w)                     # Not preceded by a word character
+        [+-]?                      # Optional sign
+        (?:                        # Number formats:
+            \d{1,3}(?:,\d{3})*(?:\.\d+)?   # e.g., 1,234.56
+            | \d+\.\d+             # e.g., 123.456
+            | \.\d+                # e.g., .456
+            | \d+                  # e.g., 123
+        )
+        (?:[eE][+-]?\d+)?          # Optional scientific notation
+        %?                         # Optional percentage
+        (?!\w)                     # Not followed by a word character
+    '''
+
+    matches = re.finditer(number_pattern, response, flags=re.VERBOSE)
+
+    for match in matches:
+        num_str = match.group()
+        clean_num = num_str.replace(',', '').rstrip('%')
+
+        # Split out mantissa if scientific notation
+        if 'e' in clean_num.lower():
+            mantissa = re.split('[eE]', clean_num)[0]
+        else:
+            mantissa = clean_num
+
+        # Check digits after decimal in mantissa
+        if '.' in mantissa:
+            decimal_part = mantissa.split('.')[-1]
+            if len(decimal_part) != precision:
+                return False
+        else:
+            if precision != 0:
+                return False
+
+    return True
+
+# HumanCheck: True
+
+
+def check_whether_has_no_arabic_number_in_response(response: str) -> bool:
+    number_pattern = r"""
+        (?<![.\w])                            # Ensure no preceding . or word char
+        (?:                                   # Start of number pattern
+            \d{1,3}(?:,\d{3})+(?:\.\d+)?%?    |  # 1,000 or 1,000.00 or 1,000%
+            \d+\.\d+%?                        |  # decimals: 3.14, 0.5%
+            \d+%?                             |  # integers: 100, 100%
+            \d+(?:\.\d+)?(?:[eE][+-]?\d+)        # scientific: 5e-10, 5.09e-10
+        )
+        (?![.\w])                             # Ensure no trailing . or word char
+    """
+    numbers = re.findall(
+        number_pattern,
+        response,
+        flags=re.IGNORECASE | re.VERBOSE)
+    # print(numbers)
+    return len(numbers) == 0
+
+# HumanCheck: True
+# def check_scientific_notation_precision_in_response(
+#     response: str, significant_digits: int
+# ) -> bool:
+#     scientific_pattern = r"(?<!\w)(?:\d+\.\d+|\d+)(?:[eE][+-]?\d+)(?!\w)"
+
+#     numbers = re.findall(scientific_pattern, response)
+
+#     for number in numbers:
+#         # Split into base and exponent
+#         parts = re.split(r"[eE]", number.lower())
+#         if len(parts) != 2:
+#             continue  # Skip invalid scientific notation
+
+#         base, exponent = parts
+
+#         # Handle cases like "0.000" or "0"
+#         if all(c == "0" for c in base.replace(".", "")):
+#             base_digits = "0"  # Treat as 0 with 1 significant digit
+#         else:
+#             # Remove leading and trailing zeros (but keep significant zeros)
+#             base_digits = base.replace(".", "").lstrip("0") or "0"
+
+#         significant_count = len(base_digits)
+#         print(f"Number: {number}, Significant digits: {significant_count}")
+
+#         if significant_count != significant_digits:
+#             return False
+
+#     return True

VLMEvalKit-sudoku/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

VLMEvalKit-sudoku/vlmeval/vlm/hawk_vl/__init__.py

@@ -0,0 +1,2 @@
+from .model import HawkVL
+from .prompt import HawkVLPromptMixin