Add files using upload-large-folder tool

VLMEvalKit-sudoku/vlmeval/dataset/charxiv.py

@@ -0,0 +1,256 @@
+import os
+import json
+from typing import Dict, List, Tuple, Any, Union
+import pandas as pd
+import warnings
+
+from vlmeval.dataset.image_base import ImageBaseDataset
+from vlmeval.smp import misc, file
+from vlmeval.smp.file import get_intermediate_file_path
+from vlmeval import utils
+from vlmeval.dataset.utils import build_judge
+
+
+def auxeval(judge_model: Any, line: pd.Series, **kwargs: Any) -> Dict[str, Any]:
+    """
+    Evaluate a line using the judge model.
+
+    Args:
+        judge_model: The model used for evaluation
+        line: A pandas Series containing the data to evaluate
+        **kwargs: Additional arguments for the judge model
+
+    Returns:
+        Dict containing evaluation results with extract_answer and score
+    """
+    failure_result = {"extract_answer": "Failed to parse response", "score": 0.0}
+    prompt = line["grading_query"].replace("{PREDICTION}", line["prediction"])
+
+    retry = kwargs.get("retry", 10)
+    max_tokens = kwargs.get("max_tokens", 256)
+    temperature = kwargs.get("temperature", 0)
+    seed = kwargs.get("seed", 42)
+    top_p = kwargs.get("top_p", 1)
+
+    for _ in range(retry):
+        try:
+            response = judge_model.generate(
+                prompt,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                seed=seed,
+                top_p=top_p,
+            )
+            content = json.loads(response)
+            if not isinstance(content, dict):
+                return failure_result
+            if "score" not in content or "extract_answer" not in content:
+                return failure_result
+            return content
+        except Exception:
+            continue
+
+    return failure_result
+
+
+def qid2category(mode: str) -> Tuple[Dict[int, str], str]:
+    """
+    Map question IDs to their categories based on the evaluation mode.
+
+    Args:
+        mode: Either "descriptive" or "reasoning"
+
+    Returns:
+        Tuple containing a mapping dictionary and the index column name
+
+    Raises:
+        ValueError: If the mode is not recognized
+    """
+    if mode == "descriptive":
+        index_col = "qid"
+        return {
+            1: "Information Extraction",
+            2: "Information Extraction",
+            3: "Information Extraction",
+            4: "Information Extraction",
+            5: "Information Extraction",
+            6: "Information Extraction",
+            7: "Information Extraction",
+            8: "Enumeration",
+            9: "Enumeration",
+            10: "Counting",
+            11: "Pattern Recognition",
+            12: "Counting",
+            13: "Enumeration",
+            14: "Enumeration",
+            15: "Enumeration",
+            16: "Pattern Recognition",
+            17: "Compositionality",
+            18: "Pattern Recognition",
+            19: "Counting",
+        }, index_col
+    elif mode == "reasoning":
+        index_col = "inst_category"
+        return {
+            1: "Text-in-Chart",
+            2: "Text-in-General",
+            3: "Number-in-Chart",
+            4: "Number-in-General",
+        }, index_col
+    else:
+        raise ValueError(f"Invalid mode: {mode}")
+
+
+class CharXiv(ImageBaseDataset):
+    TYPE = "VQA"
+    DATASET_URL = {
+        "CharXiv_descriptive_val": "http://opencompass.openxlab.space/utils/VLMEval/CharXiv_descriptive_val.tsv",
+        "CharXiv_reasoning_val": "http://opencompass.openxlab.space/utils/VLMEval/CharXiv_reasoning_val.tsv",
+    }
+    DATASET_MD5 = {
+        "CharXiv_descriptive_val": "e165037032f169a59dd09ea5d7ad3073",
+        "CharXiv_reasoning_val": "98eeff269b40726982627b19338ccd45",
+    }
+
+    def build_prompt(self, line: Union[int, pd.Series]) -> List[Dict[str, str]]:
+        """
+        Build a prompt for the model from a data line.
+
+        Args:
+            line: Either an index into the dataset or a pandas Series
+
+        Returns:
+            List of message dictionaries containing the image and question
+        """
+        if isinstance(line, int):
+            line = self.data.iloc[line]
+
+        if self.meta_only:
+            tgt_path = misc.toliststr(line["image"])
+        else:
+            tgt_path = self.dump_image(line)
+
+        messages = [{"type": "image", "value": tgt_path[0]}]
+        messages.append({"type": "text", "value": line["question"]})
+        return messages
+
+    def get_scores(self, result_file: str) -> pd.DataFrame:
+        """
+        Calculate scores by category from evaluation results.
+
+        Args:
+            result_file: Path to the file containing evaluation results
+
+        Returns:
+            DataFrame with scores for each category and overall score
+
+        Raises:
+            ValueError: If the dataset name is invalid
+        """
+        data = file.load(result_file)
+
+        if "descriptive" in self.dataset_name:
+            mode = "descriptive"
+        elif "reasoning" in self.dataset_name:
+            mode = "reasoning"
+        else:
+            raise ValueError(f"Invalid dataset name: {self.dataset_name}")
+
+        category_map, index_col = qid2category(mode)
+
+        # Group scores by category
+        scores_by_category = {}
+        for _, row in data.iterrows():
+            category = category_map[row[index_col]]
+            if category not in scores_by_category:
+                scores_by_category[category] = []
+            scores_by_category[category].append(row["score"])
+
+        # Calculate average score for each category
+        result = {}
+        for category, scores in scores_by_category.items():
+            result[category] = [sum(scores) / len(scores)]
+
+        # Calculate overall score
+        result["Overall"] = [
+            sum(sum(scores) for scores in scores_by_category.values()) / len(data)
+        ]
+
+        return pd.DataFrame(result)
+
+    def evaluate(self, eval_file: str, **judge_kwargs: Any) -> pd.DataFrame:
+        """
+        Evaluate model predictions on the CharXiv dataset.
+
+        Args:
+            eval_file: Path to the file containing model predictions
+            **judge_kwargs: Additional arguments for the judge model
+
+        Returns:
+            DataFrame with evaluation scores by category
+        """
+        # Set up judge model
+        if "LOCAL_LLM" in os.environ:
+            judge_model = os.path.basename(os.environ.get("LOCAL_LLM"))
+        else:
+            judge_model = judge_kwargs.get("model", "gpt-4o-mini")
+
+        if judge_model != "gpt-4o-mini":
+            warnings.warn(
+                f"The judge_model '{judge_model}' is not gpt-4o-mini. Evaluation results may not be accurate."
+            )
+
+        judge_model = build_judge(model=judge_model, **judge_kwargs)
+        judge_model_name = judge_model.model
+
+        # Define file paths
+        result_file = get_intermediate_file_path(eval_file, f"_{judge_model_name}")
+        temp_result_file = get_intermediate_file_path(eval_file, f"_{judge_model_name}", "pkl")
+        score_file = get_intermediate_file_path(result_file, "_acc", "csv")
+
+        # Return existing results if available
+        if os.path.exists(result_file):
+            score = self.get_scores(result_file)
+            file.dump(score, score_file)
+            return score
+
+        data = file.load(eval_file)
+        if "score" not in data.columns:
+            data["score"] = 0
+        if "extract_answer" not in data.columns:
+            data["extract_answer"] = ""
+
+        # Load intermediate results if available
+        processed_results = {}
+        if os.path.exists(temp_result_file):
+            processed_results = file.load(temp_result_file)
+
+        # Identify unprocessed indices
+        indices = [i for i in range(len(data)) if i not in processed_results]
+        tups = [(judge_model, data.iloc[i]) for i in range(len(data)) if i not in processed_results]
+
+        # Process remaining examples
+        nproc = judge_kwargs.pop("nproc", 4)
+        if len(indices):
+            utils.track_progress_rich(
+                auxeval,
+                tups,
+                nproc=nproc,
+                chunksize=nproc,
+                keys=indices,
+                save=temp_result_file,
+                **judge_kwargs,
+            )
+            processed_results = file.load(temp_result_file)
+
+        # Update data with evaluation results
+        data["score"] = data.apply(lambda x: processed_results[x.name]["score"], axis=1)
+        data["extract_answer"] = data.apply(
+            lambda x: processed_results[x.name]["extract_answer"], axis=1
+        )
+
+        # Save results and return scores
+        file.dump(data, result_file)
+        score = self.get_scores(result_file)
+        file.dump(score, score_file)
+        return score

VLMEvalKit-sudoku/vlmeval/dataset/spatial457.py

@@ -0,0 +1,212 @@
+import os
+import re
+import tempfile
+from functools import partial
+
+import pandas as pd
+
+from .image_base import ImageBaseDataset
+from .utils import build_judge, DEBUG_MESSAGE, Spatial457_utils
+from ..smp import *
+from ..utils import track_progress_rich
+
+
+class Spatial457(ImageBaseDataset):
+    TYPE = "VQA"
+    # When ROBUST is True, if the models does not follow the format, all of the response will be treated as answers.
+    ROBUST = True
+
+    DATASET_URL = {
+        "Spatial457": "http://opencompass.openxlab.space/utils/VLMEval/Spatial457.tsv",
+    }
+
+    DATASET_MD5 = {
+        'Spatial457': "1f24f5a7b2cadc3d33a8a66ecf92ca68"
+    }
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.dataset_utils = Spatial457_utils()
+
+    def evaluate(self, eval_file, **judge_kwargs):
+
+        data = load(eval_file)
+        data['prediction'] = [str(x) for x in data['prediction']]
+        lt = len(data)
+        lines = [data.iloc[i] for i in range(lt)]
+
+        all_results = {
+            "correct": 0,
+            "total": 0,
+            "answers": [],
+            "format_error": 0,
+            "L1_single": 0,
+            "L2_objects": 0,
+            "L3_2d_spatial": 0,
+            "L4_occ": 0,
+            "L4_pose": 0,
+            "L5_6d_spatial": 0,
+            "L5_collision": 0,
+            "L1_single_correct": 0,
+            "L2_objects_correct": 0,
+            "L3_2d_spatial_correct": 0,
+            "L4_occ_correct": 0,
+            "L4_pose_correct": 0,
+            "L5_6d_spatial_correct": 0,
+            "L5_collision_correct": 0,
+        }
+
+        for i in tqdm(range(len(lines))):
+
+            line = lines[i]
+            index = int(line["index"])
+
+            answers = str(line["answer"])
+            level = line["category"]
+            objects = []
+
+            # parse the answer
+            pred_try_1 = re.search(r"Answer': '(.*?)'", line["prediction"])
+            pred_try_2 = re.search(r'Answer": "(.*?)"', line["prediction"])
+            pred_try_3 = re.search(r"Answer': (\d)", line["prediction"])
+
+            if pred_try_1:
+                pred = pred_try_1.group(1)
+            elif pred_try_2:
+                pred = pred_try_2.group(1)
+            elif pred_try_3:
+                pred = pred_try_3.group(1)
+            else:
+                if self.ROBUST:
+                    pred = line['prediction']
+                else:
+                    pred = self.dataset_utils.get_random_answer(answers)
+                all_results["format_error"] += 1
+
+            reasoning_try_1 = re.search(r"Reasoning': '(.*?)'", line["prediction"])
+            reasoning_try_2 = re.search(r'Reasoning": "(.*?)"', line["prediction"])
+
+            if reasoning_try_1:
+                reasoning = reasoning_try_1.group(1)
+            elif reasoning_try_2:
+                reasoning = reasoning_try_2.group(1)
+            else:
+                if self.ROBUST:
+                    reasoning = "Format Error. All of the resposne as the answer."
+                else:
+                    reasoning = "Format Error. Guess a random answer."
+
+            correct = self.dataset_utils.is_correct(answers, pred)
+
+            all_results["answers"].append(
+                {
+                    "index": index,
+                    "correct": correct,
+                    "answers": answers,
+                    "predict": pred,
+                    "reasoning": reasoning,
+                    "objects": objects,
+                }
+            )
+
+            all_results["total"] += 1
+            if correct:
+                all_results["correct"] += 1
+
+            all_results[f"{level}"] += 1
+            if correct:
+                all_results[f"{level}_correct"] += 1
+
+        all_results["score"] = all_results["correct"] / all_results["total"]
+
+        for level in [
+            "L1_single",
+            "L2_objects",
+            "L3_2d_spatial",
+            "L4_occ",
+            "L4_pose",
+            "L5_6d_spatial",
+            "L5_collision",
+        ]:
+            all_results[f"{level}_score"] = (
+                all_results[f"{level}_correct"] / all_results[level] if all_results[level] > 0 else 0
+            )
+
+        score_pth = get_intermediate_file_path(eval_file, "_score", "json")
+
+        dump(all_results, score_pth)
+        return all_results
+
+    def build_prompt(self, line):
+        msgs = super().build_prompt(line)
+
+        set_type = line["category"]
+
+        instruction_1, instruction_2 = self.build_subtask_instruction(set_type)
+
+        msgs.insert(0, {"type": "text", "value": instruction_1})
+        msgs.append({"type": "text", "value": instruction_2})
+
+        return msgs
+
+    def build_subtask_instruction(self, level):
+
+        task_map = {
+            "L1_single": (
+                "You are an intelligent chatbot designed to answer questions based on an image. Your task is to "
+                "analyze the images, identify attributes of the objects, "
+                "and then determine the answer to the question.\n"
+            ),
+            "L2_objects": (
+                "You are an intelligent chatbot designed to answer questions based on an image. Your task is to "
+                "analyze the images, identify attributes of multiple objects, "
+                "and then determine the answer to the question.\n"
+            ),
+            "L3_2d_spatial": (
+                "You are an intelligent chatbot designed to answer questions based on an image. Your task is to "
+                "analyze the images, identify attributes of multiple objects and their spatial relationship from 2D "
+                "projected camera view, and then determine the answer to the question.\n"
+            ),
+            "L4_occ": (
+                "You are an intelligent chatbot designed to answer questions based on an image. Your task is to "
+                "analyze the images, identify attributes of multiple objects and their occlusion relationships, and "
+                "then determine the answer to the question.\n"
+            ),
+            "L4_pose": (
+                "You are an intelligent chatbot designed to answer questions based on an image. Your task is to "
+                "analyze the images, identify attributes of multiple objects and their facing direction in 3D space "
+                "from the camera view, and then determine the answer to the question.\n"
+            ),
+            "L5_6d_spatial": (
+                "You are an intelligent chatbot designed to answer questions based on an image. Your task is to "
+                "analyze the images, identify attributes of multiple objects and their spatial relationship from "
+                "objects’ perspective in 3D space, and then determine the answer to the question.\n"
+            ),
+            "L5_collision": (
+                "You are an intelligent chatbot designed to answer questions based on an image. Your task is to "
+                "analyze the images, identify attributes of multiple objects and their potential collision given the "
+                "assumption of moving direction in 3D space, and then determine the answer to the question.\n"
+            ),
+        }
+
+        instruction_1 = task_map.get(level, "")
+
+        instruction_2 = (
+            "First, you should identify the related objects refered in the questions, including their shape, "
+            "color, size; then add a brief reasoning process about the questions. Each object in the image has a "
+            "shape (e.g., 'airliner'), a size (only can be 'small' or 'large'), a color (e.g. 'blue'). The size of "
+            "the object is either 'small' or 'large'. The color of the object is one of the following: 'gray', "
+            "'blue', 'purple', 'brown', 'green', 'cyan', 'red', 'yellow'. The direction of the object is one of the "
+            "following: 'left', 'right', 'front', 'back'.\n\n"
+            "Second, give the answer based on the reasoning process. The answer should only be (1) a phrase chosen "
+            "from the following options: {}, or (2) an integer [0-10] when asked for 'How many' or 'What is the "
+            "number of', or (3) 'Yes' or 'No' when asked for 'Is there'. If you think there are no possible answers "
+            "or the question is not clear, choose the best answer that fits the question.\n\n"
+        ).format(self.dataset_utils.all_answers())
+
+        instruction_2 += (
+            "Write your response into this json template: " "{'Reasoning': '<your reasons>', 'Answer': '<Your answer>'}"
+        )
+
+        return instruction_1, instruction_2

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

@@ -0,0 +1,50 @@
+import pandas as pd
+from ...smp import *
+
+
+FAIL_MSG = "Failed to obtain answer via API."
+
+
+def build_prompt_ayavision(line):
+    question = line["question"]
+    prediction = str(line["prediction"])
+    answer = str(line["answer"])
+
+    tmpl = (
+        "You are an expert evaluator. Your task is to determine if the predicted answer "
+        "is a correct response to the given question, using the ground truth answer as a reference. "
+        "The predicted answer does not need to be a verbatim match of the ground truth, "
+        "but it must be semantically equivalent and accurately answer the question.\n"
+        "Respond with '[[CORRECT]]' if the prediction is correct, and '[[WRONG]]' if it is incorrect. "
+        "Do not provide any explanation.\n\n"
+        "Question: {question}\n"
+        "Ground Truth Answer: {answer}\n"
+        "Predicted Answer: {prediction}\n\n"
+        "Is the prediction correct? "
+    )
+    return tmpl.format(question=question, answer=answer, prediction=prediction)
+
+
+def AyaVision_auxeval(model, line):
+    prompt = build_prompt_ayavision(line)
+    log = ""
+    retry = 5
+
+    for i in range(retry):
+        res = model.generate(prompt, temperature=i * 0.5)
+
+        if FAIL_MSG in res:
+            log += f"Try {i}: output is {res}, failed to parse.\\n"
+        elif "[[CORRECT]]" in res:
+            log += "Succeed"
+            hit = 1
+            return dict(log=log, res=res, hit=hit)
+        elif "[[WRONG]]" in res:
+            log += "Succeed"
+            hit = 0
+            return dict(log=log, res=res, hit=hit)
+        else:
+            log += f"Try {i}: output is {res}, failed to parse.\\n"
+
+    log += "All 5 retries failed.\\n"
+    return dict(log=log, res="", hit=0)

VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/eval_req.txt

@@ -0,0 +1,5 @@
+pdf2image
+colormath
+squarify
+matplotlib_venn
+Pillow

VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/chart_type_and_color.py

@@ -0,0 +1,971 @@
+# flake8: noqa
+import inspect
+from matplotlib.patches import Ellipse
+from matplotlib.image import NonUniformImage
+from matplotlib.projections.polar import PolarAxes
+import networkx.drawing.nx_pylab as nx_pylab
+import matplotlib.colors as mcolors
+from mpl_toolkits.mplot3d import Axes3D
+from matplotlib.axes._axes import Axes
+from matplotlib.axes._base import _process_plot_var_args
+import matplotlib.pyplot as plt
+import matplotlib
+import squarify
+
+import warnings
+warnings.filterwarnings("ignore", category=UserWarning)
+
+# sys.path.insert(0, f'{os.environ["PROJECT_PATH"]}')
+
+
+drawed_colors = []
+in_decorator = False
+
+
+def convert_color_to_hex(color):
+    'Convert color from name, RGBA, or hex to a hex format.'
+    try:
+        # First, try to convert from color name to RGBA to hex
+        if isinstance(color, str):
+            # Check if it's already a hex color (start with '#' and length
+            # either 7 or 9)
+            if color.startswith('#') and (len(color) == 7 or len(color) == 9):
+                return color.upper()
+            else:
+                return mcolors.to_hex(mcolors.to_rgba(color)).upper()
+        # Then, check if it's in RGBA format
+        elif isinstance(color, (list, tuple)) and len(color) == 4:
+            return mcolors.to_hex(color).upper()
+        else:
+            raise ValueError("Unsupported color format")
+    except ValueError as e:
+        print(color)
+        print("Error converting color:", e)
+        return None
+
+
+def log_function_specific_for_draw_networkx_labels(func):
+    def wrapper(
+        G,
+        pos,
+        labels=None,
+        font_size=12,
+        font_color="k",
+        font_family="sans-serif",
+        font_weight="normal",
+        alpha=None,
+        bbox=None,
+        horizontalalignment="center",
+        verticalalignment="center",
+        ax=None,
+        clip_on=True,
+    ):
+        global drawed_colors
+        global in_decorator
+
+        if not in_decorator:
+            in_decorator = True
+
+            func_name = inspect.getfile(func) + "/" + func.__name__
+
+            result = func(
+                G,
+                pos,
+                labels=labels,
+                font_size=font_size,
+                font_color=font_color,
+                font_family=font_family,
+                font_weight=font_weight,
+                alpha=alpha,
+                bbox=bbox,
+                horizontalalignment=horizontalalignment,
+                verticalalignment=verticalalignment,
+                ax=ax,
+                clip_on=clip_on
+            )
+
+            for item in result.values():
+                color = convert_color_to_hex(item.get_color())
+                drawed_colors.append(func_name + "--" + color)
+
+            in_decorator = False
+        else:
+            return func(
+                G,
+                pos,
+                labels=labels,
+                font_size=font_size,
+                font_color=font_color,
+                font_family=font_family,
+                font_weight=font_weight,
+                alpha=alpha,
+                bbox=bbox,
+                horizontalalignment=horizontalalignment,
+                verticalalignment=verticalalignment,
+                ax=ax,
+                clip_on=clip_on
+            )
+        return result
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+def log_function_specific_for_draw_networkx_edges(func):
+    def wrapper(
+        G,
+        pos,
+        edgelist=None,
+        width=1.0,
+        edge_color="k",
+        style="solid",
+        alpha=None,
+        arrowstyle=None,
+        arrowsize=10,
+        edge_cmap=None,
+        edge_vmin=None,
+        edge_vmax=None,
+        ax=None,
+        arrows=None,
+        label=None,
+        node_size=300,
+        nodelist=None,
+        node_shape="o",
+        connectionstyle="arc3",
+        min_source_margin=0,
+        min_target_margin=0,
+    ):
+        global drawed_colors
+        global in_decorator
+
+        if not in_decorator:
+            in_decorator = True
+
+            func_name = inspect.getfile(func) + "/" + func.__name__
+
+            result = func(
+                G,
+                pos,
+                edgelist=edgelist,
+                width=width,
+                edge_color=edge_color,
+                style=style,
+                alpha=alpha,
+                arrowstyle=arrowstyle,
+                arrowsize=arrowsize,
+                edge_cmap=edge_cmap,
+                edge_vmin=edge_vmin,
+                edge_vmax=edge_vmax,
+                ax=ax,
+                arrows=arrows,
+                label=label,
+                node_size=node_size,
+                nodelist=nodelist,
+                node_shape=node_shape,
+                connectionstyle=connectionstyle,
+                min_source_margin=min_source_margin,
+                min_target_margin=min_target_margin
+            )
+
+            for item in result.get_edgecolors().tolist():
+                color = convert_color_to_hex(item)
+                drawed_colors.append(func_name + "--" + color)
+
+            in_decorator = False
+        else:
+            return func(
+                G,
+                pos,
+                edgelist=edgelist,
+                width=width,
+                edge_color=edge_color,
+                style=style,
+                alpha=alpha,
+                arrowstyle=arrowstyle,
+                arrowsize=arrowsize,
+                edge_cmap=edge_cmap,
+                edge_vmin=edge_vmin,
+                edge_vmax=edge_vmax,
+                ax=ax,
+                arrows=arrows,
+                label=label,
+                node_size=node_size,
+                nodelist=nodelist,
+                node_shape=node_shape,
+                connectionstyle=connectionstyle,
+                min_source_margin=min_source_margin,
+                min_target_margin=min_target_margin
+            )
+        return result
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+def log_function_specific_for_draw_networkx_nodes(func):
+    def wrapper(
+        G,
+        pos,
+        nodelist=None,
+        node_size=300,
+        node_color="#1f78b4",
+        node_shape="o",
+        alpha=None,
+        cmap=None,
+        vmin=None,
+        vmax=None,
+        ax=None,
+        linewidths=None,
+        edgecolors=None,
+        label=None,
+        margins=None,
+    ):
+        global drawed_colors
+        global in_decorator
+
+        if not in_decorator:
+            in_decorator = True
+
+            func_name = inspect.getfile(func) + "/" + func.__name__
+
+            result = func(
+                G,
+                pos,
+                nodelist=nodelist,
+                node_size=node_size,
+                node_color=node_color,
+                node_shape=node_shape,
+                alpha=alpha,
+                cmap=cmap,
+                vmin=vmin,
+                vmax=vmax,
+                ax=ax,
+                linewidths=linewidths,
+                edgecolors=edgecolors,
+                label=label,
+                margins=margins
+            )
+
+            for item in result.get_facecolors().tolist():
+                color = convert_color_to_hex(item)
+                drawed_colors.append(func_name + "--" + color)
+
+            in_decorator = False
+        else:
+            return func(
+                G,
+                pos,
+                nodelist=nodelist,
+                node_size=node_size,
+                node_color=node_color,
+                node_shape=node_shape,
+                alpha=alpha,
+                cmap=cmap,
+                vmin=vmin,
+                vmax=vmax,
+                ax=ax,
+                linewidths=linewidths,
+                edgecolors=edgecolors,
+                label=label,
+                margins=margins
+            )
+        return result
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+def log_function_for_3d(func):
+    def wrapper(*args, **kwargs):
+        global drawed_colors
+        global in_decorator
+
+        if not in_decorator:
+            in_decorator = True
+
+            func_name = inspect.getfile(func) + "/" + func.__name__
+
+            result = func(*args, **kwargs)
+
+            if func.__name__ == "scatter":
+                # check whether cmap is used
+                if "cmap" in kwargs and kwargs["cmap"] is not None:
+                    print("cmap is used", kwargs["cmap"])
+                    drawed_colors.append(func_name + "--" + kwargs["cmap"])
+                else:
+                    for item in result.get_facecolors().tolist():
+                        color = convert_color_to_hex(item)
+                        drawed_colors.append(func_name + "--" + color)
+            elif func.__name__ == "plot":
+                for line in result:
+                    color = convert_color_to_hex(line.get_color())
+                    drawed_colors.append(func_name + "--" + color)
+            elif func.__name__ == "plot_surface":
+                if "cmap" in kwargs and kwargs["cmap"] is not None:
+                    print("cmap is used", kwargs["cmap"])
+                    drawed_colors.append(func_name + "--" + kwargs["cmap"])
+                else:
+                    colors = result.get_facecolors().tolist()
+                    drawed_colors.append(
+                        func_name +
+                        "--" +
+                        convert_color_to_hex(
+                            colors[0]))
+            elif func.__name__ == "bar3d":
+                colors = result.get_facecolors().tolist()
+                drawed_colors.append(
+                    func_name +
+                    "--" +
+                    convert_color_to_hex(
+                        colors[0]))
+            elif func.__name__ == "bar":
+                for item in result:
+                    color = convert_color_to_hex(item.get_facecolor())
+                    drawed_colors.append(func_name + "--" + color)
+            elif func.__name__ == "add_collection3d":
+                colors = result.get_facecolors().tolist()
+                for color in colors:
+                    drawed_colors.append(
+                        func_name + "--" + convert_color_to_hex(color))
+
+            in_decorator = False
+        else:
+            return func(*args, **kwargs)
+        return result
+
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+def log_function(func):
+    def wrapper(*args, **kwargs):
+        global drawed_colors
+        global in_decorator
+
+        if not in_decorator:
+            in_decorator = True
+
+            func_name = inspect.getfile(func) + "/" + func.__name__
+
+            result = func(*args, **kwargs)
+
+            if func.__name__ == "_makeline":
+                color = convert_color_to_hex(result[1]["color"])
+                drawed_colors.append(func_name + "--" + color)
+            elif func.__name__ == "axhline":
+                color = convert_color_to_hex(result.get_color())
+                drawed_colors.append(func_name + "--" + color)
+            elif func.__name__ == "axvline":
+                color = convert_color_to_hex(result.get_color())
+                drawed_colors.append(func_name + "--" + color)
+            elif func.__name__ == "_fill_between_x_or_y":
+                color = convert_color_to_hex(list(result.get_facecolors()[0]))
+                drawed_colors.append(func_name + "--" + color)
+            elif func.__name__ == "bar":
+                for item in result:
+                    color = convert_color_to_hex(
+                        list(item._original_facecolor))
+                    drawed_colors.append(func_name + "--" + color)
+            elif func.__name__ == "scatter" and not isinstance(args[0], PolarAxes):
+                # check whether cmap is used
+                if "cmap" in kwargs and kwargs["cmap"] is not None:
+                    print("cmap is used", kwargs["cmap"])
+                    drawed_colors.append(func_name + "--" + kwargs["cmap"])
+                else:
+                    color = convert_color_to_hex(
+                        list(result.get_facecolor()[0]))
+                    drawed_colors.append(func_name + "--" + color)
+            elif func.__name__ == "pie":
+                for item in result[0]:
+                    color = convert_color_to_hex(item.get_facecolor())
+                    drawed_colors.append(func_name + "--" + color)
+            elif func.__name__ == "axvspan":
+                color = convert_color_to_hex(result.get_facecolor())
+                drawed_colors.append(func_name + "--" + color)
+            elif func.__name__ == "axhspan":
+                color = convert_color_to_hex(result.get_facecolor())
+                drawed_colors.append(func_name + "--" + color)
+            elif func.__name__ == "hlines":
+                for item in result.get_edgecolors():
+                    color = convert_color_to_hex(list(item))
+                    drawed_colors.append(func_name + "--" + color)
+            elif func.__name__ == "vlines":
+                for item in result.get_edgecolors():
+                    color = convert_color_to_hex(list(item))
+                    drawed_colors.append(func_name + "--" + color)
+            elif func.__name__ == "boxplot":
+                for item in result["boxes"]:
+                    if isinstance(item, matplotlib.patches.PathPatch):
+                        color = convert_color_to_hex(
+                            list(item.get_facecolor()))
+                        drawed_colors.append(func_name + "--" + color)
+            elif func.__name__ == "violinplot":
+                for item in result["bodies"]:
+                    color = convert_color_to_hex(list(item.get_facecolor()[0]))
+                    drawed_colors.append(func_name + "--" + color)
+            elif func.__name__ == "hist":
+                tops, bins, patches = result
+                if not isinstance(patches, matplotlib.cbook.silent_list):
+                    for item in patches:
+                        color = convert_color_to_hex(
+                            list(item.get_facecolor()))
+                        drawed_colors.append(func_name + "--" + color)
+                else:
+                    for container in patches:
+                        for item in container:
+                            color = convert_color_to_hex(
+                                list(item.get_facecolor()))
+                            drawed_colors.append(func_name + "--" + color)
+            elif func.__name__ == "quiver":
+                for item in result.get_facecolors().tolist():
+                    color = convert_color_to_hex(item)
+                    drawed_colors.append(func_name + "--" + color)
+            elif func.__name__ == "plot" and len(args) > 0 and isinstance(args[0], PolarAxes):
+                lines = result
+                for line in lines:
+                    color = convert_color_to_hex(line.get_color())
+                    drawed_colors.append(func_name + "_polar" + "--" + color)
+            elif func.__name__ == "scatter" and isinstance(args[0], PolarAxes):
+                # check whether cmap is used
+                if "cmap" in kwargs and kwargs["cmap"] is not None:
+                    print("cmap is used", kwargs["cmap"])
+                    drawed_colors.append(func_name + "--" + kwargs["cmap"])
+                else:
+                    color = convert_color_to_hex(
+                        list(result.get_facecolor()[0]))
+                    drawed_colors.append(func_name + "_polar" + "--" + color)
+            elif func.__name__ == "plot" and "squarify" in func_name:
+                # get ax
+                ax = result
+                # get container
+                containers = ax.containers
+                for container in containers:
+                    for item in container:
+                        color = convert_color_to_hex(
+                            list(item.get_facecolor()))
+                        drawed_colors.append(
+                            func_name + "_squarify" + "--" + color)
+            elif func.__name__ == "imshow":
+                colormap = result.get_cmap().name
+                drawed_colors.append(func_name + "--" + colormap)
+            elif func.__name__ == "pcolor":
+                colormap = result.get_cmap().name
+                drawed_colors.append(func_name + "--" + colormap)
+            elif func.__name__ == "contour":
+                colormap = result.get_cmap().name
+                drawed_colors.append(func_name + "--" + colormap)
+            elif func.__name__ == "contourf":
+                colormap = result.get_cmap().name
+                drawed_colors.append(func_name + "--" + colormap)
+            elif func.__name__ == "fill":
+                patches = result
+                for patch in patches:
+                    color = convert_color_to_hex(list(patch.get_facecolor()))
+                    drawed_colors.append(func_name + "--" + color)
+            elif func.__name__ == "__init__" and isinstance(args[0], NonUniformImage):
+                colormap = args[0].get_cmap().name
+                drawed_colors.append(func_name + "--" + colormap)
+            elif func.__name__ == "broken_barh":
+                colors = result.get_facecolors().tolist()
+                for color in colors:
+                    drawed_colors.append(
+                        func_name + "--" + convert_color_to_hex(color))
+            elif func.__name__ == "__init__" and isinstance(args[0], Ellipse):
+                color = convert_color_to_hex(args[0].get_facecolor())
+                drawed_colors.append(func_name + "--" + color)
+
+            in_decorator = False
+        else:
+            return func(*args, **kwargs)
+        return result
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+_process_plot_var_args._makeline = log_function(
+    _process_plot_var_args._makeline)
+Axes.bar = log_function(Axes.bar)
+Axes.scatter = log_function(Axes.scatter)
+Axes.axhline = log_function(Axes.axhline)
+Axes.axvline = log_function(Axes.axvline)
+Axes._fill_between_x_or_y = log_function(Axes._fill_between_x_or_y)
+Axes.pie = log_function(Axes.pie)
+Axes.axvspan = log_function(Axes.axvspan)
+Axes.axhspan = log_function(Axes.axhspan)
+Axes.hlines = log_function(Axes.hlines)
+Axes.vlines = log_function(Axes.vlines)
+Axes.boxplot = log_function(Axes.boxplot)
+Axes.violinplot = log_function(Axes.violinplot)
+Axes.hist = log_function(Axes.hist)
+Axes.plot = log_function(Axes.plot)
+Axes.quiver = log_function(Axes.quiver)
+Axes.imshow = log_function(Axes.imshow)
+Axes.pcolor = log_function(Axes.pcolor)
+Axes.contour = log_function(Axes.contour)
+Axes.contourf = log_function(Axes.contourf)
+Axes.fill = log_function(Axes.fill)
+NonUniformImage.__init__ = log_function(NonUniformImage.__init__)
+Ellipse.__init__ = log_function(Ellipse.__init__)
+Axes.broken_barh = log_function(Axes.broken_barh)
+
+nx_pylab.draw_networkx_nodes = log_function_specific_for_draw_networkx_nodes(
+    nx_pylab.draw_networkx_nodes)
+nx_pylab.draw_networkx_edges = log_function_specific_for_draw_networkx_edges(
+    nx_pylab.draw_networkx_edges)
+nx_pylab.draw_networkx_labels = log_function_specific_for_draw_networkx_labels(
+    nx_pylab.draw_networkx_labels)
+
+
+squarify.plot = log_function(squarify.plot)
+
+Axes3D.scatter = log_function_for_3d(Axes3D.scatter)
+Axes3D.plot = log_function_for_3d(Axes3D.plot)
+Axes3D.plot_surface = log_function_for_3d(Axes3D.plot_surface)
+Axes3D.bar3d = log_function_for_3d(Axes3D.bar3d)
+Axes3D.bar = log_function_for_3d(Axes3D.bar)
+Axes3D.add_collection3d = log_function_for_3d(Axes3D.add_collection3d)
+
+# barh test
+# draw a simple barh plot
+# fig, ax = plt.subplots()
+# ax.barh(np.arange(5), np.random.rand(5))
+# ax.barh(np.arange(5), np.random.rand(5))
+# plt.show()
+
+# axhline test
+# fig, ax = plt.subplots()
+# ax.axhline(0.5)
+# ax.axhline(0.8)
+# plt.show()
+
+# axvline test
+# fig, ax = plt.subplots()
+# ax.axvline(0.5)
+# ax.axvline(0.8)
+# plt.show()
+
+# errorbar test
+# fig, ax = plt.subplots()
+# x = np.arange(10)
+# y = np.sin(x)
+#
+# ax.errorbar(x, y, yerr=0.1)
+# ax.errorbar(x, y, yerr=0.2)
+# plt.show()
+
+# squarify test
+# fig, ax = plt.subplots()
+# sizes = [50, 25, 25]
+# squarify.plot(sizes=sizes, ax=ax)
+# plt.savefig("tmp.png")
+# plt.show()
+
+# loglog test
+# fig, ax = plt.subplots()
+# x = np.linspace(0, 10, 100)
+# y = x**2
+# ax.loglog(x, y)
+# plt.show()
+
+# fill_between test
+# fig, ax = plt.subplots()
+# x = np.arange(10)
+# y1 = np.sin(x)
+# y2 = np.cos(x)
+# ax.fill_between(x, y1, y2, cmap='viridis')
+# plt.show()
+
+# fill_betweenx test
+# fig, ax = plt.subplots()
+# x = np.arange(10)
+# y1 = np.sin(x)
+# y2 = np.cos(x)
+# ax.fill_betweenx(x, y1, y2, cmap='viridis')
+# plt.show()
+
+# pie test
+# fig, ax = plt.subplots()
+# sizes = [50, 25, 25]
+# ax.pie(sizes)
+# plt.savefig("tmp.png")
+# plt.show()
+
+# axvspan test
+# fig, ax = plt.subplots()
+# ax.axvspan(0.2, 0.3, color='red', alpha=0.5)
+# ax.axvspan(0.5, 0.7, color='blue', alpha=0.5)
+# plt.show()
+
+# axhspan test
+# fig, ax = plt.subplots()
+# ax.axhspan(0.2, 0.3, color='red', alpha=0.5)
+# ax.axhspan(0.5, 0.7, color='blue', alpha=0.5)
+# plt.show()
+
+
+# hlines test
+# fig, ax = plt.subplots()
+# y_values = [1, 2, 3, 4, 5]
+# xmin = 0
+# xmax = 10
+# ax.hlines(y=y_values, xmin=xmin, xmax=xmax, linestyles='dashed')
+# ax.set_xlabel('X-axis')
+# ax.set_ylabel('Y-axis')
+# plt.savefig("tmp.png")
+# plt.show()
+
+# vlines test
+# fig, ax = plt.subplots()
+# x_values = [1, 2, 3, 4, 5]
+# ymin = 0
+# ymax = 10
+# ax.vlines(x=x_values, ymin=ymin, ymax=ymax, linestyles='dashed')
+# ax.set_xlabel('X-axis')
+# ax.set_ylabel('Y-axis')
+# plt.savefig("tmp.png")
+# plt.show()
+
+# boxplot test
+# fig, ax = plt.subplots()
+# data = np.random.rand(10, 3)
+# ax.boxplot(data, patch_artist=True)
+# plt.savefig("tmp.png")
+# plt.show()
+
+# violin test
+# fig, ax = plt.subplots()
+# data = np.random.rand(10, 3)
+# ax.violinplot(data)
+# plt.savefig("tmp.png")
+# plt.show()
+
+# hist test
+# fig, ax = plt.subplots()
+# data = np.random.rand(100, 1)
+# ax.hist(data, bins=10)
+# plt.savefig("tmp.png")
+# plt.show()
+
+
+# networkx test
+# fig, ax = plt.subplots()
+# G = networkx.complete_graph(5)
+# draw the graph, give each node a different color, and a label. make the edges red and blue, with labels
+# networkx.draw(G, ax=ax, node_color='r', edge_color='b', labels={0: '0', 1: '1', 2: '2', 3: '3', 4: '4'})
+# plt.savefig("tmp.png")
+# plt.show()
+
+# quiver test
+# fig, ax = plt.subplots()
+# x = np.linspace(0, 10, 10)
+# y = np.linspace(0, 10, 10)
+# u = np.zeros(10)
+# v = np.ones(10)
+# # draw the quiver plot, with color red
+# ax.quiver(x, y, u, v, color='r')
+# plt.savefig("tmp.png")
+# plt.show()
+
+# 3d scatter test
+# fig, ax = plt.subplots(subplot_kw={'projection': '3d'})
+# x = np.random.rand(10)
+# y = np.random.rand(10)
+# z = np.random.rand(10)
+# draw the scatter plot, with color red
+# ax.scatter3D(x, y, z, c='#ff2395')
+# plt.savefig("tmp.png")
+# plt.show()
+
+# 3d plot test
+# fig, ax = plt.subplots(subplot_kw={'projection': '3d'})
+# draw two lines in 3d, with color red and blue
+# ax.plot([0, 1], [0, 1], [0, 1], color='r')
+# ax.plot([0, 1], [0, 1], [1, 0], color='b')
+
+# 3d plot_surface test
+# fig, ax = plt.subplots(subplot_kw={'projection': '3d'})
+# draw a surface plot, with a beautiful colormap
+# X = np.linspace(-5, 5, 100)
+# Y = np.linspace(-5, 5, 100)
+# X, Y = np.meshgrid(X, Y)
+# Z = np.sin(np.sqrt(X**2 + Y**2))
+# ax.plot_surface(X, Y, Z, cmap='viridis')
+# plt.savefig("tmp.png")
+# plt.show()
+
+# 3d bar test
+# fig, ax = plt.subplots(subplot_kw={'projection': '3d'})
+# x = np.arange(10)
+# y = np.random.rand(10)
+# z = np.zeros(10)
+# dx = np.ones(10)
+# dy = np.ones(10)
+# dz = np.random.rand(10)
+# # draw the 3d bar plot, with color red
+# ax.bar3d(x, y, z, dx, dy, dz)
+# plt.savefig("tmp.png")
+# plt.show()
+
+# # bar2d in axes3d test
+# fig, ax = plt.subplots(subplot_kw={'projection': '3d'})
+# x = np.arange(10)
+# y = np.random.rand(10)
+# z = np.zeros(10)
+# dx = np.ones(10)
+# dy = np.ones(10)
+# dz = np.random.rand(10)
+# # draw the 2d bar plot, with color red
+# ax.bar(x, y, z, zdir='y', color=['r', 'b', 'g', 'y', 'm', 'c', 'k', 'w', 'r', 'b'])
+# plt.savefig("tmp.png")
+# plt.show()
+
+
+# plot in test
+# fig, ax = plt.subplots()
+# x = np.linspace(0, 10, 100)
+# y = np.sin(x)
+# draw the plot, with color red
+# ax.plot(x, y, color='r')
+# plt.savefig("tmp.png")
+# plt.show()
+
+# matshow in test
+# fig, ax = plt.subplots()
+# data = np.random.rand(10, 10)
+# draw the matshow plot, with a beautiful colormap
+# ax.imshow(data, cmap='pink')
+# plt.savefig("tmp.png")
+# plt.show()
+
+# pcolor in test
+# fig, ax = plt.subplots()
+# data = np.random.rand(10, 10)
+# draw the pcolor plot, with a beautiful colormap
+# ax.pcolor(data)
+# plt.savefig("tmp.png")
+# plt.show()
+
+# # contour in test
+# fig, ax = plt.subplots()
+# x = np.linspace(0, 10, 100)
+# y = np.linspace(0, 10, 100)
+# X, Y = np.meshgrid(x, y)
+# Z = np.sin(X) * np.cos(Y)
+# # draw the contour plot, with a beautiful colormap
+# ax.contour(X, Y, Z)
+# plt.savefig("tmp.png")
+# plt.show()
+
+# # contourf in test
+# fig, ax = plt.subplots()
+# x = np.linspace(0, 10, 100)
+# y = np.linspace(0, 10, 100)
+# X, Y = np.meshgrid(x, y)
+# Z = np.sin(X) * np.cos(Y)
+# # draw the contourf plot, with a beautiful colormap
+# ax.contourf(X, Y, Z, cmap='viridis')
+# plt.savefig("tmp.png")
+# plt.show()
+
+# stackplot in test
+# fig, ax = plt.subplots()
+# x = np.linspace(0, 10, 100)
+# y1 = np.sin(x)
+# y2 = np.cos(x)
+# y3 = np.tan(x)
+# draw the stackplot, with beautiful colors
+# ax.stackplot(x, y1, y2, y3, colors=['r', 'g', 'b'])
+# plt.savefig("tmp.png")
+# plt.show()
+
+# fill in test
+# fig, ax = plt.subplots()
+# x = np.linspace(0, 10, 100)
+# y1 = np.sin(x)
+# y2 = np.cos(x)
+# draw the fill plot, with color red
+# ax.fill(x, y1, color='r')
+# plt.savefig("tmp.png")
+# plt.show()
+
+
+# # NonUniformImage in test
+# fig, ax = plt.subplots()
+# data = np.random.rand(10, 10)
+# x = np.linspace(-4, 4, 9)
+# y = np.linspace(-4, 4, 9)
+# z = np.sqrt(x[np.newaxis, :] ** 2 + y[:, np.newaxis] ** 2)
+# im = NonUniformImage(ax, interpolation='bilinear')
+# im.set_data(x, y , z)
+# ax.add_image(im)
+# plt.savefig("tmp.png")
+# plt.show()
+
+# broken_barh in test
+# fig, ax = plt.subplots()
+# x = np.linspace(0, 10, 100)
+# y = np.sin(x)
+# draw the broken_barh plot, with color red
+# ax.broken_barh([(1, 2), (3, 4)], (0, 1), facecolors='r')
+# plt.savefig("tmp.png")
+# plt.show()
+
+
+# Ellipse in test
+fig, ax = plt.subplots()
+e = matplotlib.patches.Ellipse((0.5, 0.5), 0.4, 0.2, color='r')
+ax.add_patch(e)
+plt.savefig("tmp.png")
+plt.show()
+
+
+# # radar plot in test
+# fig, ax = plt.subplots(subplot_kw={'projection': 'polar'})
+# theta = np.linspace(0, 2*np.pi, 100)
+# r = np.sin(3*theta)**2
+# # draw the radar plot, with color red
+# ax.plot(theta, r, color='r')
+# plt.savefig("tmp.png")
+# plt.show()
+
+
+# import numpy as np; np.random.seed(0)
+
+# import matplotlib.pyplot as plt
+# from matplotlib.lines import Line2D
+
+# # ===================
+# # Part 2: Data Preparation
+# # ===================
+# # Data for PC1 and PC2
+# values_pc1 = [0.8, 0.7, 0.6, 0.85, 0.9, 0.75, 0.7, 0.65, 0.8, 0.9]
+# values_pc2 = [0.6, 0.55, 0.5, 0.45, 0.4, 0.35, 0.3, 0.25, 0.2, 0.15]
+# num_vars = len(values_pc1)
+
+# # Compute angle for each axis
+# angles = np.linspace(0, 2 * np.pi, num_vars, endpoint=False).tolist()
+
+# # The plot is circular, so we need to "complete the loop" and append the start to the end.
+# values_pc1 += values_pc1[:1]
+# values_pc2 += values_pc2[:1]
+# angles += angles[:1]
+
+# # ===================
+# # Part 3: Plot Configuration and Rendering
+# # ===================
+# # Draw the radar chart
+# fig, ax = plt.subplots(figsize=(8, 8), subplot_kw=dict(polar=True))
+# ax.fill(angles, values_pc1, color="black", alpha=0.1)
+# ax.plot(angles, values_pc1, color="black", linewidth=2, label="Loadings PC1")
+# ax.scatter(angles[:-1], values_pc1[:-1], color="black", s=50)
+# ax.fill(angles, values_pc2, color="red", alpha=0.1)
+# ax.plot(angles, values_pc2, color="red", linewidth=2, label="Loadings PC2")
+# ax.scatter(angles[:-1], values_pc2[:-1], color="red", s=50)
+
+# # Add labels to the plot
+# ax.set_yticklabels([])
+# grid_angles = np.linspace(0, 2 * np.pi, 8, endpoint=False)
+# ax.set_xticks(grid_angles)
+# angle_labels = [f"{i*45}°" for i in range(8)]
+# ax.set_xticklabels(angle_labels)
+
+# # Add grid lines and labels for the concentric circles
+# ax.set_rgrids(
+#     [0.2, 0.4, 0.6, 0.8, 1.0],
+#     labels=["0.2", "0.4", "0.6", "0.8", "1.0"],
+#     angle=30,
+#     color="black",
+#     size=10,
+# )
+
+# # Create legend handles manually
+# legend_elements = [
+#     Line2D(
+#         [0],
+#         [0],
+#         color="black",
+#         linewidth=2,
+#         marker="o",
+#         markersize=8,
+#         label="Loadings PC1",
+#     ),
+#     Line2D(
+#         [0],
+#         [0],
+#         color="red",
+#         linewidth=2,
+#         marker="o",
+#         markersize=8,
+#         label="Loadings PC2",
+#     ),
+# ]
+
+# # Add legend and title
+# ax.legend(
+#     handles=legend_elements, loc="upper right", bbox_to_anchor=(1.1, 1.1), frameon=False
+# )
+
+# # ===================
+# # Part 4: Saving Output
+# # ===================
+# # Adjust layout and save the plot
+# plt.tight_layout()
+# plt.savefig('tmp.png')
+
+
+# poly3d in test
+# import math
+# import matplotlib.pyplot as plt
+# import numpy as np; np.random.seed(0)
+
+# from matplotlib.collections import PolyCollection
+
+# # ===================
+# # Part 2: Data Preparation
+# # ===================
+# # Fixing random state for reproducibility
+# def polygon_under_graph(x, y):
+#     """
+#     Construct the vertex list which defines the polygon filling the space under
+#     the (x, y) line graph. This assumes x is in ascending order.
+#     """
+#     return [(x[0], 0.0), *zip(x, y), (x[-1], 0.0)]
+
+
+# x = np.linspace(0.0, 10.0, 31)
+# vaccination_numbers = range(1, 4)
+
+# # verts[i] is a list of (x, y) pairs defining polygon i.
+# gamma = np.vectorize(math.gamma)
+# verts = [
+#     polygon_under_graph(x, v**x * np.exp(-v) / gamma(x + 1))
+#     for v in vaccination_numbers
+# ]
+
+# # ===================
+# # Part 3: Plot Configuration and Rendering
+# # ===================
+# ax = plt.figure(figsize=(8, 6)).add_subplot(projection="3d")
+# facecolors = plt.colormaps["viridis_r"](np.linspace(0, 1, len(verts)))
+
+# poly = PolyCollection(verts, facecolors=facecolors, alpha=0.7)
+# ax.add_collection3d(poly, zs=vaccination_numbers, zdir="y")
+
+# ax.set(
+#     xlim=(0, 10),
+#     ylim=(1, 4),
+#     zlim=(0, 0.35),
+#     xlabel="Age",
+#     ylabel="Vaccination Number",
+#     zlabel="Incidence Rate",
+# )
+
+# ax.set_yticks([1, 2, 3])
+# ax.set_box_aspect(aspect=None, zoom=0.8)
+
+# # ===================
+# # Part 4: Saving Output
+# # ===================
+# plt.tight_layout()
+# plt.savefig('3d_14.pdf', bbox_inches='tight')
+
+
+drawed_colors = set(drawed_colors)
+print("drawed_colors", drawed_colors)

VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/evaluator/chart_type_evaluator.py

@@ -0,0 +1,179 @@
+# flake8: noqa
+from typing import Dict
+# from dotenv import load_dotenv
+# load_dotenv()
+
+import os
+from ..eval_configs.global_config import run_script_safe
+
+
+class ChartTypeEvaluator:
+
+    def __init__(self):
+        self.metrics = {
+            "precision": 0,
+            "recall": 0,
+            "f1": 0
+        }
+
+    def __call__(self, generation_code_file, golden_code_file):
+        generation_chart_types = self._get_chart_types(generation_code_file)
+        golden_chart_types = self._get_chart_types(golden_code_file)
+
+        self.golden_code_file = golden_code_file
+
+        self._calculate_metrics(generation_chart_types, golden_chart_types)
+
+        # [TAG] What is this for?
+        # redunant_file = os.environ["VLMEVAL_CHARTMIMIC_UTILS_PATH"] + "/" + os.path.basename(golden_code_file).replace(".py", ".pdf")
+        # print(f"redunant_file: {redunant_file}")
+        # breakpoint()
+        # # if os.path.exists(redunant_file) == True:
+        # os.remove(redunant_file)
+
+        # print(self.metrics)
+
+    def _get_chart_types(self, code_file):
+
+        with open(code_file, "r") as f:
+            lines = f.readlines()
+        code = "".join(lines)
+
+        prefix = self._get_prefix()
+        output_file = code_file.replace(".py", "_log_chart_types.txt")
+        suffix = self._get_suffix(output_file)
+        code = prefix + code + suffix
+
+        code_log_chart_types_file = code_file.replace(
+            ".py", "_log_chart_types.py")
+        with open(code_log_chart_types_file, "w") as f:
+            f.write(code)
+
+        # os.system(f"python {code_log_chart_types_file}")
+        success = run_script_safe(code_log_chart_types_file)
+        if not success:
+            print("Skip downstream logic due to previous failure.")
+            # optionally return default result or continue
+
+        if os.path.exists(output_file):
+            with open(output_file, "r") as f:
+                chart_types = f.read()
+                chart_types = eval(chart_types)
+            os.remove(output_file)
+        else:
+            chart_types = {}
+        os.remove(code_log_chart_types_file)
+
+        # pdf_file = re.findall(r"plt\.savefig\('(.*)'\)", code)
+        # if len(pdf_file) != 0:
+        # pdf_file = pdf_file[0].split(",")[0][:-1]
+        # print(pdf_file)
+        # if os.path.basename(pdf_file) == pdf_file:
+        # os.remove(pdf_file)
+
+        return chart_types
+
+    def _calculate_metrics(
+            self, generation_chart_types: Dict[str, int], golden_chart_types: Dict[str, int]):
+        """
+        Calculate precision, recall, and f1 score of the chart types.
+
+        Args:
+            - generation_chart_types: Dict[str, int]
+                - key: chart type
+                - value: number of times the chart type is called
+            - golden_chart_types: Dict[str, int]
+                - key: chart type
+                - value: number of times the chart type is called
+        """
+        if len(generation_chart_types) == 0:
+            return
+
+        n_correct = 0
+        total = sum(generation_chart_types.values())
+
+        for chart_type, count in generation_chart_types.items():
+            if chart_type in golden_chart_types:
+                n_correct += min(count, golden_chart_types[chart_type])
+
+        self.metrics["precision"] = n_correct / total
+        try:
+            self.metrics["recall"] = n_correct / \
+                sum(golden_chart_types.values())
+        except BaseException:
+            print(
+                "<<<<<<<<<<<<<<<<<<<<golden_code_file",
+                self.golden_code_file)
+        if self.metrics["precision"] + self.metrics["recall"] == 0:
+            self.metrics["f1"] = 0
+        else:
+            self.metrics["f1"] = 2 * self.metrics["precision"] * \
+                self.metrics["recall"] / (self.metrics["precision"] + self.metrics["recall"])
+        return
+
+    def _get_prefix(self):
+        with open(os.environ["VLMEVAL_CHARTMIMIC_UTILS_PATH"] + "/evaluator/chart_type_evaluator_prefix.py", "r") as f:
+            prefix = f.read()
+        return prefix
+
+#     def _get_prefix(self):
+#         return f"""
+# import warnings
+# warnings.filterwarnings("ignore", category=UserWarning)
+
+# import sys
+# sys.path.insert(0, '{os.environ['PROJECT_PATH']}')
+# import matplotlib.pyplot as plt
+# from matplotlib.axes import Axes
+# import squarify
+# import inspect
+
+# called_functions = {{}}
+# in_decorator = False
+
+# def log_function(func):
+#     def wrapper(*args, **kwargs):
+#         global in_decorator
+#         if not in_decorator:
+#             in_decorator = True
+#             # name = func.__name__
+#             file_name = inspect.getfile(func)
+#             name = file_name + "-" + func.__name__
+#             called_functions[name] = called_functions.get(name, 0) + 1
+#             result = func(*args, **kwargs)
+#             in_decorator = False
+#             return result
+#         else:
+#             return func(*args, **kwargs)
+#     return wrapper
+
+# Axes.plot = log_function(Axes.plot)
+# Axes.loglog = log_function(Axes.loglog)
+# Axes.scatter = log_function(Axes.scatter)
+# Axes.bar = log_function(Axes.bar)
+# Axes.barh = log_function(Axes.barh)
+# Axes.axhline = log_function(Axes.axhline)
+# Axes.axvline = log_function(Axes.axvline)
+# Axes.errorbar = log_function(Axes.errorbar)
+# Axes.matshow = log_function(Axes.matshow)
+# Axes.hist = log_function(Axes.hist)
+# Axes.pie = log_function(Axes.pie)
+# Axes.boxplot = log_function(Axes.boxplot)
+# Axes.arrow = log_function(Axes.arrow)
+# Axes.fill_between = log_function(Axes.fill_between)
+# Axes.fill_betweenx = log_function(Axes.fill_betweenx)
+# Axes.imshow = log_function(Axes.imshow)
+# Axes.contour = log_function(Axes.contour)
+# Axes.contourf = log_function(Axes.contourf)
+# Axes.violinplot = log_function(Axes.violinplot)
+# Axes.violin = log_function(Axes.violin)
+
+# squarify.plot = log_function(squarify.plot)
+# """
+
+    def _get_suffix(self, output_file):
+        return f"""
+# print(called_functions)
+with open('{output_file}', 'w') as f:
+    f.write(str(called_functions))
+"""

VLMEvalKit-sudoku/vlmeval/dataset/utils/chartmimic/mp_util.py

@@ -0,0 +1,76 @@
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from tqdm import tqdm
+import traceback
+import os
+from typing import Callable, Iterable
+from ....smp import *
+
+logger = get_logger("ChartMimic/mp_util")
+
+
+def track_progress_rich_new(
+    func: Callable,
+    tasks: Iterable = tuple(),
+    nproc: int = 1,
+    save=None,
+    keys=None,
+    **kwargs
+) -> list:
+    """
+    Parallel execution with progress tracking and safe interim saving.
+    """
+    # Prepare persistent storage
+    if save:
+        os.makedirs(os.path.dirname(save), exist_ok=True)
+        if not os.path.exists(save):
+            dump({}, save)
+        res = load(save)
+    else:
+        res = {}
+
+    results = [None] * len(tasks)
+    future_to_idx = {}
+
+    # Use process pool to bypass GIL for CPU-bound tasks
+    with ProcessPoolExecutor(max_workers=nproc) as executor:
+        for idx, inp in enumerate(tasks):
+            # Support dict, tuple/list, or single-value tasks
+            if isinstance(inp, dict):
+                future = executor.submit(func, **inp)
+            elif isinstance(inp, (list, tuple)):
+                future = executor.submit(func, *inp)
+            else:
+                future = executor.submit(func, inp)
+            future_to_idx[future] = idx
+
+        # Display progress bar as tasks complete
+        with tqdm(total=len(tasks)) as pbar:
+            for future in as_completed(future_to_idx):
+                idx = future_to_idx[future]
+                key = keys[idx] if keys else None
+                try:
+                    result = future.result()
+                except Exception as e:
+                    exc_type = type(e).__name__
+                    err_msg = f"[{exc_type}] Exception in task {key or idx}: {str(e)}"
+                    logger.error(err_msg)
+                    logger.error("Full traceback:")
+                    logger.error(traceback.format_exc())
+
+                    # Optional: attach traceback to result for downstream
+                    # reference
+                    result = getattr(e, 'result', (-1, {
+                        'msg': err_msg,
+                        'traceback': traceback.format_exc(),
+                    }))
+
+                results[idx] = result
+                # Update persistent results
+                if keys and key is not None:
+                    res[key] = result
+                if save:
+                    dump(res, save)  # save after each task
+
+                pbar.update(1)
+
+    return results

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

@@ -0,0 +1,54 @@
+from ...smp import *
+import os
+
+
+def report_acc_hrbench(df):
+    cycle_group = df.groupby('cycle_category')
+    result_dic = defaultdict(list)
+    avg_dic = defaultdict(int)
+
+    count = 0
+    for key, data_value in cycle_group:
+        count += 1
+        _, resp_dic = hrbench_score(data_value)
+
+        for task_type, accuracy in resp_dic.items():
+            result_dic['cycle'].append(key)
+            result_dic['type'].append(task_type)
+            result_dic['accuracy'].append(accuracy)
+
+            avg_dic[task_type] += accuracy
+    for task_type, accuracy in avg_dic.items():
+        result_dic['cycle'].append('Average')
+        result_dic['type'].append(task_type)
+        result_dic['accuracy'].append(accuracy / count)
+    result_pd = pd.DataFrame(result_dic)
+
+    return result_pd
+
+
+def hrbench_score(data):
+    ret = defaultdict(list)
+    resp_dic = {}
+    category_list = set(data['category'])
+    score_dict = defaultdict(list)
+
+    for i in range(len(data)):
+        d = data.iloc[i]
+        category = d['category']
+        gpt_score = d['hit']
+        score_dict[category].append(gpt_score)
+        score_dict['all'].append(gpt_score)
+
+    all_acc = np.mean(score_dict['all'])
+    ret['type'].append('all')
+    ret['acc'].append(all_acc)
+    resp_dic['all'] = all_acc
+    for cate in category_list:
+        acc = np.mean(score_dict[cate])
+        ret['type'].append(cate)
+        ret['acc'].append(acc)
+
+        resp_dic[cate] = acc
+
+    return pd.DataFrame(ret), resp_dic

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

@@ -0,0 +1,150 @@
+import pandas as pd
+
+# from colorama import Fore, Back, Style
+from ...smp import *
+
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+def build_prompt_logicvista(line):
+    question = line['question']
+    prediction = str(line['prediction'])
+    tmpl = (
+        "You are a information extractor that extracts multiple choice letter answer choices "
+        "from a paragraph that contains the answer choice and sometimes explaination of why that "
+        "choice is correct to the given question.\n"
+        "What letter did the following answer choose? If the answer did not select a letter answer choice, "
+        "first try to infer the answer based off the given choices.\n"
+        "If it does not seem like the given answer corresponds to an answer choice OR if there is no selected answer, please just respond with Z.\n"  # noqa: E501
+        "Make sure you answer with ONLY the letters chosen.\n"
+        'Example 1: \n'
+        'Question: <start>\nWhat is the main object in image?\nOptions: A. teddy bear B. rabbit C. cat D. dog\n<end>\n'
+        'Answer: <start>\na cute teddy bear\n<end>\nYour output: A\n'
+        'Example 2: \n'
+        'Question: <start>\nWhat is the main object in image?\nOptions: A. teddy bear B. rabbit C. cat D. dog\n<end>\n'
+        'Answer: <start>\nSpider\n<end>\nYour output: Z\n'
+        'Example 3: \n'
+        'Question: <start>\nWhich figure is a rotation of the object?\n<end>\n'
+        'Answer: <start>\nThe figure on the right, labeled "D," is a rotation of the object shown in the top left corner.\n<end>\nYour output: D\n'  # noqa: E501
+        'Example 4: \n'
+        'Question: <start>\nWhich of the boxes comes next in the sequence? Select from A-E\n<end>\n'
+        'Answer: <start>\nThe sequence of the boxes is A, B, C, D, E.\n<end>\nYour output: ABCDE\n'
+        'Example 5: \n'
+        'Question: <start>\n{}\n<end>\nAnswer: <start>\n{}\n<end>\nYour output: '
+    )
+
+    return tmpl.format(question, prediction)
+
+
+def LogicVista_auxeval(model, line):
+    prompt = build_prompt_logicvista(line)
+    print(prompt)
+    log = ''
+    retry = 5
+
+    for i in range(retry):
+        prediction = line['prediction']
+        res = model.generate(prompt, temperature=i * 0.5)
+        answer = line['answer'].split(", ")
+        for j in range(0, len(answer)):
+            answer[j] = answer[j].lower()
+        answer.sort()
+        answer = ''.join(answer)
+
+        if FAIL_MSG in res:
+            log += f'Try {i}: output is {prediction}, failed to parse.\n'
+        elif not res.isupper() or not res.isalpha():
+            log += f'Try {i}: output is {prediction}, failed to parse.\n'
+        else:
+            log += 'Succeed'
+            hit = 0
+            extracted = [alpha.lower() for alpha in res]
+            extracted.sort()
+            extracted = ''.join(extracted)
+            if extracted == answer:
+                hit = 1
+            return dict(log=log, res=res, hit=hit)
+    log += 'All 5 retries failed.\n'
+    return dict(log=log, res='', hit=0)
+
+
+cat = ["diagram", "ocr", "patterns", "graphs", "tables", "3d shapes", "puzzles", "sequences", "physics"]
+
+
+def evaluate_logicvista(file_path):
+    df = load(file_path)
+
+    tot = defaultdict(lambda: 0)
+    hit = defaultdict(lambda: 0)
+    acc = defaultdict(lambda: 0)
+
+    _ = len(df)
+    _ = []
+
+    df_tot = df
+
+    df_inductive = df[df["skill"].str.contains("inductive")]
+    df_deductive = df[df["skill"].str.contains("deductive")]
+    df_numerical = df[df["skill"].str.contains("numerical")]
+    df_spatial = df[df["skill"].str.contains("spatial")]
+    df_mechanical = df[df["skill"].str.contains("mechanical")]
+
+    tot_correct = df_tot["hit"].sum()
+    tot_acc = (tot_correct / df_tot.shape[0]) * 100
+    tot['Overall'] = df_tot.shape[0]
+    hit['Overall'] = tot_correct
+    acc['Overall'] = tot_acc
+
+    inductive_correct = df_inductive["hit"].sum()
+    inductive_acc = (inductive_correct / df_inductive.shape[0]) * 100
+
+    tot["inductive"] = df_inductive.shape[0]
+    hit["inductive"] = inductive_correct
+    acc["inductive"] = inductive_acc
+
+    deductive_correct = df_deductive["hit"].sum()
+    deductive_acc = (deductive_correct / df_deductive.shape[0]) * 100
+
+    tot["deductive"] = df_deductive.shape[0]
+    hit["deductive"] = deductive_correct
+    acc["deductive"] = deductive_acc
+
+    numerical_correct = df_numerical["hit"].sum()
+    numerical_acc = (numerical_correct / df_numerical.shape[0]) * 100
+
+    tot["numerical"] = df_numerical.shape[0]
+    hit["numerical"] = numerical_correct
+    acc["numerical"] = numerical_acc
+
+    spatial_correct = df_spatial["hit"].sum()
+    spatial_acc = (spatial_correct / df_spatial.shape[0]) * 100
+
+    tot["spatial"] = df_spatial.shape[0]
+    hit["spatial"] = spatial_correct
+    acc["spatial"] = spatial_acc
+
+    mechanical_correct = df_mechanical["hit"].sum()
+    mechanical_acc = (mechanical_correct / df_mechanical.shape[0]) * 100
+
+    tot["mechanical"] = df_mechanical.shape[0]
+    hit["mechanical"] = mechanical_correct
+    acc["mechanical"] = mechanical_acc
+
+    # capability dimension, the official data json does not contain 'capability' column, so it is now ignored
+    # for i in cat:
+    #     curr = df[df["capability"].str.contains(i.replace(" ", ""))]
+    #     correct = curr["hit"].sum()
+    #     accuracy = (correct / curr.shape[0]) * 100
+    #     tot[i] = curr.shape[0]
+    #     hit[i] = correct
+    #     acc[i] = accuracy
+
+    res = defaultdict(list)
+    for k in tot.keys():
+        res['Task&Skill'].append(k)
+        res['tot'].append(tot[k])
+        res['hit'].append(hit[k])
+        res['acc'].append(acc[k])
+    res = pd.DataFrame(res)
+    return res

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/aggregation/mean_agg.py

@@ -0,0 +1,22 @@
+from numbers import Number
+from typing import Dict
+import numpy as np
+
+
+class MeanAggregation:
+    """Take the mean of all valid scores."""
+
+    @staticmethod
+    def aggregate(scores: Dict[str, Number], weights: Dict[str, Number]) -> Number:
+        """Exact match between targets and responses."""
+        filtered_scores = {f: s for f, s in scores.items() if s >= 0}
+        if not filtered_scores:
+            return -1
+
+        # Align the key order
+        flattened_scores = []
+        flattened_weights = []
+        for field in filtered_scores:
+            flattened_scores.append(filtered_scores[field])
+            flattened_weights.append(weights[field])
+        return np.average(flattened_scores, weights=flattened_weights)

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/aggregation/unsupported_agg.py

@@ -0,0 +1,8 @@
+from numbers import Number
+from typing import Dict
+
+
+class UnsupportedAggregation:
+    @staticmethod
+    def aggregate(scores: Dict[str, Number], weights: Dict[str, Number]) -> Number:
+        return -1

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/chess_jaccard.py

@@ -0,0 +1,24 @@
+import logging
+from typing import Dict, Any
+from .common.conversions import str_to_set
+from .common.metrics import jaccard_index
+
+
+def chess_transform(move_sequence: str) -> set:
+    """Transform a sequence of chess moves encoded in SAN into a set."""
+    move_sequence = str_to_set(move_sequence)
+    return {move_san.removesuffix("!").removesuffix("#") for move_san in move_sequence}
+
+
+class ChessMoveJaccard:
+    """Calculates the Jacard index for chess moves."""
+
+    @classmethod
+    def match(cls, responses: str | None, targets: str) -> float:
+        """Exact match between targets and responses."""
+        if responses is None:
+            return 0
+        responses = chess_transform(responses)
+        targets = chess_transform(targets)
+
+        return jaccard_index(responses, targets)

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/constrained_generation.py

@@ -0,0 +1,518 @@
+import collections
+import itertools
+import logging
+from numbers import Number
+import re
+from nltk.tokenize import sent_tokenize, word_tokenize
+from nltk.stem import WordNetLemmatizer
+from nltk.corpus import wordnet
+import pronouncing
+from .common.conversions import str_to_iterable
+from ..parsing.common.parsers import parse_nested_str_list, parse_syllable_ranges
+import signal
+
+
+def custom_lemmatize(word, lemmatizer):
+    """
+    Custom lemmatization to handle special cases like 'puppies' -> 'puppy'.
+    """
+    lemma = lemmatizer.lemmatize(word, wordnet.NOUN)
+
+    # Handle irregular plural forms manually
+    if word.endswith("ies") and lemma.endswith("y"):
+        lemma = lemma[:-1] + "y"
+    elif word.endswith("ves") and lemma.endswith("f"):
+        lemma = lemma[:-1] + "f"
+
+    return lemma
+
+
+def lemmatize_phrase(phrase, lemmatizer):
+    """
+    Lemmatizes a phrase (multiple words).
+    """
+    words = word_tokenize(phrase.lower())
+    lemmatized_words = [custom_lemmatize(word, lemmatizer) for word in words]
+    return " ".join(lemmatized_words)
+
+
+custom_phones_for_word = {
+    "'gainst": ["G EH1 N S T", "G EY1 N S T"],
+    "'midst": ["M IH1 D S T"],
+    "'mongst": ["M AH1 NG S T"],
+    "'neath": ["N IY1 TH"],
+    "beguiles": ["B IH0 G AY1 L Z"],
+    "cerulean": ["S ER0 UW1 L IY0 AH0 N"],
+    "doggo": ["D AO1 G OW0"],
+    "downtorn": ["D AW1 N T AO2 R N"],
+    "enthrall": ["EH0 N TH R AO1 L"],
+    "fam'ly": ["F AE1 M L IY0"],
+    "fiery": ["F AY1 ER0 IY0", "F AY1 R IY0"],
+    "flits": ["F L IH1 T S"],
+    "furred": ["F ER1 D"],
+    "kneels": ["N IY1 L Z"],
+    "o'er": ["OW1 ER0"],
+    "orbs": ["AO1 R B Z"],
+    "quenched": ["K W EH1 N CH D"],
+    "quietude": ["K W AY1 AH0 T UW0 D"],
+    "retold": ["R IY0 T OW1 L D"],
+    "scurries": ["S K ER1 IY0 Z"],
+    "sunbeams": ["S AH1 N B IY2 M Z"],
+    "syncs": ["S IH1 NG K S"],
+    "'twixt": ["T W IH1 K S T"],
+}
+
+
+file_logger = logging.getLogger("errorLogger")
+
+
+def phones_for_word(text: str) -> list[str]:
+    """A wrapper for pronouncingpy's phones_for_word to handle out-of-vocab issues."""
+    text = text.replace("’", "'").lower()
+
+    suffixes = [""]
+    prefixes = [""]
+    prefixes_to_remove = [""]
+    if text.endswith("'s"):
+        suffixes = [" Z"]
+        text = text.removesuffix("'s")
+
+    if text in custom_phones_for_word:
+        return [
+            pr + suffix
+            for pr, suffix in itertools.product(custom_phones_for_word[text], suffixes)
+        ]
+
+    pronunciations = pronouncing.phones_for_word(text)
+
+    # Guess pronunciation from word stem
+    if not pronunciations:
+        if suffixes[0] != "":  # "'s doesn't really work with the rest."
+            file_logger.error(f"OOV: {text}")
+            return []
+
+        if text.endswith("ed"):
+            suffixes = [" D", " T", " AH0 D", " IH0 D"]
+            text = text.removesuffix("ed")
+        elif text.endswith("s"):
+            # Some words, like bustles, end with es but the plural suffix is s.
+            if pronouncing.phones_for_word(text.removesuffix("s")):
+                # On the other hand, pierces is two syllables but pierce is one.
+                if text.endswith("es"):
+                    suffixes = [" S", " Z", " AH0 Z", " IH0 Z"]
+                    text = text.removesuffix("s")
+                else:
+                    suffixes = [" S", " Z"]
+                    text = text.removesuffix("s")
+            elif text.endswith("es"):
+                suffixes = [" AH0 Z", " IH0 Z"]
+                text = text.removesuffix("es")
+        if text.startswith("un"):
+            prefixes = ["AH0 N "]
+            text = text.removeprefix("un")
+        elif text.startswith("'"):
+            if pronouncing.phones_for_word("a" + text.removeprefix("'")):
+                prefixes_to_remove = ["AH0 "]
+                text = "a" + text.removeprefix("'")
+        pronunciations = pronouncing.phones_for_word(text)
+    pronunciations = [
+        (prefix + pr + suffix).removeprefix(prefix_to_remove)
+        for prefix, pr, suffix, prefix_to_remove in itertools.product(
+            prefixes, pronunciations, suffixes, prefixes_to_remove
+        )
+    ]
+
+    if not pronunciations:
+        file_logger.error(f"OOV: {text}")
+    return pronunciations
+
+
+def rhyming_part_include_unstressed(phones: str) -> str:
+    """Get the "rhyming part" of a string with CMUdict phones.
+
+    "Rhyming part" here means everything from the vowel in the
+    last syllable up to the end of the word.
+
+    Example:
+        >>> import pronouncing
+        >>> phones = pronouncing.phones_for_word("purple")
+        >>> rhyming_part_include_unstressed(phones[0])
+        'AH0 L'
+
+    Args:
+        phones: a string containing space-separated CMUdict phones
+
+    Returns:
+        a string with just the "rhyming part" of those phones
+    """
+    phones_list = phones.split()
+    for i in range(len(phones_list) - 1, 0, -1):
+        if phones_list[i][-1] in "012":
+            phones = " ".join(phones_list[i:])
+            break
+    return re.sub(r"\d", "", phones)
+
+
+def count_syllables(text: str) -> list[int]:
+    """Count the number of syllables in a piece of text."""
+    pronunciations = [phones_for_word(p) for p in text.split()]
+    syllable_counts = []
+    for pronun_possibility in itertools.product(*pronunciations):
+        syllable_counts.append(
+            sum([pronouncing.syllable_count(p) for p in pronun_possibility])
+        )
+    return syllable_counts
+
+
+def find_string_occurrences_with_variations(text, search_string):
+    lemmatizer = WordNetLemmatizer()
+
+    # Lemmatize the entire search phrase
+    search_lemma = lemmatize_phrase(search_string, lemmatizer)
+
+    # Tokenize the text into sentences
+    sentences = sent_tokenize(text)
+
+    occurrences = []
+    total_count = 0
+
+    # Iterate over each sentence
+    for i, sentence in enumerate(sentences, 1):  # Sentence numbers start from 1
+        # Lemmatize the entire sentence
+        lemmatized_sentence = lemmatize_phrase(sentence, lemmatizer)
+
+        # Count occurrences of the lemmatized search phrase in the lemmatized sentence
+        count_in_sentence = lemmatized_sentence.count(search_lemma)
+        if count_in_sentence > 0:
+            occurrences.append((i, count_in_sentence))
+            total_count += count_in_sentence
+
+    return total_count, occurrences
+
+
+def word_to_stresses(word: str) -> list[list[int]]:
+    """Convert a word to a list of stresses, for each valid pronunciation."""
+    pronunciations = phones_for_word(word)
+    stresses = {
+        tuple(int(stress) for stress in pronouncing.stresses(pronunc))
+        for pronunc in pronunciations
+    }
+    return [list(pronunc_stresses) for pronunc_stresses in stresses]
+
+
+def is_iambic_pair(stress1: int, stress2: int) -> bool:
+    """Whether the pair of stresses is a valid iambic pair."""
+    valid_pairs = {(2, 1), (0, 2), (0, 1), (0, 0), (1, 1), (2, 2)}
+    return (stress1, stress2) in valid_pairs
+
+
+def grouper_ignore_last(iterable, n):
+    "Collect data into fixed-length chunks or blocks"
+    # grouper('ABCDEFG', 3) --> ABC DEF
+    args = [iter(iterable)] * n
+    return zip(*args)
+
+
+def is_line_iambic(line: str) -> bool:
+    """Determine if a line is iambic."""
+    words = line.split()
+    stress_options = [word_to_stresses(word) for word in words]
+
+    def backtrack(word_index: int, syllable_index: int, prev_stress: int) -> bool:
+        """Using backtracking, determine if there is a sequence of pronunciations that is in iambic pentameter."""
+        if word_index == len(words):
+            # At this point, syllable_index is the number of syllables
+            return syllable_index % 2 == 0
+
+        for stress_pattern in stress_options[word_index]:
+            word_syllable_index = 0
+            if syllable_index % 2 != 0:
+                current_stress = stress_pattern[word_syllable_index]
+                if not is_iambic_pair(prev_stress, current_stress):
+                    continue
+                word_syllable_index += 1
+
+            word_valid_iambic_pairs = True
+            for stress1, stress2 in grouper_ignore_last(
+                stress_pattern[word_syllable_index:], 2
+            ):
+                if not is_iambic_pair(stress1, stress2):
+                    word_valid_iambic_pairs = False
+                    break
+                word_syllable_index += 2
+            if not word_valid_iambic_pairs:
+                continue
+
+            if word_syllable_index < len(stress_pattern):
+                assert word_syllable_index + 1 == len(stress_pattern)
+                next_stress = stress_pattern[word_syllable_index]
+                if backtrack(
+                    word_index + 1,
+                    syllable_index + word_syllable_index + 1,
+                    next_stress,
+                ):
+                    return True
+            else:
+                assert word_syllable_index == len(stress_pattern)
+                if backtrack(word_index + 1, syllable_index + word_syllable_index, -1):
+                    return True
+
+        return False
+
+    return backtrack(
+        0, 0, -1
+    )  # Start with -1 as prev_stress as a placeholder for the first syllable
+
+
+def parse_constraints(key_string, value_string):
+    key_components = key_string.strip().split("##")
+    # Remove trailing numbers from each key
+    key_components = [re.sub(r"\d+$", "", key) for key in key_components]
+    # Extract value components by splitting on ##
+    value_components = value_string.strip().split("##")
+    # Clean value components by removing brackets and spaces
+    value_components = [comp.strip().strip('"').strip() for comp in value_components]
+
+    # Handle cases where we expect integers
+    for i, value in enumerate(value_components):
+        if value.isdigit():
+            value_components[i] = int(value)
+
+    # Combine keys and values into a dictionary
+    if len(key_components) == len(value_components):
+        result = {
+            key.lower(): value for key, value in zip(key_components, value_components)
+        }
+    elif len(key_components) == 1 and len(value_components) == 1:
+        result = {key_components[0].lower(): value_components[0]}
+    else:
+        raise ValueError("Mismatch between number of keys and values.")
+
+    return result
+
+
+def check_constraint(response, constraint, constraint_val):
+    if constraint_val.strip() == "":
+        # empty contraint (placeholder), directly return 1
+        return 1
+    elif "contain" in constraint:
+        occurs_records = {}
+        parsed_constraint = parse_constraints(constraint, constraint_val)
+        response = response.replace("**", "")  # Remove markdown around bolded letters
+        if "contain_only" in parsed_constraint:
+            num_satisfied = 0
+            conditions = parse_nested_str_list(parsed_constraint["contain_only"])
+            for cond in conditions:
+                count, occurs = 0, []
+                for item in cond:  # check one condition
+                    count_, occurs_ = find_string_occurrences_with_variations(
+                        response, item
+                    )
+                    if count_ > 0:
+                        count += count_
+                        occurs.extend(occurs_)
+                if count > 0:
+                    num_satisfied += 1
+                    occurs_records[tuple(cond)] = occurs
+            score = 1 if num_satisfied == 1 else 0
+        else:  # the vanilla "contain" constraint
+            items = str_to_iterable(list, parsed_constraint["contain"])
+            count, occurs = 0, []
+            for item in items:
+                count_, occurs_ = find_string_occurrences_with_variations(
+                    response, item
+                )
+                if count_ > 0:
+                    count += count_
+                    occurs.extend(occurs_)
+            if count > 0:
+                occurs_records[tuple(items)] = occurs
+            score = 0 if count == 0 else 1
+
+        ## Other logics like position or repeat, only check when
+        ## previous "contain" consraint passes
+        if score > 0:
+            occurs = list(occurs_records.values())[0]
+            if "position_only" in parsed_constraint:
+                pos = parsed_constraint["position_only"]
+                score = 1 if len(occurs) == 1 and occurs[0][0] == pos else 0
+                return score
+            elif "position" in parsed_constraint:
+                pos = parsed_constraint["position"]
+                occurs_sent_ids = [item[0] for item in occurs]
+                score = 1 if pos in occurs_sent_ids else 0
+
+            # check occurance times
+            if "times" in parsed_constraint:
+                repeat_times = parsed_constraint["times"]
+                total_occurs = sum([item[1] for item in occurs])
+                score = 1 if total_occurs == repeat_times else 0
+
+    elif "length" in constraint:
+        try:
+            len_constraint = int(constraint_val[1:])
+            words = re.findall(r"\b\w+\b", response)
+            if constraint_val.strip() == "":
+                score = 1  ## dummy placeholder constraint, score is 1
+            elif constraint_val[0] == "<":
+                score = 1 if len(words) < len_constraint else 0
+            elif constraint_val[0] == ">":
+                score = 1 if len(words) > len_constraint else 0
+            else:
+                file_logger.warning(f"Unknown length info {constraint_val}")
+        except ValueError:
+            file_logger.warning(f"Wrong length info {constraint_val}")
+            score = 0
+    elif "acrostic" in constraint:
+        response = response.replace("**", "")
+
+        lines = response.strip().lower().split("\n")
+        if len(lines) != len(constraint_val):
+            return 0
+        all_match = True
+        if "acrostic_alliteration" in constraint:
+            for line, letter in zip(lines, constraint_val.lower()):
+                line = line.strip()
+                if letter == " ":
+                    if line != "":
+                        all_match = False
+                        break
+                elif not line or not all(word[0] == letter for word in line.split(" ")):
+                    all_match = False
+                    break
+        else:
+            for line, letter in zip(lines, constraint_val.lower()):
+                line = line.strip()
+                if letter == " ":
+                    if line != "":
+                        all_match = False
+                        break
+                elif not line or not line[0] == letter:
+                    all_match = False
+                    break
+        score = 1 if all_match else 0
+    else:
+        response = response.strip()
+        response = response.replace(".", "")
+        response = response.replace(",", "")
+        response = response.replace("!", "")
+        response = response.replace("?", "")
+        response = response.replace(":", "")
+        response = response.replace(";", "")
+        response = response.replace('"', "")
+        response = response.replace("-", " ")
+        response = response.replace("—", " ")
+        response = re.sub(
+            " *\(\w\) *(?=\n|$)", "", response
+        )  # The parenthesized letter in the rhyming scheme
+
+        lines = response.lower().split("\n")
+        match constraint:
+            case "syllables":
+                syllable_count_intervals = parse_syllable_ranges(constraint_val)
+                if len(lines) != len(syllable_count_intervals):
+                    return 0
+                try:
+                    all_match = all(
+                        any(
+                            min_count <= syll_count <= max_count
+                            for syll_count in count_syllables(line)
+                        )
+                        for line, (min_count, max_count) in zip(
+                            lines, syllable_count_intervals
+                        )
+                    )
+                except IndexError:
+                    all_match = None
+                score = 1 if all_match else 0
+            case "rhyming_scheme":
+                # Ensure that the number of lines is the same as the number in the rhyming scheme
+                if len(lines) != len(constraint_val):
+                    return 0
+                last_words = []
+                for line in lines:
+                    if line.strip():  # Check if line has non-whitespace content
+                        words = line.split()
+                        last_words.append(words[-1] if words else "")
+                    else:
+                        last_words.append("")
+
+                # Map each rhyming scheme letter to the last word of a line
+                letter_to_words = collections.defaultdict(set)
+                for rhyme_letter, word in zip(constraint_val, last_words):
+                    if rhyme_letter == " ":
+                        if word != "":
+                            return 0
+                    else:
+                        letter_to_words[rhyme_letter].add(word)
+
+                # Check that 1. The words for the same letter all rhyme
+                letter_to_rhyming_parts = {}
+                for letter, words in letter_to_words.items():
+                    rhyming_parts: list[set[str]] = [
+                        {
+                            rhyming_part_include_unstressed(pronunciations)
+                            for pronunciations in phones_for_word(word)
+                        }
+                        for word in words
+                    ]
+                    common_rhyming_parts = set.intersection(*rhyming_parts)
+                    if not common_rhyming_parts:
+                        return 0
+                    letter_to_rhyming_parts[letter] = common_rhyming_parts
+                # Check that 2. The words for different letters do not rhyme
+                for a, b in itertools.combinations(letter_to_rhyming_parts, 2):
+                    # To simplify things, if there are any shared pronunciations between two different letters, we reject it
+                    if letter_to_rhyming_parts[a] & letter_to_rhyming_parts[b]:
+                        return 0
+                score = 1
+            case "poetry_meter":
+                all_match = all(is_line_iambic(line) for line in lines)
+                score = 1 if all_match else 0
+            case _:
+                file_logger.warning(f"Unknown constraint type {constraint}")
+                score = 0
+
+    return score
+
+
+class ConstrainedGenerationEval:
+    """
+    Constrained generation metric
+    """
+
+    timeout = 10
+
+    @classmethod
+    def match(cls, response, constraints) -> Number:
+        scores = []
+        eval_results = {}
+
+        def handler(signum, frame):
+            raise TimeoutError()
+
+        def check_with_timeout(constraint, constraint_val):
+            # Set the signal handler and a timeout
+            signal.signal(signal.SIGALRM, handler)
+            signal.alarm(cls.timeout)  # Set the timeout
+
+            try:
+                # Try to check the constraint
+                score = check_constraint(response, constraint, constraint_val)
+            except TimeoutError:
+                print(f"Timeout reached for constraint: {constraint}")
+                score = 0  # Set score to 0 if timeout occurs
+            finally:
+                signal.alarm(0)  # Reset the alarm
+
+            return score
+
+        for constraint, constraint_val in constraints.items():
+            score = check_with_timeout(constraint, constraint_val)
+            scores.append(score)
+            eval_results[constraint] = score
+
+        final_score = min(scores)
+        eval_info = "\t".join([f"{key}: {val}" for key, val in eval_results.items()])
+
+        return final_score, eval_info

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/coordinate_sequence_match.py

@@ -0,0 +1,65 @@
+import logging
+from .common.conversions import str_to_coords
+import numpy as np
+
+
+class CoordsSequenceSimilarity:
+    """
+    Measure the similarity between two list of coordinates, used for keypoint estimation tasks
+    """
+
+    @staticmethod
+    def compute_score(pred_keypoints, gt_keypoints, k=10):
+        """
+        Compute the evaluation score for keypoint estimation.
+
+        Args:
+            pred_keypoints (list or np.ndarray): List or array of predicted keypoint coordinates,
+                                                 each as (x, y), normalized to [0, 1].
+            gt_keypoints (list or np.ndarray): List or array of ground truth keypoint coordinates,
+                                               each as (x, y), normalized to [0, 1].
+
+        Returns:
+            float: A score between 0 and 1, where 1 indicates perfect accuracy,
+                   and 0 indicates completely wrong.
+        """
+        # Convert inputs to NumPy arrays
+        try:
+            pred_keypoints = np.array(pred_keypoints)
+        except ValueError:
+            # Format is not a correct
+            return 0
+
+        gt_keypoints = np.array(gt_keypoints)
+
+        # shape mismatch, directly assign 0 score
+        if pred_keypoints.shape != gt_keypoints.shape:
+            return 0
+
+        # Compute Euclidean distances between corresponding keypoints
+        distances = np.linalg.norm(pred_keypoints - gt_keypoints, axis=1)
+
+        # Maximum possible distance in normalized coordinate space
+        max_distance = np.sqrt(2)
+
+        # Normalize distances
+        normalized_distances = distances / max_distance
+
+        # Compute per-keypoint scores using exponential decay
+        per_keypoint_scores = np.exp(-k * normalized_distances)
+
+        # Compute the average score across all keypoints
+        score = np.mean(per_keypoint_scores)
+
+        return score
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        """Exact match between targets and responses."""
+        logging.debug(f"{responses=}, {targets=}")
+        if not isinstance(responses, (tuple | list)):
+            responses = str_to_coords(responses, dim=2)
+        if not isinstance(targets, (tuple | list)):
+            targets = str_to_coords(targets, dim=2)
+
+        return cls.compute_score(responses, targets)

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/dict_jaccard_agg_jaccard.py

@@ -0,0 +1,28 @@
+from .jaccard import Jaccard
+from .common.conversions import cast_to_dict
+
+
+class DictJaccardAggJaccard:
+    """Calculates the Jaccard index, dividing by the union of the predictions.
+
+    1. Calculates the Jaccard index for all sets with the same key,
+    if it appears in either pred or targets
+    2. Calculates the total, then divides by the size of the union
+    """
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        """Return the aggregated Jaccard index between targets and responses."""
+        responses = cast_to_dict(responses)
+        if not isinstance(responses, dict):
+            return 0
+
+        all_keys = set(responses) | set(targets)
+
+        num_keys = 0
+        total_score = 0
+        for key in all_keys:
+            total_score += Jaccard.match(responses.get(key, []), targets.get(key, []))
+            num_keys += 1
+
+        return total_score / num_keys

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/dict_set_equality_agg_jaccard.py

@@ -0,0 +1,28 @@
+from vlmeval.dataset.utils.megabench.scoring.set_equality import SetEquality
+
+
+class DictSetEqualityAggJaccard:
+    """Calculates the average set equality across the dict.
+
+    1. Calculates the set equality for all sets with the same key,
+    if it appears in either pred or targets
+    2. Calculates the total, then divides by the size of the union
+    """
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        """Return the aggregated Jaccard index between targets and responses."""
+        if not isinstance(responses, dict):
+            return 0
+
+        all_keys = set(responses) | set(targets)
+
+        num_keys = 0
+        total_score = 0
+        for key in all_keys:
+            total_score += SetEquality.match(
+                responses.get(key, []), targets.get(key, [])
+            )
+            num_keys += 1
+
+        return total_score / num_keys

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/exact_str_match_case_insensitive.py

@@ -0,0 +1,12 @@
+from .exact_str_match import ExactStrMatch
+
+
+class ExactStrMatchCaseInsensitive:
+    """Case-insensitive exact string matching."""
+
+    @staticmethod
+    def match(response, correct_answer) -> int:
+        """Case-insensitive exact match between targets and responses."""
+        if not isinstance(response, str) and isinstance(correct_answer, str):
+            return 0
+        return ExactStrMatch.match(response.lower(), correct_answer.lower())

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/geo_proximity.py

@@ -0,0 +1,100 @@
+import functools
+import logging
+import math
+import random
+from geopy.distance import distance
+from geopy.geocoders import Nominatim
+from geopy.extra.rate_limiter import RateLimiter
+
+
+USER_AGENT_SUFFIX = hex(random.getrandbits(128))[2:]
+geolocator = Nominatim(user_agent=f"vlm-mega-benchmark_{USER_AGENT_SUFFIX}")
+
+
+error_logger = logging.getLogger("errorLogger")
+
+
+def calculate_proximity_score(guess_coords, actual_coords, k=100):
+    """Calculate the proximity score based on the location.
+
+    Exponentially decreases depending on the distance.
+
+    Args:
+        guess_coords (float, float): The longitude and latitude of the guessed coordinates.
+        actual_coords (float, float): The longitude and latitude of the actual coordinates.
+        k (numbers.Number): The threshold (in km) at which we get a score of 0.5.
+    """
+    dist = distance(guess_coords, actual_coords).km
+    proximity_score = math.exp(-dist / k)
+    return proximity_score
+
+
+GEOLOCATION_TIMEOUT = 1
+MAX_RETRIES = 30
+
+
+geocode = RateLimiter(
+    geolocator.geocode, min_delay_seconds=GEOLOCATION_TIMEOUT, max_retries=MAX_RETRIES
+)
+
+
+@functools.cache
+def try_geolocate(query):
+    """Try to look up the location."""
+    location = geocode(query)
+    if location is None:
+        error_logger.error(
+            f"Geolocation API request failed due to timeout: exceeded {MAX_RETRIES} retries!"
+        )
+    return location
+
+
+def location_to_coords(
+    country: str, province_or_state: str, municipality: str
+) -> tuple[float, float] | None:
+    if country == "" or province_or_state == "" or municipality == "":
+        return None
+    """Convert the location to longitude and latitude."""
+    location = geolocator.geocode(
+        query={"country": country, "state": province_or_state, "city": municipality}
+    )
+    if location is not None:
+        return (location.latitude, location.longitude)
+    # Try searching without the province/state, as it can be non-standard for some questions
+    location = geolocator.geocode(query={"country": country, "city": municipality})
+    if location is None:
+        return None
+    return (location.latitude, location.longitude)
+
+
+class GeoProximityLocationDict:
+    """Return a score based on the distance between two locations."""
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        """Return a score based on how far two targets are away from each other,
+        where each field is a dict with the following schema:
+        {
+            country: str,
+            province_or_state: str,
+            municipality: str
+        }
+        """
+        try:
+            guess_coords = location_to_coords(**responses)
+        except:
+            return 0
+
+        if guess_coords is None:
+            error_logger.error(
+                f"GeoProximityLocationDict: could not load co-ordinates for {responses=}"
+            )
+            return 0
+        actual_coords = location_to_coords(**targets)
+        if actual_coords is None:
+            error_logger.error(
+                f"GeoProximityLocationDict: could not load co-ordinates for {targets=}"
+            )
+            return 0
+
+        return calculate_proximity_score(guess_coords, actual_coords)

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/gleu.py

@@ -0,0 +1,17 @@
+from numbers import Number
+import jieba
+from nltk.translate.gleu_score import sentence_gleu
+
+
+class GLEUChinese:
+    """Compute GLEU score for Chinese text."""
+
+    @staticmethod
+    def match(response, correct_answer) -> Number:
+        """Compute the BLEU scores between two strings."""
+        if isinstance(response, str) and isinstance(correct_answer, str):
+            reference_tokens = list(jieba.cut_for_search(response))
+            translation_tokens = list(jieba.cut_for_search(correct_answer))
+        else:
+            return 0
+        return sentence_gleu([reference_tokens], translation_tokens)

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/jaccard.py

@@ -0,0 +1,75 @@
+from .common.conversions import cast_to_set
+from .common.metrics import jaccard_index
+
+
+class Jaccard:
+    """Calculates the Jacard index for iterables."""
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        """Exact match between targets and responses."""
+        if responses is None:
+            return 0
+        responses = cast_to_set(responses)
+        targets = cast_to_set(targets)
+
+        return jaccard_index(responses, targets)
+
+
+class JaccardCaseInsensitive:
+    """Calculates the Jacard index for iterables of strings,
+    Do not consider the case
+    """
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+        """Exact match between targets and responses."""
+        if responses is None:
+            return 0
+        responses = cast_to_set(responses)
+        targets = cast_to_set(targets)
+
+        if isinstance(list(targets)[0], str):
+            new_responses = {
+                item.lower() if isinstance(item, str) else str(item).lower()
+                for item in responses
+            }
+            new_targets = {item.lower() for item in targets}
+        elif isinstance(list(targets)[0], tuple):
+            new_responses = set()
+            new_targets = set()
+            try:
+                for res in responses:
+                    new_res = tuple(
+                        [
+                            item.lower()
+                            .replace(" ", "")
+                            .replace("-", "")
+                            .replace("\n", "")
+                            .replace("\t", "")
+                            .replace("_", "")
+                            .replace(".", "")
+                            for item in res
+                        ]
+                    )
+                    new_responses.add(new_res)
+            except:  # the data type of the response might be wrong, return 0 in this case
+                return 0
+            for tgt in targets:
+                new_tgt = tuple(
+                    [
+                        item.lower()
+                        .replace(" ", "")
+                        .replace("-", "")
+                        .replace("\n", "")
+                        .replace("\t", "")
+                        .replace("_", "")
+                        .replace(".", "")
+                        for item in tgt
+                    ]
+                )
+                new_targets.add(new_tgt)
+        else:
+            return 0
+
+        return jaccard_index(new_responses, new_targets)

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/latex_expr_equality.py

@@ -0,0 +1,96 @@
+import re
+from sympy.parsing.latex import parse_latex
+from sympy.parsing.latex.errors import LaTeXParsingError
+from sympy.core.sympify import SympifyError
+from .common.transformations import normalize_latex
+from .simple_str_match import SimpleStrMatch
+import signal
+
+
+class TimeoutException(Exception):
+    pass
+
+
+def timeout_handler(signum, frame):
+    raise TimeoutException()
+
+
+class LatexExprEquality:
+    """Determines if two LaTeX expressions are equal."""
+
+    @classmethod
+    def match(cls, responses, targets, timeout_duration=15) -> int:
+        """Whether two LaTeX expressions are equal."""
+        if not isinstance(responses, str) or not isinstance(targets, str):
+            return 0
+        signal.signal(signal.SIGALRM, timeout_handler)
+        signal.alarm(timeout_duration)  # Set the timeout duration in seconds
+        try:
+            # seems that this eval can get stuck when evaluating all tasks..
+            responses = normalize_latex(responses)
+            targets = normalize_latex(targets)
+            responses_expr = parse_latex(responses)
+            targets_expr = parse_latex(targets)
+            result = 1 if responses_expr.equals(targets_expr) else 0
+            return result
+        except (
+            LaTeXParsingError,
+            SympifyError,
+            TypeError,
+            TimeoutException,
+            NotImplementedError,
+        ):
+            return SimpleStrMatch.match(responses, targets)
+        finally:
+            signal.alarm(0)  # Cancel the alarm if it completes successfully
+
+
+def separate_text_and_latex(text):
+    # Regular expression to match LaTeX content between $ symbols
+    pattern = r"(\$[^$]*\$)"
+
+    # Split the text based on LaTeX parts
+    parts = re.split(pattern, text)
+
+    # Separate plain text and LaTeX
+    latex_content = []
+    plain_text = []
+
+    for part in parts:
+        if part.startswith("$") and part.endswith("$"):
+            latex_content.append(part)
+        else:
+            plain_text.append(part.strip())
+
+    return plain_text, latex_content
+
+
+def join_latex(latex_exps):
+    result = []
+    for exp in latex_exps:
+        result.append(exp[1:-1].strip().replace(",", ""))
+    result = f"{' '.join(result)}"
+    return result
+
+
+class TextLatexExprEquality:
+    """Determines if two LaTeX expressions are equal."""
+
+    @classmethod
+    def match(cls, responses, targets) -> int:
+        """Whether two LaTeX expressions are equal."""
+        if not isinstance(responses, str) or not isinstance(targets, str):
+            return 0
+
+        tgt_texts, tgt_latex = separate_text_and_latex(targets)
+        res_texts, res_latex = separate_text_and_latex(responses)
+
+        res_text_join = "".join(res_texts).replace(",", "")
+        tgt_text_join = "".join(tgt_texts).replace(",", "")
+        text_match = SimpleStrMatch.match(res_text_join, tgt_text_join)
+
+        res_latex_join = join_latex(res_latex)
+        tgt_latex_join = join_latex(tgt_latex)
+        latex_match = LatexExprEquality.match(res_latex_join, tgt_latex_join)
+
+        return 1 if text_match and latex_match else 0

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/program_judge.py

@@ -0,0 +1,141 @@
+import io
+import pathlib
+import json
+import multiprocessing
+from unittest.mock import patch
+from multiprocessing.queues import Empty
+
+BIG_BENCH_PATH = pathlib.Path(__file__).resolve().parent.parent.parent
+
+
+class ProgramJudge:
+    """Program Judging."""
+
+    # Check if results have been saved for this metric instance
+    # prevent duplicate saving results
+    task_saved = {}
+
+    @classmethod
+    def save_test_results(cls, task_name, results, query_file):
+        query_base = pathlib.Path(query_file).parent
+        output_dir = query_base / "code_eval"
+        output_dir.mkdir(parents=True, exist_ok=True)
+        output_file = output_dir / f"{task_name}_test_case.json"
+
+        saved = cls.task_saved.get(task_name, False)
+        if output_file.is_file() and saved:
+            with open(output_file, "r") as f:
+                existing_data = json.load(f)
+            existing_data.extend(results)
+        else:
+            existing_data = results
+            cls.task_saved[task_name] = True
+        with open(output_file, "w") as f:
+            json.dump(existing_data, f, indent=4)
+
+    @staticmethod
+    def match(response: str, eval_context: str, task_info: str = None) -> int:
+        # Load all test cases from the benchmark_tasks directory
+        # task_name = task_info["task_name"]
+        # task_folder = task_info["task_folder"]
+        # query_results_file = task_info["results_file"]
+
+        test_cases = eval_context["test_case"]
+
+        # Create a CodeTester instance with the response and the found test cases
+        tester = CodeTester(response, test_cases)
+        score, results = tester.run_tests()
+
+        # ProgramJudge.save_test_results(task_name, results, query_results_file)
+        return score
+
+
+#########################################################
+### Implementation of the automatic code tester
+#########################################################
+
+
+class CodeTester:
+    def __init__(self, user_code, test_cases, timeout=2, verbose=True):
+        self.user_code = user_code
+        self.test_cases = test_cases
+        self.timeout = timeout
+        self.verbose = verbose
+
+    def run_user_code(self, input_data):
+        input_str = "\n".join(input_data) + "\n"
+        output_queue = multiprocessing.Queue()
+        process = multiprocessing.Process(
+            target=self.target, args=(output_queue, input_str)
+        )
+        process.start()
+
+        process.join(self.timeout)
+        if process.is_alive():
+            process.terminate()
+            return f"ERROR: Code execution exceeded the time limit."
+
+        try:
+            result = output_queue.get(timeout=10)  # Add timeout for queue retrieval
+        except Empty:
+            return "ERROR: No output was produced before timeout."
+        finally:
+            output_queue.close()  # Close the queue to release resources
+            output_queue.join_thread()  # Ensure all items in the queue are processed
+
+        return result
+
+    def target(self, output_queue, input_str):
+        contains_main_block = 'if __name__ == "__main__":' in self.user_code
+        stdout = io.StringIO()
+        try:
+            with patch("builtins.input", side_effect=input_str.splitlines()):
+                with patch("sys.stdout", new=stdout):
+                    if contains_main_block:
+                        # If the user code contains the main block, execute in the context of __name__ == "__main__"
+                        exec(self.user_code, {"__name__": "__main__"})
+                    else:
+                        # Otherwise, just execute the user code directly
+                        exec(self.user_code)
+        except Exception as e:
+            output_queue.put(f"ERROR during execution: {e}")
+        else:
+            output_queue.put(stdout.getvalue().rstrip())
+
+    def evaluate_test_case(self, input_data, expected_output):
+        output = self.run_user_code(input_data)
+        return output == expected_output.rstrip(), output
+
+    def run_tests(self):
+        if isinstance(self.test_cases, dict):
+            self.test_cases = [self.test_cases]
+        total_tests = len(self.test_cases)
+        passed_tests = 0
+        results = []
+
+        for i, test_case in enumerate(self.test_cases, 1):
+            result, output = self.evaluate_test_case(
+                test_case["input"], test_case["expected"]
+            )
+
+            test_result = {
+                "response": self.user_code,
+                "test_case": test_case["input"],
+                "output": output,
+                "expected": test_case["expected"],
+                "result": "Passed" if result else "Failed",
+            }
+            results.append(test_result)
+
+            if result:
+                if self.verbose:
+                    print(f"Test case {i}: Passed")
+                passed_tests += 1
+            else:
+                if self.verbose:
+                    print(
+                        f"Test case {i}: Failed - Expected {test_case['expected']} but got {output}"
+                    )
+
+        score = passed_tests / total_tests if total_tests > 0 else 0
+        return score, results

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/sequence_equality.py

@@ -0,0 +1,62 @@
+from .common.conversions import str_to_list
+from numbers import Number
+
+
+class SequenceEquality:
+    """Determines how much of the first part of the list
+    was predicted correctly.
+    """
+
+    @classmethod
+    def match(cls, responses, targets) -> int:
+        """Exact match between targets and responses."""
+        if not isinstance(responses, str):
+            responses = str(responses)
+        responses = str_to_list(responses)
+        targets = str_to_list(targets)
+        return 1 if responses == targets else 0
+
+
+class SequenceEqualityCaseInsensitive:
+    """Determines how much of the first part of the list
+    was predicted correctly.
+    """
+
+    @classmethod
+    def match(cls, responses, targets) -> int:
+        """Exact match between targets and responses."""
+        if not isinstance(responses, str):
+            responses = str(responses)
+        responses = str_to_list(responses)
+        targets = str_to_list(targets)
+
+        responses = [
+            item.lower() if isinstance(item, str) else str(item) for item in responses
+        ]
+        targets = [item.lower() for item in targets]
+        return 1 if responses == targets else 0
+
+
+class SequenceAccuracyCaseInsensitive:
+    """Determines how much of the first part of the list
+    was predicted correctly.
+    """
+
+    @classmethod
+    def match(cls, responses, targets) -> int:
+        """Exact match between targets and responses."""
+        responses = str_to_list(responses)
+        targets = str_to_list(targets)
+        if len(targets) != len(responses):
+            return 0
+        correct = 0
+        for res, tgt in zip(responses, targets):
+            if isinstance(tgt, str):
+                if res.lower() == tgt.lower():
+                    correct += 1
+            elif isinstance(tgt, Number) and isinstance(res, Number):
+                if res == tgt:
+                    correct += 1
+            else:
+                pass
+        return correct / len(targets)

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/set_equality.py

@@ -0,0 +1,74 @@
+from .common.conversions import cast_to_set, str_to_set
+
+
+def _convert_to_hashable(item):
+    """将不可哈希的类型转换为可哈希类型"""
+    if isinstance(item, (list, tuple)):
+        return tuple(item)  # 将列表转换为元组
+    return item
+
+
+class SetEquality:
+    """Determines whether two sets are equal."""
+
+    @classmethod
+    def match(cls, responses, targets) -> int:
+        """Exact match between targets and responses."""
+        if isinstance(responses, (list, tuple)):
+            responses = {_convert_to_hashable(item) for item in responses}
+        if isinstance(targets, (list, tuple)):
+            targets = {_convert_to_hashable(item) for item in targets}
+        return 1 if responses == targets else 0
+
+
+class SetEqualityCaseInsensitive:
+    """Determines whether two sets are equal, ignoring string case."""
+
+    @classmethod
+    def match(cls, responses, targets) -> int:
+        """Exact match between targets and responses."""
+        try:
+            responses: set[str] = {text.upper() for text in cast_to_set(responses)}
+            targets: set[str] = {text.upper() for text in cast_to_set(targets)}
+        except AttributeError:
+            return 0
+        return 1 if responses == targets else 0
+
+
+class StringSetEqualityLineSplit:
+    """Determines whether two sets are equal, for string inputs, separated by line breaks"""
+
+    @classmethod
+    def match(cls, responses, targets) -> int:
+        if "\\n" in targets:
+            targets = targets.replace("\\n", "\n")
+        if "\\n" in responses:
+            responses = responses.replace("\\n", "\n")
+        responses_set = set(responses.split("\n"))
+        targets_set = set(targets.split("\n"))
+        responses_set = {
+            item.lower() if isinstance(item, str) else item for item in responses_set
+        }
+        targets_set = {
+            item.lower() if isinstance(item, str) else item for item in targets_set
+        }
+        return 1 if responses_set == targets_set else 0
+
+
+class StringSetEqualityCommaSplit:
+    """Determines whether two sets are equal, for string inputs, separated by commas
+    Handles some corner cases that would fail the general SetEquality metric, like the string
+    with "None", which fails the eval. Also do case-insensitive eval.
+    """
+
+    @classmethod
+    def match(cls, responses, targets) -> int:
+        responses_set = str_to_set(responses)
+        targets_set = str_to_set(targets)
+        responses_set = {
+            item.lower() if isinstance(item, str) else item for item in responses_set
+        }
+        targets_set = {
+            item.lower() if isinstance(item, str) else item for item in targets_set
+        }
+        return 1 if responses_set == targets_set else 0

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/xml_norm_point_in_bbox.py

@@ -0,0 +1,35 @@
+from .common.conversions import parse_point_2d_from_xml, str_to_bboxes
+
+
+class XmlNormPointInBbox:
+    """Determines whether a point is located in a bounding box.
+
+    Assumes that co-ordinates are normalized between 0 and 1 and that the 2D point is
+    of the form <point>x, y</point>
+    """
+
+    @classmethod
+    def match(cls, responses, eval_context) -> int:
+        """Determine if the point is in the bounding box
+        and return which bounding box was matched, if any."""
+        bounding_box_has_match = {
+            bbox: False for bbox in eval_context["bounding_boxes"]
+        }
+        bounding_boxes = [
+            str_to_bboxes(bbox_str)[0] for bbox_str in eval_context["bounding_boxes"]
+        ]
+        assert bounding_boxes
+
+        if not isinstance(responses, (tuple | list)):
+            responses = parse_point_2d_from_xml(responses)
+            if not responses:
+                return 0, bounding_box_has_match
+        elif len(responses) != 2:
+            return 0, bounding_box_has_match
+
+        x, y = responses
+        for min_x, min_y, max_x, max_y in bounding_boxes:
+            if min_x <= x <= max_x and min_y <= y <= max_y:
+                bounding_box_has_match[str((min_x, min_y, max_x, max_y))] = True
+                return 1, bounding_box_has_match
+        return 0, bounding_box_has_match

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/tools/analysis_utils.py

@@ -0,0 +1,182 @@
+import json
+import ast
+from collections import defaultdict
+from typing import List, Dict, Any
+
+_DATASET_CACHE = {}
+_SCORING_FUNCTIONS_CACHE = {}
+
+def _load_hf(subset_name: str) -> List[Dict[str, Any]]:
+    """
+    Load the HF dataset for the given subset name.
+    """
+    if subset_name in _DATASET_CACHE:
+        return _DATASET_CACHE[subset_name]
+    
+    from datasets import load_dataset
+    dataset = load_dataset("TIGER-Lab/MEGA-Bench", subset_name)["test"]
+    task_dict = {}
+    for sample in dataset:
+        task_name = sample["task_name"]
+        if task_name not in task_dict:
+            task_dict[task_name] = []
+        task_dict[task_name].append(sample)
+
+    _DATASET_CACHE[subset_name] = task_dict
+    return task_dict
+
+
+def _get_scoring_functions():
+    if _SCORING_FUNCTIONS_CACHE:
+        return _SCORING_FUNCTIONS_CACHE
+    
+    core_data = _load_hf("core")
+    open_data = _load_hf("open")
+    
+    core_scoring_functions = {}
+    open_scoring_functions = {}
+    
+    for task_name, task_samples in core_data.items():
+        core_scoring_functions[task_name] = ast.literal_eval(
+            task_samples[0]["metric_info"]
+        )
+    
+    for task_name, task_samples in open_data.items():
+        open_scoring_functions[task_name] = ast.literal_eval(
+            task_samples[0]["metric_info"]
+        )
+    
+    _SCORING_FUNCTIONS_CACHE["core"] = core_scoring_functions
+    _SCORING_FUNCTIONS_CACHE["open"] = open_scoring_functions
+    
+    return _SCORING_FUNCTIONS_CACHE
+
+
+def _determine_eval_style(task):
+    """
+    Determine the evaluation style (rule or llm) for a task.
+    """
+    scoring_functions = _get_scoring_functions()
+    core_scoring_functions = scoring_functions["core"]
+    open_scoring_functions = scoring_functions["open"]
+    
+    task_name = task["task_name"]
+    if task_name in core_scoring_functions:
+        metric_info = core_scoring_functions[task_name]
+    elif task_name in open_scoring_functions:
+        metric_info = open_scoring_functions[task_name]
+    else:
+        raise ValueError(f"Task '{task_name}' not found in either core or open datasets")
+    
+    all_task_metrics = list(metric_info["field_score_function"].values())
+    eval_type = (
+        "rule"
+        if (
+            "gpt_4o_as_judge" not in all_task_metrics
+            and "ascii_art_gpt4o_judge" not in all_task_metrics
+        )
+        else "llm"
+    )
+    return eval_type
+
+
+def clear_cache():
+    """
+    Clear the cache and force re-loading the dataset.
+    """
+    global _DATASET_CACHE, _SCORING_FUNCTIONS_CACHE
+    _DATASET_CACHE.clear()
+    _SCORING_FUNCTIONS_CACHE.clear()
+
+
+def task_list_refine(task_list):
+    task_results = []
+    for task in task_list:
+        if "mean_task_score" in task and task["mean_task_score"] != -1:
+            num_demo = 1 if len(task["example_contents"]) > 0 else 0
+            task_results.append(
+                {
+                    "name": task["task_name"],
+                    "score": task["mean_task_score"],
+                    "eval_type": task.get("eval_type", _determine_eval_style(task)),
+                    "num_demo": num_demo,
+                    "num_query": len(task["query_response"]),
+                }
+            )
+    return task_results
+
+
+def derive_keyword_stats(task_results_with_meta, include_per_task_info=False):
+    """
+    Calculate keyword-based statistics for skills, input_format, and output_format.
+    """
+    skills_stats = defaultdict(lambda: {"count": 0, "total_score": 0.0, "num_samples": 0, "tasks": []})
+    input_format_stats = defaultdict(lambda: {"count": 0, "total_score": 0.0, "num_samples": 0, "tasks": []})
+    output_format_stats = defaultdict(lambda: {"count": 0, "total_score": 0.0, "num_samples": 0, "tasks": []})
+    input_num_stats = defaultdict(lambda: {"count": 0, "total_score": 0.0, "num_samples": 0, "tasks": []})
+    app_stats = defaultdict(lambda: {"count": 0, "total_score": 0.0, "num_samples": 0, "tasks": []})
+
+    for task_name, task in task_results_with_meta.items():
+        task_name = task.get("original_task_name", "Unknown Task")
+        score = task.get("score", 0.0)
+        num_samples = task.get("num_query", 0) + task.get("num_demo", 0)
+
+        if score == -1:
+            continue
+
+        for skill in task.get("skills", []):
+            skills_stats[skill]["count"] += 1
+            skills_stats[skill]["total_score"] += score
+            skills_stats[skill]["num_samples"] += num_samples
+            if include_per_task_info:
+                skills_stats[skill]["tasks"].append((task_name, score))
+
+        for stat_dict, key in [
+            (input_format_stats, "input_format"),
+            (output_format_stats, "output_format"),
+            (input_num_stats, "num_input"),
+            (app_stats, "app")
+        ]:
+            if value := task.get(key):
+                stat_dict[value]["count"] += 1
+                stat_dict[value]["total_score"] += score
+                stat_dict[value]["num_samples"] += num_samples
+                if include_per_task_info:
+                    stat_dict[value]["tasks"].append((task_name, score))
+
+    all_stats = {
+        "skills": skills_stats,
+        "input_format": input_format_stats,
+        "output_format": output_format_stats,
+        "input_num": input_num_stats,
+        "app": app_stats,
+    }
+
+    for stats_dict in all_stats.values():
+        for keyword, data in stats_dict.items():
+            data["average_score"] = data["total_score"] / data["count"] if data["count"] > 0 else 0.0
+            del data["total_score"]
+
+    return dict(all_stats)
+
+
+def collect_task_metadata(model_results, all_task_meta_path):
+    """
+    Collect task metadata for a model's results using the all_task_meta.json file
+    """
+    # Load the complete task metadata
+    with open(all_task_meta_path, "r") as f:
+        all_meta = json.load(f)
+    
+    # Create result dictionary
+    all_task_meta = {}
+    
+    # Match results with metadata
+    for task_result in model_results:
+        task_name = task_result["name"]
+        if task_name in all_meta:
+            meta = all_meta[task_name].copy()  # Create a copy to avoid modifying original
+            meta.update(task_result)
+            all_task_meta[task_name] = meta
+    
+    return all_task_meta

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/tools/derive_breakdown_results.py

@@ -0,0 +1,141 @@
+import json
+import argparse
+from pathlib import Path
+from analysis_utils import (
+    task_list_refine,
+    collect_task_metadata,
+    derive_keyword_stats,
+)
+
+def calculate_model_summary(task_results_with_meta):
+    """
+    Re-calculate model performance summary statistics across core and open tasks.
+    
+    Args:
+        task_results: List of task results with scores
+        task_metadata: Dictionary containing task metadata including task types
+    
+    Returns:
+        Dictionary containing summary statistics for core and open tasks
+    """
+    core_tasks = []
+    open_tasks = []
+
+    # Separate core and open tasks
+    for task in task_results_with_meta.values():
+        if task['eval_type'] == 'llm':
+            open_tasks.append(task)
+        else:
+            core_tasks.append(task)
+    
+    def calculate_stats(tasks):
+        if not tasks:
+            return None
+        
+        total_samples = sum(task.get('num_query', 0) for task in tasks)
+        macro_scores = [task.get('score', 0) for task in tasks]
+        
+        return {
+            "num_eval_tasks": len(tasks),
+            "num_eval_samples": total_samples,
+            "macro_mean_score": sum(macro_scores) / len(tasks) if tasks else 0,
+        }
+    
+    core_stats = calculate_stats(core_tasks)
+    open_stats = calculate_stats(open_tasks)
+    
+    # Calculate overall score (weighted average based on number of tasks)
+    total_tasks = (core_stats["num_eval_tasks"] + open_stats["num_eval_tasks"])
+    overall_score = (
+        (core_stats["macro_mean_score"] * core_stats["num_eval_tasks"] + 
+         open_stats["macro_mean_score"] * open_stats["num_eval_tasks"]) / total_tasks
+        if core_stats and open_stats
+        else 0
+    )
+    
+    return {
+        "core": core_stats,
+        "open": open_stats,
+        "overall_score": overall_score
+    }
+
+def merge_json_files(input_dir, output_path, key="name"):
+    """
+    Merge multiple JSON files containing evaluation results from a directory.
+    Looks for all files matching pattern 'data_with_scores*.json'.
+    Prioritizes LLM evaluations over rule-based ones when duplicates exist.
+    """
+    data_dict = {}  # Using name as key for easy lookup and updates
+    
+    # Find all matching JSON files in the directory
+    json_paths = list(Path(input_dir).glob("megabench_score*.json"))
+    print(f"Found {len(json_paths)} files to merge")
+    
+    # Load and merge all JSON files
+    for path in json_paths:
+        print(f"Processing {path}")
+        with open(path, "r") as f:
+            data = json.load(f)
+            if isinstance(data, dict) and "data" in data:
+                data = task_list_refine(data["data"])
+            
+            # Update or add entries
+            for item in data:
+                item_key = item[key]
+                # If new item or if new item is LLM-evaluated (prioritize LLM eval)
+                if item_key not in data_dict or (
+                    item.get("eval_type") == "llm" and data_dict[item_key].get("eval_type") != "llm"
+                ):
+                    data_dict[item_key] = item
+
+    # Convert back to list
+    merged_data = list(data_dict.values())
+    
+    # Save the merged result
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(output_path, "w") as f:
+        json.dump(merged_data, f, indent=4)
+    
+    print(f"Merged file with {len(merged_data)} tasks saved to {output_path}")
+    return merged_data
+
+def main():
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description='Merge and process evaluation score files.')
+    parser.add_argument('--input_dir', type=str, help='Directory containing score files')
+    args = parser.parse_args()
+
+    # Convert path to Path object
+    input_dir = Path(args.input_dir)
+    
+    # Create analysis directory under input directory
+    output_dir = input_dir / "analysis"
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Merge files
+    output_path = output_dir / "task_results.json"
+    task_results = merge_json_files(input_dir, output_path)
+    
+    # Collect metadata and derive keyword stats
+    task_results_with_meta = collect_task_metadata(task_results, all_task_meta_path="all_task_meta.json")
+    keyword_stats = derive_keyword_stats(task_results_with_meta)
+    
+    # Calculate model summary
+    model_summary = calculate_model_summary(task_results_with_meta)
+
+    summary_results = {
+        "model_summary": model_summary,
+        "keyword_stats": keyword_stats
+    }
+    
+    # Save keyword stats
+    stats_output = output_dir / "summary_and_keyword_stats.json"
+    with open(stats_output, "w") as f:
+        json.dump(summary_results, f, indent=4)
+    
+    print(f"\nResults saved in {output_dir}:")
+    print(f"- Merged data: {output_path}")
+    print(f"- Multi-dimensional keywords stats: {stats_output}")
+
+if __name__ == "__main__":
+    main()

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/tools/get_si_subset_from_full.py

@@ -0,0 +1,92 @@
+"""
+For propietary models that naturally suport multi-image or video inputs, we don't run the single-image setting, 
+instead, we directly compute the SI results by extracting the subset results from the full task set to compute the stats.
+"""
+
+
+from pathlib import Path
+import json
+import argparse
+from analysis_utils import (
+    derive_keyword_stats,
+    collect_task_metadata
+)
+from derive_breakdown_results import calculate_model_summary
+
+
+def process_subset_results(input_dir, eval_type):
+    """Read results from the full results directory structure"""
+    task_results_path = input_dir / "analysis" / "task_results.json"
+    
+    # Load task results
+    with open(task_results_path, "r") as f:
+        task_results = json.load(f)
+    
+    results_with_meta = collect_task_metadata(task_results, all_task_meta_path="all_task_meta.json")
+    
+    # Filter tasks by eval_type
+    filtered_results_with_meta = {task_name:task for task_name, task in results_with_meta.items() if task["eval_type"] == eval_type and task["num_input"] == "1-image"}
+    filtered_results = [task for task in task_results if task["name"] in filtered_results_with_meta]
+    
+    if not filtered_results:
+        print(f"Warning: No tasks found in {input_dir} with eval_type {eval_type}")
+        return None, None, None
+    
+    # Calculate summary statistics
+    num_tasks = len(filtered_results)
+    total_queries = sum(task["num_query"] for task in filtered_results)
+    total_correct = sum(round(task["score"] * task["num_query"]) for task in filtered_results)
+    
+    summary = {
+        "num_eval_tasks": num_tasks,
+        "num_eval_samples": total_queries,
+        "macro_mean_score": sum(task["score"] for task in filtered_results) / num_tasks,
+    }
+    
+    return filtered_results, filtered_results_with_meta, summary
+
+
+def main(input_dir, output_dir):
+    # Process core and open set results
+    filtered_tasks_core, filtered_tasks_core_with_meta, _ = process_subset_results(input_dir, "rule")
+    filtered_tasks_open, filtered_tasks_open_with_meta, _ = process_subset_results(input_dir, "llm")
+
+    if filtered_tasks_core and filtered_tasks_open:
+        task_results = filtered_tasks_core + filtered_tasks_open
+        task_results_with_meta = {**filtered_tasks_core_with_meta, **filtered_tasks_open_with_meta}
+
+        # Save task results
+        with open(output_dir / "task_results.json", "w") as f:
+            json.dump(task_results, f, indent=4)
+
+        # Collect metadata and derive keyword stats
+        keyword_stats = derive_keyword_stats(task_results_with_meta)
+
+        # Calculate model summary
+        model_summary = calculate_model_summary(task_results_with_meta)
+
+        summary_results = {
+            "model_summary": model_summary,
+            "keyword_stats": keyword_stats
+        }
+    
+        # Save keyword stats
+        stats_output = output_dir / "summary_and_keyword_stats.json"
+        with open(stats_output, "w") as f:
+            json.dump(summary_results, f, indent=4)
+    
+        print(f"\nResults saved in {output_dir}")
+
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input_dir", type=str, required=True, help="Path to the input directory containing full results")
+    parser.add_argument("--output_dir", type=str, required=True, help="Path to the output directory")
+    args = parser.parse_args()
+
+    input_dir = Path(args.input_dir)
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    main(input_dir, output_dir)

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

@@ -0,0 +1,126 @@
+from ...smp import *
+
+meta_prompt = """
+You are an assistant skilled at evaluating the quality of creative text.
+Please act as an impartial judge and evaluate the quality of the response provided by an AI assistant to \
+the user question displayed below. You'll need to assess the response on the following dimensions: \
+Creativity, Richness, Visual Perception, Logical Coherence, Answer Accuracy and Image Relationship Understanding. \
+We will provide you with a creative question and the AI model's response and a reference answer for your evaluation. \
+As you begin your assessment, follow this process:
+1. Evaluate the AI model's answers on different dimensions, pointing out its strengths or weaknesses \
+in each dimension and assigning a score of 1 to 10 for each.
+2. Finally, based on the assessments across dimensions, \
+provide an overall score of 1 to 10 for the AI model's response.
+3. Your scoring should be as stringent as possible and follow the scoring rules below:
+In general, the higher the quality of the model's response and its strict adherence to user needs, \
+the higher the score. Responses that do not meet user needs will receive lower scores.
+Scoring rules:
+Creativity:
+Scores 1-2 when there is no innovation or uniqueness in the content.
+Scores 3-4 when providing partially original content but with low creative quality.
+Scores 5-6 when mostly creative but lacks significant novelty, with moderate quality.
+Scores 7-8 when having novelty and high-quality content.
+Scores 9-10 when highly novel and of exceptional quality compared to the reference answer.
+Richness:
+Scores 1-2 when lacking depth and breadth, with very limited information.
+Scores 3-4 when limited in depth and breadth, with fewer explanations and examples, showing low diversity.
+Scores 5-6 when limited in depth and breadth but provides basic necessary information.
+Scores 7-8 when providing depth and useful additional information.
+Scores 9-10 when providing exceptional depth, breadth, and high diversity compared to the reference answer.
+Visual Perception:
+Scores 1-2 when the description of the visual information in the image contains errors or \
+is significantly inconsistent with the content of the image.
+Scores 3-4 When the description of the visual information in the image reflects only a small amount \
+of the image's information and contains some errors.
+Scores 5-6 when the description of the visual information in the image includes the basic information \
+of the image but contains minimal information.
+Scores 7-8 when the description of the visual information in the image matches the image well and is rich in content, \
+providing a substantial amount of information about the image.
+Scores 9-10 when the description of the visual information in the image not only matches the image \
+but also is more detailed and informative compared to the reference answer, providing more information about the image.
+Logical Coherence:
+Scores 1-2 when entirely incoherent, lacking any logic, and not matching the question or known information.
+Scores 3-4 when somewhat coherent but with many logical errors or inconsistencies.
+Scores 5-6 when mostly coherent, with few errors, but may struggle to maintain complete coherence in complex situations.
+Scores 7-8 when excellent logical handling, very few errors.
+Scores 9-10 when flawless logic, impeccable in handling complexity, \
+and significantly higher logical coherence compared to the reference answer.
+Answer Accuracy:
+Scores 1-2 when the answer is significantly inconsistent with the question or contains obvious errors.
+Scores 3-4 when the answer is partially correct but contains some errors or is incomplete.
+Scores 5-6 when the answer is basically correct but lacks details or is not sufficiently detailed.
+Scores 7-8 when the answer is accurate and detailed, fully corresponding to the question.
+Scores 9-10 when the answer is not only accurate and detailed but also provides additional useful information, \
+exceeding expectations.
+Image Relationship Understanding:
+Scores 1-2 when there are significant errors or confusion in distinguishing and describing different images, \
+unable to correctly identify and relate the content of the images.
+Scores 3-4 when the description of different images reflects only minimal distinguishing information, \
+contains some errors and confusion, and fails to clearly differentiate and relate the images.
+Scores 5-6 when the description of different images includes basic distinguishing information, \
+is able to correctly identify and relate the images in a basic manner, \
+but the information provided is minimal and lacks detail.
+Scores 7-8 when the description of different images is accurate and detailed, \
+clearly distinguishing and relating the images, \
+with rich content that points out the main commonalities and differences between the images.
+Scores 9-10 when the description of different images is not only accurate and detailed but also \
+provides richer information and analysis, clearly distinguishing and relating the images, \
+more comprehensively pointing out the commonalities and differences \
+between the images compared to the reference answer.
+Overall Score:
+Scores 1-2 when irrelevant to the question, factually incorrect, or generates harmful content.
+Scores 3-4 when no serious errors, mostly harmless, but of low quality and does not meet requirements.
+Scores 5-6 when basically meeting requirements but performing poorly in some dimensions, with moderate quality.
+Scores 7-8 when performing well in all dimensions.
+Scores 9-10 when fully addressing user questions and all requirements, significantly surpassing the reference answer.
+Please remember, you must evaluate and explain before scoring. After your explanation for each dimension, \
+add the score for that dimension. Finally, at the end of your response, \
+in the format of the dictionary (including brackets), return all your scoring results, \
+ensuring your scores are integers:
+{'Dimension One': Score, 'Dimension Two': Score, ..., 'Overall Score': Score}, \
+for example: {'Creativity': 9, 'Richness': 6, ..., 'Overall Score': 7}.\n
+"""
+question_begin_prompt = '[Question]'
+reference_begin_prompt = '[The Start of Reference Answer]'
+reference_end_prompt = '[The End of Reference Answer]'
+answers_begin_prompt = '[The Start of Assistant’s Answer]'
+answers_end_prompt = '[The End of Assistant’s Answer]'
+
+
+def mmdu_score(model, line):
+    question = eval(line['question'])
+    gt = eval(line['answer'])
+    prediction = eval(line['prediction'])
+
+    DIMS = [
+        'Creativity', 'Richness', 'Visual Perception', 'Logical Coherence',
+        'Answer Accuracy', 'Image Relationship Understanding', 'Overall Score'
+    ]
+
+    all_result_dict = []
+    logs = []
+    for j in range(len(question)):
+        try:
+            prompt = meta_prompt + question_begin_prompt + '\n' + question[j] + '\n\n' + \
+                reference_begin_prompt + '\n' + gt[j] + '\n' + reference_end_prompt + '\n\n' + \
+                answers_begin_prompt + '\n' + prediction[j] + '\n' + answers_end_prompt
+            response = model.generate(prompt)
+            start_index = response.find('{')
+            end_index = response.rfind('}') + 1
+            dictionary_str = response[start_index: end_index]
+            result_dict = eval(dictionary_str)
+            all_result_dict.append(result_dict)
+            if all([x in result_dict for x in DIMS]):
+                logs.append('Succeed')
+            else:
+                logs.append(
+                    f'Following Dims are not in results of turn {j}: '
+                    f'{",".join([x for x in DIMS if x not in result_dict])}'
+                )
+        except Exception as e:
+            logging.warning(str(e))
+            all_result_dict.append({d: None for d in DIMS})
+            logs.append(str(e))
+
+    df = pd.DataFrame(all_result_dict)
+    return dict(res=df, log='\n'.join(logs))

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

@@ -0,0 +1,434 @@
+# flake8: noqa
+import evaluate
+from tqdm import tqdm
+import numpy as np
+import os.path as osp
+import pandas as pd
+from vlmeval import load, dump, track_progress_rich
+
+g_eval_prompt = """
+You will be given a oracle caption that describes an image. You will then be given a second caption written for the same image.
+
+Your task is to rate the second caption on one metric.
+
+Evaluation Criteria:
+
+Relevance (1-5) - The extent to which the second caption is relevant to the key elements and context described in the oracle caption. A relevant caption should focus on the same subjects, objects, actions, or context highlighted in the oracle caption, without introducing unrelated or extraneous details.
+
+Evaluation Steps:
+
+1. Review the Oracle Caption: Carefully read the oracle caption to understand the main elements and context it describes.
+2. Review the Second Caption: Assess whether the second caption focuses on the same key elements and context as the oracle caption. Evaluate if the second caption stays on topic and does not introduce irrelevant details.
+3. Assign a Score for Relevance: Based on the Evaluation Criteria, rate how relevant the second caption is to the oracle caption's description of the same image.
+"""
+
+generate_atomic_facts_sys_prompt = """
+You will be given a caption for a figure containing multiple panels, which includes descriptions for the entire figure as well as each individual panel. Your task is to break down the caption into separate, independent descriptions for the entire figure and each panel, formatted appropriately and separated by '-'
+"""
+
+generate_atomic_facts_usr_prompt_one_shot = """
+The figure consists of four sub-figures labeled a, b, c, and d. All four images appear to be scanning electron microscope (SEM) images showing the microstructure of different materials, likely related to the iron-based cathode catalysts described in the article.\n\na. This image shows a highly porous structure with interconnected particles forming a network. The particles appear to be in the nanometer to micrometer size range. The scale bar indicates 1 \u03bcm.\n\nb. This image displays a closer view of what seems to be a similar material to (a), but at a higher magnification. The individual particles are more clearly visible, showing a rough, granular texture. The scale bar indicates 200 nm.\n\nc. This image reveals a different morphology compared to (a) and (b). It shows larger, more consolidated structures with a rougher surface texture. There are still visible pores and gaps between the structures. The scale bar indicates 1 \u03bcm.\n\nd. This final image appears to be a cross-sectional view of a porous material, possibly showing the internal structure of the catalyst. It reveals a highly interconnected network of pores and channels throughout the material. The scale bar indicates 200 nm.\n\nThese images likely represent different stages or variations of the iron-acetate/phenanthroline/zeolitic-imidazolate-framework-derived electrocatalyst mentioned in the article. The varying structures and porosities shown in these images could be related to the enhanced mass-transport properties and increased volumetric activity described in the text.
+Model_Response:
+- The figure consists of four sub-figures labeled a, b, c, and d.
+- All four images appear to be scanning electron microscope (SEM) images.
+- The images show the microstructure of different materials.
+- The materials are likely related to the iron-based cathode catalysts described in the article.
+- Image a shows a highly porous structure with interconnected particles forming a network.
+- The particles in image a are in the nanometer to micrometer size range.
+- The scale bar in image a indicates 1 μm.
+- Image b displays a closer view of a material similar to that in image a but at higher magnification.
+- The individual particles in image b are more clearly visible and show a rough, granular texture.
+- The scale bar in image b indicates 200 nm.
+- Image c shows larger, more consolidated structures with a rougher surface texture.
+- There are visible pores and gaps between the structures in image c.
+- The scale bar in image c indicates 1 μm.
+- Image d appears to be a cross-sectional view of a porous material.
+- Image d reveals the internal structure of the catalyst with a highly interconnected network of pores and channels.
+- The scale bar in image d indicates 200 nm.
+- These images likely represent different stages or variations of the iron-acetate/phenanthroline/zeolitic-imidazolate-framework-derived electrocatalyst mentioned in the article.
+- The varying structures and porosities shown in these images could be related to the enhanced mass-transport properties described in the text.
+- The varying structures and porosities in the images may contribute to increased volumetric activity described in the article.
+"""
+
+from pycocoevalcap.cider.cider import Cider
+cider_scorer = Cider()
+
+
+def compute_cider(predictions, references):
+    """
+    predictions: list of strings
+    references: list of list of strings
+    """
+    return cider_scorer.compute_score([{i: [ref for ref in refs]} for i, refs in enumerate(references)],
+                                      {i: [pred] for i, pred in enumerate(predictions)})[0]
+
+
+def get_all_metrics_for_reference_based_metrics(
+    references, candidates, image_id_list, reference_based_metrics_file,
+):
+    # Initialize the metrics
+    existing_data = load(reference_based_metrics_file) if osp.exists(reference_based_metrics_file) else {}
+    bleu_metric = evaluate.load("bleu")
+    rouge_metric = evaluate.load("rouge")
+    meteor_metric = evaluate.load("meteor")
+    bertscore_metric = evaluate.load("bertscore")
+    # cider_metric = evaluate.load("cider")
+
+    # bleu_scores = [[], [], [], [], []]  # B1, B2, B3, B4, BLEU
+    # rouge_scores = [[], [], [], []]  # ROUGE1, ROUGE2, ROUGEL, ROUGELSUM
+    # meteor_scores = []
+    # bertscore_scores = []
+
+    # Calculate scores for each sample
+    idx = 1
+    print(f"Calculating metrics for {len(references)} samples")
+    assert len(references) == len(candidates) == len(image_id_list)
+    for ref, cand, image_id in tqdm(zip(references, candidates, image_id_list)):
+        if not cand.strip():
+            print(cand)
+            continue
+
+        default_bleu_score = {"bleu": 0.0, "precisions": [0.0, 0.0, 0.0, 0.0]}
+        if image_id not in existing_data:
+            existing_data[image_id] = {}
+        bleu_score = existing_data.get(image_id, {}).get('bleu_score', default_bleu_score)
+
+        if bleu_score == default_bleu_score:
+            try:
+                bleu_score = bleu_metric.compute(predictions=[cand], references=ref)
+            except:
+                bleu_score = default_bleu_score
+            existing_data[image_id]['bleu_score'] = bleu_score
+
+        default_rouge_score = {
+            "rouge1": 0.0,
+            "rouge2": 0.0,
+            "rougeL": 0.0,
+            "rougeLsum": 0.0,
+        }
+        rouge_score = existing_data.get(image_id, {}).get('rouge_score', default_rouge_score)
+        if rouge_score == default_rouge_score:
+            try:
+                rouge_score = rouge_metric.compute(predictions=[cand], references=ref)
+            except:
+                rouge_score = default_rouge_score
+            existing_data[image_id]['rouge_score'] = rouge_score
+
+        # meteor score
+        default_meteor_score = 0.0
+        meteor_score = existing_data.get(image_id, {}).get('meteor_score', default_meteor_score)
+        if meteor_score == default_meteor_score:
+            try:
+                meteor_score = meteor_metric.compute(predictions=[cand], references=ref)[
+                    "meteor"
+                ]
+            except:
+                meteor_score = default_meteor_score
+            existing_data[image_id]['meteor_score'] = meteor_score
+
+        # bertscore
+        default_bertscore_score = {"f1": [0.0]}
+        bertscore_score = existing_data.get(image_id, {}).get('bertscore_score', default_bertscore_score)
+        if bertscore_score == default_bertscore_score:
+            try:
+                bertscore_score = bertscore_metric.compute(
+                    predictions=[cand], references=ref, lang="en"
+                )
+            except:
+                bertscore_score = default_bertscore_score
+            existing_data[image_id]['bertscore_score'] = bertscore_score
+
+        # cider score
+        default_cider_score = 0.0
+        cider_score = existing_data.get(image_id, {}).get('cider_score', default_cider_score)
+        if cider_score == default_cider_score:
+            try:
+                # cider_score = cider_metric.compute(predictions=[cand], references=ref)["score"]
+                cider_score = compute_cider([cand], [ref])
+            except:
+                cider_score = default_cider_score
+            existing_data[image_id]['cider_score'] = cider_score
+
+        if idx % 50 == 0:
+            print(f"Saving 50 samples to {reference_based_metrics_file}")
+            dump(existing_data, reference_based_metrics_file)
+
+        idx += 1
+
+    dump(existing_data, reference_based_metrics_file)
+    print(f"Saved all samples to {reference_based_metrics_file}")
+
+    return existing_data
+
+
+def llm_openai_judge(prediction, reference, dimension, prompt, model):
+
+    if isinstance(reference, list):
+        reference = reference[0]
+    assert isinstance(prediction, str)
+
+    if dimension == "fluency":
+        sys_prompt = prompt.format(Second=prediction)  # no reference
+        usr_prompt = f"Caption:\n{prediction}\n"
+    else:
+        sys_prompt = prompt.format(Target=reference, Second=prediction)
+        usr_prompt = f"Oracle Caption:\n{reference}\n\nSecond Caption:\n{prediction}\n\n"
+    usr_prompt += f"What is the {dimension} score (1-5)? Return the score ONLY!"
+
+    model.system_prompt = sys_prompt
+
+    answer = 0
+    all_responses = model.generate(usr_prompt)
+
+    for response in all_responses.choices:
+        response = response.message.content.strip()
+        try:
+            answer = int(response)
+            break
+        except:
+            for s in ["1", "2", "3", "4", "5"]:
+                if s in response:
+                    answer = int(s)
+                    break
+    return answer
+
+
+def g_eval_generate(evaluator, usr_prompt):
+    return evaluator.generate(usr_prompt)
+
+
+def get_all_metrics_for_g_eval_score(references, candidates, evaluator, tmp_file, nproc=4):
+    # relevance scores
+    assert len(references) == len(candidates)
+    tups = []
+    indices = range(len(references))
+    for reference, prediction in tqdm(zip(references, candidates)):
+        dimension = "relevance"
+        if isinstance(reference, list):
+            reference = reference[0]
+        assert isinstance(prediction, str)
+
+        sys_prompt = g_eval_prompt.format(Target=reference, Second=prediction)
+        usr_prompt = f"Oracle Caption:\n{reference}\n\nSecond Caption:\n{prediction}\n\n"
+        usr_prompt += f"What is the {dimension} score (1-5)? Return the score ONLY!"
+
+        evaluator.system_prompt = sys_prompt
+        tups.append((evaluator, usr_prompt))
+
+    ans = {}
+    if osp.exists(tmp_file):
+        ans = load(tmp_file)
+    ans = {k: v for k, v in ans.items() if evaluator.fail_msg not in str(v)}
+    tups = [x for x, i in zip(tups, indices) if i not in ans]
+    indices = [i for i in indices if i not in ans]
+
+    if len(indices):
+        _ = track_progress_rich(
+            g_eval_generate,
+            tups,
+            nproc=nproc,
+            chunksize=nproc,
+            keys=indices,
+            save=tmp_file,
+        )
+    ans = load(tmp_file)
+    return ans
+
+
+def merge_rating(refer_based_metrics_output_file_name, g_eval_metrics_output_file_name, fact_score_metrics_output_file):
+    # Update metrics columns for each row
+    refer_based_metrics_output_file = load(refer_based_metrics_output_file_name)
+    g_eval_metrics_output_file = load(g_eval_metrics_output_file_name)
+    # fact_score_metrics_output_file = load(fact_score_metrics_output_file)
+    for idx, item in refer_based_metrics_output_file.iterrows():
+        ref_based_metrics = eval(item['reference_based_metrics'])
+        refer_based_metrics_output_file.at[idx, 'B2'] = ref_based_metrics['bleu_score']['precisions'][1] * 100
+        refer_based_metrics_output_file.at[idx, 'RL'] = ref_based_metrics['rouge_score']['rougeL'] * 100
+        refer_based_metrics_output_file.at[idx, 'M'] = ref_based_metrics['meteor_score'] * 100
+        refer_based_metrics_output_file.at[idx, 'CD'] = ref_based_metrics['cider_score'] * 100
+        refer_based_metrics_output_file.at[idx, 'BS'] = ref_based_metrics['bertscore_score']['f1'][0] * 100
+        refer_based_metrics_output_file.at[idx, 'GE'] = g_eval_metrics_output_file.iloc[idx]['g_eval_metrics']
+        # refer_based_metrics_output_file.at[idx, 'FS'] = eval(fact_score_metrics_output_file.iloc[idx]['fact_score_metrics'])['score']
+
+    # df = refer_based_metrics_output_file
+    # # Filter rows for the two settings
+    # df_filtered = df[df['setting'].isin(['w/o.Abstract_w/o.Content', 'w.Abstract_w/o.Content'])]
+    # # metrics = ['B2', 'RL', 'M', 'BS', 'CD', 'GE']
+    # metrics = ['B2', 'RL', 'M', 'BS', 'GE']
+
+    # # Group by subject and setting, averaging metrics
+    # grouped = df_filtered.groupby(['subject', 'setting'])[metrics].mean()
+
+    # # Pivot to get multi-level columns: top level is setting, sub-level is metric
+    # result_df = grouped.unstack(level='setting')
+    # # Swap levels so that top level is setting
+    # result_df.columns = result_df.columns.swaplevel(0, 1)
+    # # Ensure columns order matches required settings
+    # result_df = result_df.reindex(columns=['w/o.Abstract_w/o.Content', 'w.Abstract_w/o.Content'], level=0)
+
+    # # Reset index to have subject as a column
+    # result_df = result_df.reset_index()
+    # return result_df
+
+    df = refer_based_metrics_output_file
+
+    # metrics = ['B2', 'RL', 'M', 'BS', 'CD', 'FS', 'GE']
+    metrics = ['B2', 'RL', 'M', 'BS', 'CD', 'GE']
+
+    subject_df = df.groupby('subject')[metrics].mean().reset_index()
+
+    category_df = df.groupby('category')[metrics].mean().reset_index()
+    category_df.rename(columns={'category': 'subject'}, inplace=True)
+    category_df['subject'] = 'CATEGORY_' + category_df['subject']
+
+    overall_row = df[metrics].mean().to_frame().T
+    overall_row.insert(0, 'subject', 'Overall')
+
+    result_df = pd.concat([subject_df, category_df, overall_row], ignore_index=True)
+
+    return result_df
+
+
+def dump_multiindex_excel(df, path):
+    from openpyxl import Workbook
+    from openpyxl.styles import Alignment
+    from openpyxl.utils.dataframe import dataframe_to_rows
+
+    wb = Workbook()
+    ws = wb.active
+    ws.title = "Sheet1"
+
+    ws.cell(row=1, column=1, value="subject")
+    col_levels = df.columns.levels
+    col_codes = df.columns.codes
+    level0_labels = [col_levels[0][i] for i in col_codes[0]]
+    level1_labels = [col_levels[1][i] for i in col_codes[1]]
+    unique_level0 = list(dict.fromkeys(level0_labels))
+
+    col_offset = 2
+    start = col_offset
+    for lvl0 in unique_level0:
+        count = level0_labels.count(lvl0)
+        end = start + count - 1
+        ws.merge_cells(start_row=1, start_column=start, end_row=1, end_column=end)
+        ws.cell(row=1, column=start, value=lvl0)
+        start = end + 1
+
+    ws.cell(row=2, column=1, value="subject")
+    for idx, label in enumerate(level1_labels):
+        ws.cell(row=2, column=col_offset + idx, value=label)
+
+    for r_idx, row in enumerate(df.itertuples(index=False), start=3):
+        ws.cell(row=r_idx, column=1, value=row[0])  # subject
+        for c_idx, val in enumerate(row[1:], start=2):
+            ws.cell(row=r_idx, column=c_idx, value=val)
+
+    for row in ws.iter_rows():
+        for cell in row:
+            cell.alignment = Alignment(horizontal='center', vertical='center')
+
+    wb.save(path)
+
+
+def extract_int(s, scales=[0, 5]):
+    # Regular expression to find float numbers between 0 and 1, including 0 and 1
+    for score in range(scales[0], scales[1] + 1):
+        if str(score) in s:
+            return int(score)
+    return None
+
+
+def get_score(
+    model,
+    content,
+    gamma=10,
+    scales=[0, 5],
+    atomic_facts=None,
+):
+
+    total_decisions = []
+    scores = []
+    init_scores = []
+
+    decisions = []
+    for atom in atomic_facts:
+        if not atom:
+            continue
+        atom = atom.strip()
+
+        definition = f"How relevant is the generated caption to the given human-written caption for the figure? Determine whether the information in the generated caption is included or mentioned in the human-written caption. Respond with a score between {scales[0]} and {scales[1]}."
+
+        prompt = "Human-written caption: {}\n\nGenerated caption: {}\n\nHow relevant is the generated caption to the given human-written caption? Respond with ONLY a score between {} and {}.".format(
+            content, atom, scales[0], scales[1]
+        )
+
+        model.system_prompt = definition
+        outputs = model.generate(prompt)
+
+        generated_answer = outputs.lower().strip()
+
+        generated_score = extract_int(generated_answer, scales=scales)
+
+        if generated_score is None:
+            generated_score = 0.0
+        else:
+            try:
+                # normalize the score to 0-1
+                generated_score = float(generated_score) / scales[1]
+            except Exception as e:
+                print("Error:", e)
+                generated_score = 0.0
+
+        print("Atom score:", generated_score)
+
+        decisions.append({"atom": atom, "is_supported": generated_score})
+
+    score = np.mean([d["is_supported"] for d in decisions])
+    if gamma:
+        init_scores.append(score)
+        penalty = (
+            1.0 if len(atomic_facts) > gamma else np.exp(1 - gamma / len(atomic_facts))
+        )
+        score = penalty * score
+
+    total_decisions.append(decisions)
+    scores.append(score)
+    print("Final score:", score)
+
+    out = {
+        "score": np.mean(scores),
+        "decisions": total_decisions,
+        "num_facts_per_response": np.mean(
+            [len(d) for d in total_decisions if d is not None]
+        ),
+    }
+
+    if gamma:
+        out["init_score"] = np.mean(init_scores)
+
+    return out
+
+
+def fact_score_generate(model, line):
+    generated_caption = line['prediction']
+    model.system_prompt = generate_atomic_facts_sys_prompt
+    mes = [
+        dict(type='text', value=generate_atomic_facts_usr_prompt_one_shot),
+        dict(type='text', value=generated_caption + '\nModel_Response:'),
+    ]
+    generated_facts = model.generate(mes).strip()
+    formatted_facts = generated_facts.split("-")
+    # topic = line["subject"]
+    # abstract = line["abstract"]
+
+    # ground-truth caption
+    content = line["caption"]
+
+    score_out = get_score(
+        model,
+        content,
+        gamma=10,
+        scales=[0, 5],
+        atomic_facts=formatted_facts,
+    )
+    return score_out

VLMEvalKit-sudoku/vlmeval/dataset/utils/mmsci4eval_req.txt

@@ -0,0 +1,6 @@
+evaluate
+pycocoevalcap
+bert_score
+rouge_score
+nltk
+absl-py

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

@@ -0,0 +1,703 @@
+import re
+import json
+from math import isclose
+from decimal import Decimal, getcontext
+from fractions import Fraction
+import sys
+import math
+import timeout_decorator
+import logging
+from ...smp import *
+
+try:
+    import sympy as sp
+    from sympy import simplify, Eq, sympify, evalf, Pow
+    from sympy.parsing.latex import parse_latex
+    import antlr4
+except ImportError:
+    logging.warning('sympy or antlr4 is not installed, please install it for OlympiadBench evaluation.')
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+def get_gpt4_extract_ICE():
+    example_1 = """
+1.
+Model response: 'Rounded to two decimal places, the perimeter of the sector is approximately:\n\n(-2, 1)'
+Extracted Answer: (-2, 1)
+""" # noqa
+
+    example_2 = """
+2.
+Model response: 'at those points.\n\nTherefore, the correct option that represents the meaning of the intersection points of the graphs is:\n\nD. They give the solutions to the equation $f(t)=g(t)$.",'
+Extracted Answer: D
+""" # noqa
+
+    example_3 = """
+3.
+Model response: ' at 1 (there's a closed circle at y = 1), the range in interval notation is \\((-4, 1]\\).\n\nFinal values:\nDomain: \\((-3, 3]\\)\nRange: \\((-4, 1]\\)'
+Extracted Answer: Domain: \\((-3, 3]\\)\nRange: \\((-4, 1]\\)
+""" # noqa
+
+    example_4 = """
+4.
+Model response: 'As it stands, I cannot provide the correct option letter because there isn't enough information to solve for 'y'.'
+Extracted Answer: null
+""" # noqa
+
+    example_5 = """
+5.
+Model response: 'Given that AB = 17.6 meters, we can now substitute into the equation:\n\nd = 17.6 / cos(38\u00b0)\n\nTherefore, to one decimal place, the distance d between Ned and Bart is approximately 22.3 meters.'
+Extracted answer: 22.3
+""" # noqa
+
+    example_6 = """
+6.
+Model response:  have all the coefficients for the quadratic function:\n\\( f(x) = ax^2 + bx + c \\)\n\\( f(x) = -1x^2 - 2x + 1 \\)\n\nTherefore, the equation for the graphed function \\( f \\) is:\n\\( f(x) = -x^2 - 2x + 1 \\)"'
+Extracted answer: f(x) = -x^2 - 2x + 1
+""" # noqa
+
+    return [example_1, example_2, example_3, example_4, example_5, example_6]
+
+
+def get_gpt4_score_ICE():
+    example_1 = """
+[Question]: Write the set of numbers represented on the number line in interval notation.
+[Standard Answer]: (-2,1]
+[Model_answer] : Extracted Answer: \\((-2, 1)\\)
+Judgement: 0
+""" # noqa
+
+    example_2 = """
+[Question]: As shown in the figure, circle O has a radius 1.0, if angle BAC = 60.0, then the length of BC is ()\nChoices:\nA:2\nB:2\u221a{{3}}\nC:\u221a{{3}}\nD:2\u221a{{2}}
+[Standard Answer]: C
+[Model_answer] : B:2\u221a{{3}}
+Judgement: 0
+""" # noqa
+
+    example_3 = """
+[Question]: Find the domain and range of the function f using interval notation.
+[Standard Answer]: domain: [-4, 0) and range: (-3, 1]
+[Model_answer] : Range: \\((-4, 1]\\)
+Judgement: 0
+""" # noqa
+
+    example_4 = """
+[Question]: As shown in the figure, circle O has a radius 1.0, if angle BAC = 60.0, then the length of BC is ()\nChoices:\nA:2\nB:2\u221a{{3}}\nC:\u221a{{3}}\nD:2\u221a{{2}}
+[Standard Answer]: C
+[Model_answer] : null
+Judgement: 0
+""" # noqa
+
+    return [example_1, example_2, example_3, example_4]
+
+
+def build_olympiad_gpt4_extract_prompt(line):
+    task_description = """
+I am providing you a response from a model to a math problem, termed 'Model Response'. You should extract the answer from the response as 'Extracted Answer'. Directly output the extracted answer with no explanation.\n\n
+""" # noqa
+    prediction = str(line['prediction'])
+    demo_prompt = task_description
+    examples = get_gpt4_extract_ICE()
+    for example in examples:
+        demo_prompt += example + '\n\n'
+    test_prompt = f"Model response: '{prediction}'\nExtracted Answer: "
+    full_prompt = f'{demo_prompt}7.\n{test_prompt}'
+
+    return full_prompt
+
+
+def build_olympiad_gpt4_score_prompt(line):
+    task_description = """
+Below are two answers to a math or a physics question. Question is [Question], [Standard Answer] is the standard answer to the question, and [Model_answer] is the answer extracted from a model's output to this question.  Determine whether these two answers are consistent.
+Please note that only when the [Model_answer] completely matches the [Standard Answer] means they are consistent. For non-multiple-choice questions, if the meaning is expressed in the same way, it is also considered consistent, for example, 0.5m and 50cm.
+If they are consistent, Judement is 1; if they are different, Judement is 0.\n\n
+""" # noqa
+    question_for_eval = line['question']
+    extract = line['extract']
+    answer = line['final_answer']
+    demo_prompt = task_description
+    examples = get_gpt4_score_ICE()
+    for example in examples:
+        demo_prompt += example + '\n\n'
+    test_prompt = f"""
+    [Question]: {question_for_eval}
+    [Standard Answer]: {answer}
+    [Model_answer] : {extract}
+    Judgement:"""
+    full_prompt = f'{demo_prompt}{test_prompt}'
+
+    return full_prompt
+
+
+def post_check_score(line, prefetch=False):
+    ans = str(line['final_answer']).strip()
+    response = str(line['extract']).strip()
+
+    if response == ans:
+        return response if prefetch else True
+    else:
+        return False
+
+
+def Olympiad_auxeval_extract(model, line):
+    prompt = build_olympiad_gpt4_extract_prompt(line)
+    log = ''
+    retry = 5
+    for i in range(retry):
+        prediction = line['prediction']
+        res = model.generate(prompt, temperature=i * 0.5)
+
+        if FAIL_MSG in res:
+            log += f'Try {i}: output is {prediction}, failed to parse.\n'
+        else:
+            log += 'Succeed'
+            return dict(log_extract=log, extract=res)
+    log += 'All 5 retries failed.\n'
+    return dict(log_extract=log, extract='')
+
+
+def Olympiad_auxeval_score(model, line):
+    prompt = build_olympiad_gpt4_score_prompt(line)
+    log = ''
+    retry = 5
+    if post_check_score(line, prefetch=True):
+        res = post_check_score(line, prefetch=True)
+        return dict(log_score='Prefetch succeed', score=True)
+    for i in range(retry):
+        prediction = line['prediction']
+        res = model.generate(prompt, temperature=i * 0.5)
+
+        if FAIL_MSG in res or res.strip() not in ['0', '1']:
+            log += f'Try {i}: output is {prediction}, res is {res}, failed to parse.\n'
+        else:
+            log += 'Succeed'
+            return dict(log_score=log, score=int(res) == 1)
+    log += 'All 5 retries failed.\n'
+    return dict(log_score=log, score=False)
+
+
+chinese_answer_type_dict = {
+    'Numerical': '数值',
+    'Expression': '表达式',
+    'Equation': '方程',
+    'Interval': '区间'
+}
+english_answer_type_dict = {
+    'Numerical': 'a numerical value',
+    'Expression': 'an expression',
+    'Equation': 'an equation',
+    'Interval': 'an interval'
+}
+
+
+def get_single_answer_type_text(answer_type, is_chinese):
+    if '-' in answer_type:  # No need now
+        answer_type = answer_type[:answer_type.find('-')]
+    for t in ['Numerical', 'Expression', 'Equation', 'Interval']:
+        if t in answer_type:
+            if is_chinese:
+                return chinese_answer_type_dict[t]
+            else:
+                return english_answer_type_dict[t]
+    exit(f'Error parsing answer type {answer_type}!')
+
+
+def get_answer_type_text(answer_type, is_chinese, multiple_answer):
+    # 'Tuple' has various meanings in different context, such as position or values of a series of variable,
+    # so it may lead to confusion to directly use 'tuple' in the prompt.
+    if ('Need_human_evaluate' in answer_type) or ('Tuple' in answer_type):
+        full_answer_text = ''
+    else:
+        if not multiple_answer:
+            answer_text = get_single_answer_type_text(answer_type, is_chinese)
+            if is_chinese:
+                full_answer_text = f'，答案类型为{answer_text}'
+            else:
+                full_answer_text = f"The answer of The problem should be {answer_text}. "
+        else:
+            if ',' not in answer_type:  # Same answer type for all answers
+                answer_text = get_single_answer_type_text(answer_type, is_chinese)
+                if is_chinese:
+                    full_answer_text = f'，题目有多个答案，答案类型均为{answer_text}'
+                else:
+                    full_answer_text = f'The problem has multiple answers, each of them should be {answer_text}. '
+            else:
+                answer_types = answer_type.split(',')
+                answer_types = [get_single_answer_type_text(t, is_chinese) for t in answer_types]
+                if len(set(answer_types)) == 1:
+                    answer_text = answer_types[0]
+                    if is_chinese:
+                        full_answer_text = f'，题目有多个答案，答案类型均为{answer_text}'
+                    else:
+                        full_answer_text = f'The problem has multiple answers, each of them should be {answer_text}. '
+                else:
+                    if is_chinese:
+                        answer_text = '、'.join(answer_types)
+                        full_answer_text = f'，题目有多个答案，答案类型分别为{answer_text}'
+                    else:
+                        answer_text = ', '.join(answer_types)
+                        full_answer_text = (
+                            f'The problem has multiple answers, with the answers in order being {answer_text}. '
+                        )
+    return full_answer_text
+
+
+def make_input(prompt, question_content):
+    # diversified based on the vllm, which is not implemented temporarily
+    input = prompt + '\n' + question_content
+    return input
+
+
+sys.set_int_max_str_digits(1000000)
+# 设置decimal的精度
+getcontext().prec = 50
+
+
+class MathJudger:
+    def __init__(self):
+        self.special_signal_map = {
+            "\\left": "",
+            "\\right": "",
+            "∶": ":",
+            "，": ",",
+            "$": "",
+            "\\approx": "=",
+            "\\simeq": "=",
+            "\\sim": "=",
+            "^\\prime": "'",
+            "^{\\prime}": "'",
+            "^\\circ": "",
+            "%": "",
+        }
+        self.pi = parse_latex("\\pi")
+        self.precision = 1e-8
+
+    def split_by_comma(self, expr: str):
+        in_bracket_num = 0
+        splitted_expr = []
+        start_idx = 0
+        for i, char in enumerate(expr):
+            if char == "(" or char == "[":
+                in_bracket_num += 1
+            elif char == ")" or char == "]":
+                in_bracket_num -= 1
+            elif char == "," and in_bracket_num == 0:
+                splitted_expr.append(expr[start_idx:i].strip())
+                start_idx = i + 1
+
+        if start_idx < len(expr):
+            splitted_expr.append(expr[start_idx:].strip())
+
+        return splitted_expr
+
+    def trans_plus_minus_sign(self, expr_list: list):
+        new_expr_list = []
+        for expr in expr_list:
+            if "\\pm" in expr:
+                new_expr_list.append(expr.replace("\\pm", "+"))
+                new_expr_list.append(expr.replace("\\pm", "-"))
+            else:
+                new_expr_list.append(expr)
+
+        return new_expr_list
+
+    def judge(self, expression1, expression2, precision=1e-8):
+        # (默认 expression1 为 Ground_Truth)
+        precision = precision if isinstance(precision, list) else [precision]
+
+        try:
+            expression1, expression2 = self.preprocess(expression1, expression2)
+        except:
+            return False
+        if expression1 == expression2:
+            # print("原生相等")
+            return True
+
+        # 去除字符串中的中文字符，因为上面已经判断过了类似回答为"能"或"不能"的含有中文字符的回答情况
+        expression1 = re.sub(r'[\u4e00-\u9fff]+', '', expression1)
+        expression2 = re.sub(r'[\u4e00-\u9fff]+', '', expression2)
+
+        expression1 = self.split_by_comma(expression1)
+        expression2 = self.split_by_comma(expression2)
+
+        temp_list1 = self.trans_plus_minus_sign(expression1)
+        temp_list2 = self.trans_plus_minus_sign(expression2)
+
+        # 设计误差值列表
+        if len(precision) <= 1:
+            precision = precision * len(temp_list1)
+
+        if len(temp_list1) != len(temp_list2):
+            return False
+
+        # 判断两个列表中的元素是否可以两两配对，并且两两相等，由此支持多个回答的比较
+        idx = -1
+        while len(temp_list1) != 0:
+            idx = (idx + 1) % len(temp_list1)
+
+            item1 = temp_list1[idx]
+            self.precision = precision[idx]
+            # print(self.precision)
+
+            for item2 in temp_list2:
+                try:
+                    if self.is_equal(item1, item2):
+                        temp_list1.remove(item1)
+                        temp_list2.remove(item2)
+                        precision.remove(self.precision)
+                        break
+                except Exception as err:
+                    logging.warning(f'{type(err)}: {err}')
+                    continue
+            else:
+                # If we didn't break from the inner loop, it means no match was found
+                return False
+
+        # If all elements are matched and removed, the lists can be paired
+        return True
+
+    def is_interval(self, epr):
+        return epr.startswith(("(", "[")) and epr.endswith((")", "]"))
+
+    # 在进行数值计算前，需要将sympy中的pi符号替换为pi的近似数值
+    # def sympy_sub_pi(self, expression_sympy):
+    #     return expression_sympy.subs(self.pi, math.pi)
+
+    # 默认第一个表达式是 ground_truth
+    @timeout_decorator.timeout(30)
+    def is_equal(self, expression1, expression2):
+        if expression1 == expression2 and expression1 != "" and expression2 != "":
+            # print("原生等价")
+            return True
+
+        # 先判断是否是两个区间，是的话进行判断相等，不相等则返回 False
+        if self.is_interval(expression1) and self.is_interval(expression2):
+            try:
+                if self.interval_equal(expression1, expression2):
+                    # print("区间等价")
+                    return True
+            except:
+                return False
+
+        # 再判断是否在数值上相等
+        try:
+            if self.numerical_equal(expression1, expression2):
+                # print("数值等价")
+                return True
+        except:
+            pass
+
+        # 再判断是否是表达式相等
+        try:
+            if self.expression_equal(expression1, expression2) and not ("=" in expression1 and "=" in expression2):
+                # print("表达式等价")
+                return True
+        except:
+            pass
+
+        # 再判断是否是等式相等
+        try:
+            if self.equation_equal(expression1, expression2):
+                # print("等式等价")
+                return True
+        except:
+            pass
+
+        return False
+
+    # 判断���个数值在误差允许范围内是否相等
+    def numerical_equal(self, expression1: str, expression2: str, include_percentage: bool = True):
+        """
+        (默认 expression1 为 Ground_Truth)
+        函数: 判读两个数值是否在误差允许范围内相等
+        步骤1: 将可能出现的百分号的情况包含进来
+        步骤2: 使用 math.isclose 函数判断是否相等
+        """
+        reference = float(expression1)
+        prediction = float(expression2)
+
+        if include_percentage:
+            gt_result = [reference / 100, reference, reference * 100]
+        else:
+            gt_result = [reference]
+
+        for item in gt_result:
+            # if isclose(item, prediction, abs_tol=self.precision, rel_tol=0):
+            if abs(item - prediction) <= self.precision * 1.01:
+                return True
+        return False
+
+    def expression_equal(self, exp1, exp2):
+        """
+        (默认 expression1 为 Ground_Truth)
+        函数: 判断两个表达式是否在数学意义上等价
+        步骤1: 提取表达式, 防止有的模型会给出"x=1"而不是"1"
+        步骤2: 使用 sympy 库进行等价判断
+        """
+
+        # 只提取等号右边的表达式，一般左边是所求的量
+        def extract_expression(expression):
+            if "=" in expression:
+                expression = expression.split("=")[1]
+            return expression.strip()
+
+        exp1 = extract_expression(exp1)
+        exp2 = extract_expression(exp2)
+
+        exp_too_long = len(exp1) > 300 or len(exp2) > 300
+
+        # 将表达式转换为 sympy 中能够进行处理的格式
+        expr1_sym = sympify(parse_latex(exp1))
+        expr2_sym = sympify(parse_latex(exp2))
+
+        if expr1_sym == expr2_sym:
+            return True
+        else:
+            expr1_sym = self.sympy_sub_pi(expr1_sym)
+            expr2_sym = self.sympy_sub_pi(expr2_sym)
+            # 如果输入的表达式可以计算出具体数值的话，则将其进行数值计算的比较
+
+            if (expr1_sym.has(sp.Symbol) and not expr2_sym.has(sp.Symbol)) or (
+                    not expr1_sym.has(sp.Symbol) and expr2_sym.has(sp.Symbol)):
+                return False
+            elif not expr1_sym.has(sp.Symbol) and not expr2_sym.has(sp.Symbol):
+                try:
+                    if not (self.can_compute_power(expr1_sym) and self.can_compute_power(expr2_sym)):
+                        print(
+                            "These two number can not be calculated by current computer for: "
+                            f"\"{str(expr1_sym)}\" and \"{str(expr2_sym)}\""
+                        )
+                        return False
+                    if exp_too_long:
+                        print(f'Expression {exp1} or {exp2} is too long to compute. ')
+                        return False
+
+                    if abs(expr1_sym.evalf() - expr2_sym.evalf()) <= self.precision * 1.01:
+                        return True
+                    else:
+                        return False
+                except:
+                    return False
+            elif exp_too_long:
+                print(f'Expression {exp1} or {exp2} is too long to compute. ')
+                return False
+            else:
+                try:
+                    simplified_expr = simplify(expr1_sym - expr2_sym)
+
+                    num_value = simplified_expr.evalf()
+
+                    return abs(num_value) < 1e-3
+                except:
+                    return False
+
+    def equation_equal(self, expression1, expression2):
+        """
+        (默认 expression1 为 Ground_Truth)
+        函数: 判断两个方程是否在数学意义上等价
+        步骤1: 将一个方程/等式化简为标准方程, 即等式的右边严格等于0, 接下来只需要判断两个等式的左边是否"等价"
+        步骤2: 使用 sympy 库计算两个等式左边的商, 如果这个商或者这个商的倒数为整数, 那么数学意义上我们可以推导出这两个方程等价👌
+        """
+
+        # 将等式的右边都移到左边，并返回一个 sympy 格式的表达式
+        def simplify_equation(latex_eq):
+            # 分割等式的左边和右边
+            lhs, rhs = latex_eq.split('=')
+
+            # 使用 parse_latex 解析 LaTeX 表达式
+            lhs_expr = parse_latex(lhs)
+            rhs_expr = parse_latex(rhs)
+
+            # 创建等式对象
+            equation = Eq(lhs_expr, rhs_expr)
+
+            # 化简等式：将等式右边移到左边
+            simplified_eq = simplify(equation.lhs - equation.rhs)
+
+            return simplified_eq
+
+        expr1_sym = simplify_equation(expression1)
+        expr2_sym = simplify_equation(expression2)
+
+        division_result_1 = simplify(expr1_sym / expr2_sym)
+        division_result_2 = simplify(expr2_sym / expr1_sym)
+
+        # 如果两个方程转换后的式子相除为整数 且非零，则根据推导可知这两个方程等价
+        if (division_result_1.is_Integer and division_result_1 != 0) or (
+                division_result_2.is_Integer and division_result_2 != 0):
+            return True
+        else:
+            return False
+
+    def interval_equal(self, expression1, expression2):
+        # 函数: 判断两个区间是否在数学意义上等价
+        # 步骤1: 简化区间的表达式, 去除无关的符号比如"\left", "\right", 同时将可能出现的"x \in"删去
+        # 步骤2: 对比两个区间的左右符号、中间出现的数学表达式等是否一致
+
+        def compare_two_interval(inter1, inter2):
+
+            # 首先比较两边的括号是否一致，一致的话再进行下一步比较
+            if inter1[0] != inter2[0] or inter1[-1] != inter2[-1]:
+                return False
+
+            inter1 = inter1.strip('[]()')
+            inter2 = inter2.strip('[]()')
+
+            # 分割区间的左右部分
+            items_1 = inter1.split(',')
+            items_2 = inter2.split(',')
+
+            for item_1, item_2 in zip(items_1, items_2):
+                if not self.expression_equal(item_1, item_2):
+                    return False
+            return True
+
+        interval1 = expression1
+        interval2 = expression2
+
+        if interval1 == interval2:
+            return True
+        else:
+            inter_list1 = interval1.split("\\cup")
+            inter_list2 = interval2.split("\\cup")
+
+            if len(inter_list1) != len(inter_list2):
+                return False
+            else:
+                for inter1, inter2 in zip(inter_list1, inter_list2):
+                    if not compare_two_interval(inter1, inter2):
+                        return False
+                return True
+
+    def preprocess(self, expression1, expression2):
+
+        # 尝试捕获box中的内容，如果有多个则以逗号相连返回，如果一个都没有，则报错
+        def extract_boxed_content(latex_str):
+            # 查找所有的 \boxed{...} 结构
+            boxed_matches = re.finditer(r'\\boxed{', latex_str)
+            results = ""
+
+            for match in boxed_matches:
+                start_index = match.end()
+                end_index = start_index
+                stack = 1
+
+                # 从 \boxed{ 之后开始搜索，直到找到对应的闭合括号
+                while stack > 0 and end_index < len(latex_str):
+                    if latex_str[end_index] == '{':
+                        stack += 1
+                    elif latex_str[end_index] == '}':
+                        stack -= 1
+                    end_index += 1
+
+                if stack == 0:
+                    # 提取 \boxed{} 内部的内容
+                    content = latex_str[start_index:end_index - 1]
+                    results += content + ","
+                else:
+                    # 如果括号没有正确闭合，则返回错误信息
+                    raise ValueError("Mismatched braces in LaTeX string.")
+
+            # 如果没有匹配到'\boxed{}'字符，则默认提取有内容的文字最后一行中的所有公式部分
+            if results == "":
+                last_line_ans = latex_str.strip().split("\n")[-1]
+                dollar_pattern = r"\$(.*?)\$"
+                answers = re.findall(dollar_pattern, last_line_ans)
+
+                if answers:
+                    for ans in answers:
+                        results += ans + ","
+                else:
+                    results = latex_str
+
+            return results
+
+        def sepcial_symbol_replace(expression):
+            if "\\in " in expression:
+                expression = expression.split("\\in ")[1]
+
+            # 进行特殊字符的替换，这些字符都不影响latex的解析，属于美观/修饰性字符
+            for signal in self.special_signal_map:
+                expression = expression.replace(signal, self.special_signal_map[signal])
+
+            expression = expression.strip("\n$,.:;^_=+`!@#$%^&*~，。")
+
+            pattern = r'\\(?:mathrm|mathbf)\{~?([^}]*)\}'
+            expression = re.sub(pattern, r'\1', expression)
+
+            return expression
+
+        exp1, exp2 = extract_boxed_content(expression1), extract_boxed_content(expression2)
+        exp1, exp2 = sepcial_symbol_replace(exp1), sepcial_symbol_replace(exp2)
+
+        return exp1, exp2
+
+    def can_compute_power(self, expr):
+        """
+        Check if the power expression can be computed.
+
+        Parameters:
+        expr (sympy expression): The expression to check.
+
+        Returns:
+        bool: True if the expression can be computed, False otherwise.
+        """
+        # Check if the expression is a power expression
+        if isinstance(expr, Pow):
+            # Extract the base and the exponent
+            base, exp = expr.as_base_exp()
+
+            # Check if the base and the exponent are numbers
+            if base.is_number and exp.is_number:
+                # Set a threshold for the maximum size of the exponent
+                MAX_EXP = 1000  # This threshold can be adjusted based on the computing environment
+
+                # Check if the exponent is greater than the threshold
+                if abs(exp.evalf()) > MAX_EXP:
+                    return False
+                else:
+                    return True
+            else:
+                # If the base or the exponent is not a number, we cannot compute the power
+                return False
+        else:
+            # If the expression is not a power expression, return True as it is not the case we are checking for
+            return True
+
+
+def extract_answer(is_chinese, model_output, is_deepseek=False):
+    # deepseekmath has special answering format
+    if str(model_output) == 'nan':
+        model_output = 'nan'
+
+    if is_deepseek:
+        if is_chinese:
+            matches = re.findall('## 解题答案(.*)', model_output)
+        else:
+            matches = re.findall('The answer is: (.*)', model_output)
+
+        # 检测是否至少找到一个匹配，如果没有就直接整个送进去找\boxed{}
+        if matches:
+            # 如果找到多个匹配，取最后一个
+            model_answer = matches[-1].strip()
+            return model_answer
+        else:
+            return model_output
+
+    if is_chinese:
+        matches = re.findall('所以最终答案是(.*)', model_output)
+    else:
+        matches = re.findall('So the final answer is (.*)', model_output)
+
+    # 检测是否至少找到一个匹配，如果没有就直接整个送进去找\boxed{}
+    if matches:
+        # 如果找到多个匹配，取最后一个
+        model_answer = matches[-1].strip()
+        return model_answer
+    else:
+        return model_output
+
+
+def calculate_merged_accuracy(reference_dir, text_only):
+    pass

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

@@ -0,0 +1,220 @@
+import re
+import numpy as np
+from .judge_util import build_judge
+from .yorn import YOrN_Extraction
+
+EVAL_TMPL = """
+You are an AI assistant tasked with evaluating whether a model's response correctly answers
+a given visual-language question.
+You will be provided with: 1. The model's response; 2. The ground truth answer.
+Your task is to determine whether the model's response conveys the same meaning as the ground truth.
+The response is considered **correct** if:
+- It has the same meaning as the ground truth, even if phrased differently.
+- It provides additional relevant details without altering the original meaning.
+The response is considered **wrong** if:
+- It contradicts the ground-truth
+- It misses essential information or include additional incorrect information.
+Your evaluation should include a single word (Either `"yes"` (if correct) or `"no"` (if incorrect)).
+
+Now please complete the following task:
+[Begin Response]{response}[End Response]
+[Begin Ground-Truth]{ground_truth}[End Ground-Truth]
+"""
+
+
+def _process_digit_article(inText):
+    outText = []
+    tempText = inText.lower().split()
+    articles = ['a', 'an', 'the']
+    manualMap = {
+        'none': '0', 'zero': '0',
+        'one': '1', 'two': '2', 'three': '3', 'four': '4', 'five': '5',
+        'six': '6', 'seven': '7', 'eight': '8', 'nine': '9', 'ten': '10',
+        'eleven': '11', 'twelve': '12', 'thirteen': '13', 'fourteen': '14',
+        'fifteen': '15', 'sixteen': '16', 'seventeen': '17', 'eighteen': '18',
+        'nineteen': '19', 'twenty': '20',
+    }
+    contractions = {
+        'aint': "ain't",
+        'arent': "aren't",
+        'cant': "can't",
+        'couldve': "could've",
+        'couldnt': "couldn't",
+        "couldn'tve": "couldn't've",
+        "couldnt've": "couldn't've",
+        'didnt': "didn't",
+        'doesnt': "doesn't",
+        'dont': "don't",
+        'hadnt': "hadn't",
+        "hadnt've": "hadn't've",
+        "hadn'tve": "hadn't've",
+        'hasnt': "hasn't",
+        'havent': "haven't",
+        'hed': "he'd",
+        "hed've": "he'd've",
+        "he'dve": "he'd've",
+        'hes': "he's",
+        'howd': "how'd",
+        'howll': "how'll",
+        'hows': "how's",
+        "Id've": "I'd've",
+        "I'dve": "I'd've",
+        'Im': "I'm",
+        'Ive': "I've",
+        'isnt': "isn't",
+        'itd': "it'd",
+        "itd've": "it'd've",
+        "it'dve": "it'd've",
+        'itll': "it'll",
+        "let's": "let's",
+        'maam': "ma'am",
+        'mightnt': "mightn't",
+        "mightnt've": "mightn't've",
+        "mightn'tve": "mightn't've",
+        'mightve': "might've",
+        'mustnt': "mustn't",
+        'mustve': "must've",
+        'neednt': "needn't",
+        'notve': "not've",
+        'oclock': "o'clock",
+        'oughtnt': "oughtn't",
+        "ow's'at": "'ow's'at",
+        "'ows'at": "'ow's'at",
+        "'ow'sat": "'ow's'at",
+        'shant': "shan't",
+        "shed've": "she'd've",
+        "she'dve": "she'd've",
+        "she's": "she's",
+        'shouldve': "should've",
+        'shouldnt': "shouldn't",
+        "shouldnt've": "shouldn't've",
+        "shouldn'tve": "shouldn't've",
+        "somebody'd": 'somebodyd',
+        "somebodyd've": "somebody'd've",
+        "somebody'dve": "somebody'd've",
+        'somebodyll': "somebody'll",
+        'somebodys': "somebody's",
+        'someoned': "someone'd",
+        "someoned've": "someone'd've",
+        "someone'dve": "someone'd've",
+        'someonell': "someone'll",
+        'someones': "someone's",
+        'somethingd': "something'd",
+        "somethingd've": "something'd've",
+        "something'dve": "something'd've",
+        'somethingll': "something'll",
+        'thats': "that's",
+        'thered': "there'd",
+        "thered've": "there'd've",
+        "there'dve": "there'd've",
+        'therere': "there're",
+        'theres': "there's",
+        'theyd': "they'd",
+        "theyd've": "they'd've",
+        "they'dve": "they'd've",
+        'theyll': "they'll",
+        'theyre': "they're",
+        'theyve': "they've",
+        'twas': "'twas",
+        'wasnt': "wasn't",
+        "wed've": "we'd've",
+        "we'dve": "we'd've",
+        'weve': "we've",
+        'werent': "weren't",
+        'whatll': "what'll",
+        'whatre': "what're",
+        'whats': "what's",
+        'whatve': "what've",
+        'whens': "when's",
+        'whered': "where'd",
+        'wheres': "where's",
+        'whereve': "where've",
+        'whod': "who'd",
+        "whod've": "who'd've",
+        "who'dve": "who'd've",
+        'wholl': "who'll",
+        'whos': "who's",
+        'whove': "who've",
+        'whyll': "why'll",
+        'whyre': "why're",
+        'whys': "why's",
+        'wont': "won't",
+        'wouldve': "would've",
+        'wouldnt': "wouldn't",
+        "wouldnt've": "wouldn't've",
+        "wouldn'tve": "wouldn't've",
+        'yall': "y'all",
+        "yall'll": "y'all'll",
+        "y'allll": "y'all'll",
+        "yall'd've": "y'all'd've",
+        "y'alld've": "y'all'd've",
+        "y'all'dve": "y'all'd've",
+        'youd': "you'd",
+        "youd've": "you'd've",
+        "you'dve": "you'd've",
+        'youll': "you'll",
+        'youre': "you're",
+        'youve': "you've",
+    }
+    for word in tempText:
+        word = manualMap.setdefault(word, word)
+        if word not in articles:
+            outText.append(word)
+    for wordId, word in enumerate(outText):
+        if word in contractions:
+            outText[wordId] = contractions[word]
+    outText = ' '.join(outText)
+    return outText
+
+
+class OmniVerifier:
+
+    tmpl_map = {
+        'boxed': r'\boxed\{([^}]*)\}',
+        'brace': r'\{([^}]*)\}'
+    }
+
+    def __init__(self,
+                 tmpl=None,
+                 judge='gpt-4o',
+                 lower_case=True,
+                 rule_only=False,
+                 retry=3,
+                 timeout=60,
+                 **kwargs):
+
+        self.judge = build_judge(model=judge, retry=retry, timeout=timeout)
+        self.tmpl = tmpl if tmpl not in self.tmpl_map else self.tmpl_map[tmpl]
+        self.lower_case = lower_case
+        self.rule_only = rule_only
+        if retry >= 3:
+            self.t_series = list(np.arange(0, 1, 1 / (retry - 1))) + [1.0, ]
+        else:
+            self.t_series = [0, 1] if retry == 2 else [0, ]
+        self.match = -1
+
+    def verify(self, prediction, gt, **kwargs):
+        prediction = str(prediction)
+        gt = str(gt)
+        if self.tmpl is not None:
+            matches = re.findall(self.tmpl, prediction)
+            if len(matches):
+                if isinstance(self.match, int) and self.match < len(matches):
+                    prediction = matches[self.match]
+        if self.lower_case:
+            prediction = prediction.lower()
+            gt = gt.lower()
+        prediction = _process_digit_article(prediction)
+        gt = _process_digit_article(gt)
+        if gt == prediction:
+            return True, 'Rule Match'
+        else:
+            if self.rule_only:
+                return False, f'Rule Match: Prediction: {prediction}, GT: {gt}'
+            judge_prompt = EVAL_TMPL.format(response=prediction, ground_truth=gt)
+            for t in self.t_series:
+                res = self.judge.generate(judge_prompt, temperature=t, **kwargs)
+                answer = YOrN_Extraction(res)
+                if answer in ['Yes', 'No']:
+                    return answer == 'Yes', 'Judge Match'
+        return False, f'Judge Failed: Prediction: {prediction}, GT: {gt}'

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

@@ -0,0 +1,49 @@
+from ...smp import *
+from .multiple_choice import extract_answer_from_item
+from PIL import Image, ImageOps
+import numpy as np
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+VQA_JUDGE_SYS_PROMPT = """
+You are a helpful assistant that grades answers related to visual video quality.
+There are a lot of special terms or keywords related to video processing and photography.
+You will pay attention to the context of `quality evaluation' when grading.
+"""
+
+VQA_JUDGE_USER_PROMPT = """
+Given the question {}, evaluate whether the response {} completely matches the correct answer {}.
+First, check the response and please rate score 0 if the response is not a valid answer.
+Please rate score 2 if the response completely or almost completely matches the correct answer on completeness, accuracy, and relevance.
+Please rate score 1 if the response partly matches the correct answer on completeness, accuracy, and relevance.
+Please rate score 0 if the response doesn't match the correct answer on completeness, accuracy, and relevance at all.
+Please only provide the result in the following format: Score:'
+"""  # noqa: E501
+
+
+def check_ans_mcq(pred, ans, correct_choice, correct_answer):
+    flag = False
+
+    if correct_choice == pred or correct_choice + "." in pred or correct_answer == pred:
+        flag = True
+    elif correct_choice in pred.split("\n"):
+        flag = True
+
+    return flag
+
+
+def check_ans_vqa(model, line):
+    score = model.generate(VQA_JUDGE_USER_PROMPT.format(line['question'], line['prediction'], line['answer'])).strip()
+    return score
+
+
+def get_dimension_rating(score_file):
+    score = load(score_file)
+    result_dict = {}
+    for idx, item in score.iterrows():
+        question_type = eval(item['dimensions'])[0].split(',')[0]
+        if question_type not in result_dict:
+            result_dict[question_type] = [0, 0]
+        result_dict[question_type][0] += int(item['score'])
+        result_dict[question_type][1] += 1
+    return result_dict

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

@@ -0,0 +1,123 @@
+from ...smp import *
+from ...utils import can_infer
+
+
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+
+def get_gpt4_ICE_for_qspatial():
+    example_1 = """
+Hint: Please answer the question requiring in a tuple format. The tuple should contain a numeric value and a unit,
+e.g., (1, m), (2.2, cm), (3.12, meter), at the end.\n
+Model response: **Object Identification**
+
+* The object in question is a chair.
+* The chair is not visible in the image.
+
+**Conclusion**
+
+The height of the chair cannot be determined from the provided image.\n
+Extracted answer: (0, cm)
+"""
+
+    example_2 = """
+Hint: Please answer the question requiring in a tuple format. The tuple should contain a numeric value and a unit,
+e.g., (1, inch), (1.2, cm), (3.0, feet), at the end.\n
+Model response: **Step 1: Identify the stapler and the recycle bin in the image.**
+
+The stapler is located on the wooden table, and the recycle bin is located on the floor.
+
+**Step 2: Determine the distance between the stapler and the recycle bin.**
+
+The stapler is 0.5 meters from the edge of the table, and the recycle bin is 1.5 meters from the edge of the table.
+Therefore, the minimum distance between the stapler and the recycle bin is 1.5 - 0.5 = 1 meter.
+
+**Answer:** 1 m\n
+Extracted answer: (1, m)
+"""
+    example_3 = """
+Hint: Please answer the question requiring in a tuple format. The tuple should contain a numeric value and a unit,
+e.g., (1, foot), (2, cm), (4.3, meter), at the end.\n
+Model response: The mirror in the image is approximately 5 feet 4 inches tall.\n
+Extracted answer: (64, inch)
+"""
+    example_4 = """
+Hint: Please answer the question requiring in a tuple format. The tuple should contain a numeric value and a unit,
+e.g., (0.1, cm), (2.9, cm), (0.3, meter), at the end.\n
+Model response: The minimum distance between the wooden chair and the chair near the camera in the image is 1.7 feet.\n
+Extracted answer: (1.7, feet)
+"""
+    example_5 = """
+Hint: Please answer the question requiring in a tuple format. The tuple should contain a numeric value and a unit,
+e.g., (5.1, cm), (0.9, cm), (55, mm), at the end.\n
+Model response: The height of the painting's bottom edge from the floor is approximately 4.5 feet.\n
+Extracted answer: (4.5, feet)
+"""
+    return [example_1, example_2, example_3, example_4, example_5]
+
+
+def list_to_dict(lst):
+    return {chr(65 + i): val for i, val in enumerate(lst)}
+
+
+def post_check(line, prefetch=False):
+    res = None
+    ans = line['answer']
+    response = line['prediction'] if prefetch else line['res']
+    try:
+        if line['question_type'] == 'multi_choice':
+            ans = line['answer_option']
+            choices = list_to_dict(eval(line['choices']))
+            res = can_infer(response, choices)
+            if prefetch:
+                return res
+        else:
+            if line['answer_type'] == 'integer':
+                res = int(response)
+                ans = int(line['answer'])
+            elif line['answer_type'] == 'float':
+                res = float(response)
+                ans = float(line['answer'])
+            else:
+                res = str(res)
+                ans = str(ans)
+    except ValueError:
+        pass
+
+    if res == ans:
+        return res if prefetch else True
+    else:
+        return False
+
+
+def build_qspatial_gpt4_prompt(line):
+    task_description = """
+Please read the following example.
+Then extract the answer from the model response and type it at the end of the prompt.\n
+"""
+    prediction = str(line['prediction'])
+    prompt = task_description
+    examples = get_gpt4_ICE_for_qspatial()
+    for example in examples:
+        prompt += example + '\n'
+    prompt += 'Model respone: ' + prediction
+    prompt += '\nExtracted answer:'
+    return prompt
+
+
+def QSpatial_auxeval(model, line):
+    prompt = build_qspatial_gpt4_prompt(line)
+
+    log = ''
+    retry = 5
+    for i in range(retry):
+        prediction = line['prediction']
+        res = model.generate(prompt, temperature=i * 0.5)
+
+        if FAIL_MSG in res:
+            log += f'Try {i}: output is {prediction}, failed to parse.\n'
+        else:
+            log += 'Succeed'
+            return dict(log=log, res=res)
+    log += 'All 5 retries failed.\n'
+    return dict(log=log, res='')

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

@@ -0,0 +1,312 @@
+from ...smp import *
+from collections import OrderedDict, defaultdict
+import re
+from sympy.parsing.latex import parse_latex
+from sympy import latex, Eq, simplify
+FAIL_MSG = 'Failed to obtain answer via API.'
+
+prompt_scoring = r"""
+You are a physics professor, please determine if the Standard answer and Model Answer are equivalent. Note that the significant figures in the answer must meet the requirements. Your judgment should be 0 (non-equivalent) or 1 (equivalent).
+
+[Question]: A force of 20 N acts on an object of mass 5 kg. What is the acceleration of the object?
+[Standard Answer]: 4 m/s²
+[Model Answer] : 4
+Judgement: 1
+
+[Question]: A projectile is launched at an angle $\\theta$ with initial velocity $v_0$. What is its time of flight before returning to the same height, assuming negligible air resistance and gravitational acceleration $g$?
+[Standard Answer]: $$ t = \\frac{{2 v_0 \\sin(\\theta)}}{{g}} $$
+[Model Answer] : Extracted Answer: $$ t = \\frac{{2 v_0 \\cos(\\frac{\\pi}{2} - \\theta)}}{{g}} $$
+Judgement: 1
+
+[Question]: The position of a particle is given by $x(t) = 3t^2 - 2t + 5$ meters. What is its instantaneous velocity at $t=2$ seconds?
+[Standard Answer]: 10 m/s
+[Model Answer] : Velocity $v(t) = dx/dt = 6t - 2$. At $t=2s$, $v(2) = 6(2) - 2 = 12 - 2 = 10$. So the velocity is 10 m/s.
+Judgement: 1
+
+[Question]: A car travels North at 20 m/s. It then turns and travels East at 20 m/s. What is the magnitude of its change in velocity?
+[Standard Answer]: Approximately 28.3 m/s
+[Model Answer] : The change in velocity is 0 m/s because the speed is the same.
+Judgement: 0
+
+[Question]: An object is thrown horizontally from a height of 20m with an initial speed of 10 m/s. Calculate: (a) the time it takes to hit the ground ($t_g$), and (b) the horizontal distance ($d_x$) it travels before hitting the ground. (Use g = 10 m/s²)
+[Standard Answer]: (a) $t_g = 2$ s, (b) $d_x = 20$ m
+[Model Answer] : (a) The time to hit the ground $t_g$ is 2 s. (b) The horizontal distance $d_x$ is 10 m.
+Judgement: 0
+
+[Question]: An engine performs $1.2 \\times 10^5$ J of work in 2 minutes. What is its average power output in watts?
+[Standard Answer]: 1 kW
+[Model Answer] : Power = Work / Time = $1.2 \\times 10^5$ J / (2 min * 60 s/min) = $1.2 \\times 10^5$ J / 120 s = 1000 W.
+Judgement: 1
+
+[Question]: A resistor has a voltage of 10V across it and a current of 2A flowing through it. What is its resistance and power dissipation?
+[Standard Answer]: Resistance R = 5 Ohms , Power P = 20 Watts.
+[Model Answer] : The resistance is $R = V/I = 10V / 2A = 5 \Omega$. The power dissipated is $P = VI = 10V \\times 2A = 20W$.
+Judgement: 1
+
+[Question]: The displacement of an object in Simple Harmonic Motion (SHM) is given by $x(t) = A \sin(\omega t)$. Determine the equation for its acceleration, $a(t)$.
+[Standard Answer]: $$ a(t) = -A\omega^2 \sin(\omega t) $$
+[Model Answer] : The acceleration is the second derivative of displacement. $v(t) = A\omega \cos(\omega t)$. $a(t) = A\omega^2 \cos\left(\omega t + \\frac{\pi}{2}\\right)$.
+Judgement: 1
+
+[Question]: 给出相对论性粒子总能量 $E$ 的速度展开式（到 $v^4/c^4$ 项）。
+[Standard Answer]: $E = mc^2 \left(1 + \frac{v^2}{2c^2} + \frac{3v^4}{8c^4} + \mathcal{O}(v^6/c^6)\right)$
+[Model Answer]: $E = \gamma m c^2 = \frac{mc^2}{\sqrt{1 - v^2/c^2}} \approx mc^2 + \frac{1}{2}mv^2 + \frac{3}{8} \frac{mv^4}{c^2}$
+Judgement: 1
+
+[Question]: 计算粒子能量 $E$ 穿过势垒 $V_0$ ($E < V_0$) 的透射系数 $T$。
+[Standard Answer]: $\ln T \approx \ln 16 + \ln\left(\frac{E}{V_0}\right) + \ln\left(1 - \frac{E}{V_0}\right) - \frac{2d}{\hbar} \sqrt{2m(V_0 - E)}$
+[Model Answer]: $T \approx 16 \frac{E}{V_0} \left(1 - \frac{E}{V_0}\right) e^{-2d\sqrt{2m(V_0 - E)}/\hbar}$
+Judgement: 1
+
+[Question]: The position of a particle is given by $x(t) = (2t^3 - 3t)$ meters. What is its acceleration at $t=1$ second? The final answer should retain 3 significant figures.
+[Standard Answer]: 12.0 m/s²
+[Model Answer] : $v(t) = 6t^2 - 3$. $a(t) = 12.1t$. At $t=1s$, $a(1) = 12.1 \\text{ m/s}^2$.
+Judgement: 0
+---
+Now please provide your judgement (0 or 1), DONNOT output explanation:
+""" # noqa
+
+
+def get_example():
+    example_1 = """
+Question: What is the net force acting on a 5 kg object accelerating at 3 m/s² to the right?\n
+Model response: Using F = ma, the net force is 15 N to the right.\n
+Extracted answer: the net force is 15 N to the right.
+""" # noqa
+
+    example_2 = """
+Question: Calculate the charge of an electron. (Unit: C)\n
+Model response: The elementary charge of an electron is approximately -1.602 × 10⁻¹⁹ coulombs.\n
+Extracted answer: -1.602 × 10⁻¹⁹ C
+""" # noqa
+
+    example_3 = """
+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
+""" # noqa
+
+    example_4 = """
+Question: Between which frequencies does human hearing typically range? \n
+Model response: Human hearing ranges between 20 Hz and 20,000 Hz.\n
+Extracted answer: [20 Hz, 20000 Hz]
+""" # noqa
+
+    example_5 = """
+Question: List the wavelengths of visible light colors.\n
+Model response: Visible light ranges from:\n
+- Red: ~700 nm\n
+- Green: ~550 nm\n
+- Blue: ~450 nanometre\n
+Extracted answer: Red: 700 nm; Green: 550 nm; Blue: 450 nanometre.
+""" # noqa
+    return [example_1, example_2, example_3, example_4, example_5]
+
+
+def build_extract_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 # noqa
+"""
+    question = "Please answer this question in the image." if str(line['question']) == 'nan' else line['question'] # noqa
+
+    prediction = extract_by_rule(line)
+    prompt = task_description
+    examples = get_example()
+    for example in examples:
+        prompt += example + '\n'
+    prompt += question + '\n'
+    prompt += 'Model response: ' + prediction
+    prompt += 'Extracted answer:'
+    return prompt
+
+
+def list_to_dict(lst):
+    return {chr(65 + i): val for i, val in enumerate(lst)}
+
+
+def extract_by_rule(line):
+    response = line['prediction']
+    try:
+        pattern = r'<answer>\s*(\d+)\s*</answer>'
+        match = re.search(pattern, response)
+        if match:
+            response = match.group(1)
+            return response
+
+    except Exception:
+        pass
+    try:
+        pattern = r"the final answer is: (.+?)\."
+        match = re.search(pattern, response)
+        if match:
+            response = match.group(1)
+            return response
+    except Exception:
+        pass
+    try:
+        pattern = r"The answer is: (.+?)\."
+        match = re.search(pattern, response)
+        if match:
+            response = match.group(1)
+            return response
+    except Exception:
+        pass
+
+    try:
+        response = int(response)
+        return str(response)
+    except Exception:
+        pass
+    try:
+        response = float(response)
+        return str(response)
+    except Exception:
+        pass
+    return str(response)
+
+
+def quick_compare(response, answer, tol=1e-6):
+    if response is None or answer is None:
+        return False
+
+    # 场景1：比较数值（如 "3.1415" vs "\pi"）
+    if response.is_Number and answer.is_Number:
+        return abs(float(response - answer)) < tol
+    # 场景2：比较等式（如 "x = y" vs "y = x"）
+    if isinstance(response, Eq) and isinstance(answer, Eq):
+        return simplify(response.lhs - response.rhs) == simplify(answer.lhs - answer.rhs)
+
+    # 场景3：比较表达式（如 "\frac{x}{y}" vs "x/y"）
+    return simplify(response - answer) == 0
+
+
+def post_check(line, prefetch=False):
+    # prefetch: return extracted response
+    ans = line['answer']
+    try:
+        res = extract_by_rule(line)
+    except ValueError:
+        return False
+
+    if str(res) == str(ans):
+        return str(res) if prefetch else True
+
+    try:
+        parsed_res = parse_latex(res)
+        parsed_ans = parse_latex(ans)
+        if quick_compare(parsed_res, parsed_ans):
+            return latex(parsed_res) if prefetch else True
+    except Exception:
+        return False
+    return False
+
+
+def extract(model, line):
+    log = ''
+    retry = 5
+    if post_check(line, prefetch=False):
+        res = post_check(line, prefetch=True)
+        return dict(log='Prefetch succeed', extract=res, score=1)
+    else:
+        prompt = build_extract_prompt(line)
+        for i in range(retry):
+            prediction = line['prediction']
+            res = model.generate(prompt, temperature=i * 0.5)  # extract
+            if not res or FAIL_MSG in res:
+                log += f'Try {i}: output is {prediction}, failed to parse.\n'
+            else:
+                log += 'Succeed'
+                score = score_func(model, res, line['question'], line['answer'])
+                if score is None:
+                    log += '\nScore failed'
+                    return dict(log=log, extract=res, score=-1)
+                return dict(log=log, extract=res, score=score)
+    log += 'All 5 retries failed.\n'
+    return dict(log=log, extract='', score=-1)
+
+
+def score_func(model, response, query, gt):
+    if not response:
+        return 0
+    try:
+        full_prompt = prompt_scoring.strip() + f"\n[Question]: \{query}\\n[Standard Answer]: {gt}\\n[Model Answer]: {response}\\nJudgement: "  # noqa
+        try_n = 0
+        while try_n < 5:
+            score = model.generate(full_prompt, temperature=try_n * 0.3)
+            if 'Judgement: ' in score:
+                score = score.split('Judgement: ')[-1]
+            elif 'Judgement:' in score:
+                score = score.split('Judgement:')[-1]
+            elif 'judgement: ' in score:
+                score = score.split('judgement: ')[-1]
+            elif 'judgement:' in score:
+                score = score.split('judgement:')[-1]
+            try:
+                if int(score) == 0 or int(score) == 1:
+                    return int(score)
+            except Exception:
+                continue
+    except Exception as e:
+        print("score_func Error!")
+        print(e)
+        return None
+
+
+def eval_acc(result_file):
+    data = load(result_file)
+    keys = ['level', 'subject', 'language', 'source', 'vision_relevance', 'img_category', 'sig_figs']
+    keys = [k for k in keys if k in data]
+    tot = {k: defaultdict(lambda: 0) for k in keys}
+    fetch = {k: defaultdict(lambda: 0) for k in keys}
+    hit = {k: defaultdict(lambda: 0) for k in keys}
+    tot['Overall'] = 0
+    fetch['Overall'] = 0
+    hit['Overall'] = 0
+
+    lt = len(data)
+    for i in range(lt):
+        item = data.iloc[i]
+        tot['Overall'] += 1
+        for k in keys:
+            value = str(item[k])
+            tot[k][value] += 1
+
+        if 'Prefetch succeed' in item['log']:
+            fetch['Overall'] += 1
+            for k in keys:
+                value = str(item[k])
+                fetch[k][value] += 1
+
+        if post_check(item, prefetch=False):
+            hit['Overall'] += 1
+            for k in keys:
+                value = str(item[k])
+                hit[k][value] += 1
+        elif item['score'] == 1:
+            hit['Overall'] += 1
+            for k in keys:
+                value = str(item[k])
+                hit[k][value] += 1
+
+    res = {k: defaultdict(lambda: 0) for k in keys}
+    res['acc'] = 0
+    res['prefetch_rate'] = 0
+
+    res['acc'] = hit['Overall'] / tot['Overall'] * 100 if tot['Overall'] > 0 else 0
+    res['prefetch_rate'] = fetch['Overall'] / tot['Overall'] * 100 if tot['Overall'] > 0 else 0
+
+    def calculate_accuracy(hit_dict, tot_dict, res_dict, category):
+        for key in tot_dict[category]:
+            total = tot_dict[category][key]
+            hits = hit_dict[category][key]
+            res_dict[category][key] = hits / total * 100 if total > 0 else 0
+
+    for category in keys:
+        calculate_accuracy(hit, tot, res, category)
+    res_dict = {
+        'Overall': {
+            'Accuracy (%)': res['acc'], 'PrefetchRate (%)': res['prefetch_rate']
+        }, **{cat: dict(res[cat]) for cat in keys}
+    }
+    return res_dict

VLMEvalKit-sudoku/vlmeval/dataset/utils/vgrpbench/configs/formating-prompt/aquarium/filter_prompt.json

@@ -0,0 +1,118 @@
+[
+    {
+        "role": "system", 
+        "content": "You are a text formater, your goal is to extract two parts, perception and answer from the answer and put them into a good format. Please according to the conversation history with the user feedback. The desired format is a 2d array, where there is only 0, e, or s; *, or 0, or _, or -, or e might indicates empty that you should convert to 0. If the perception / answer is not a valid solution or not existe, please put a Wrong there. Sometimes perception is not given but answer is there, you should put a Wrong for perception and process the answer. Your goal is only to format the user's input, not to check if it is correct or not."},
+    {
+        "role": "user",
+        "content": "```json\n{\n\"perception\": [\n  [\"*\", \"*\", \"*\", \"*\"],\n  [\"*\", \"*\", \"*\", \"*\"],\n  [\"*\", \"*\", \"*\", \"*\"],\n  [\"*\", \"*\", \"*\", \"*\"]\n],\n\"think\": \"Based on the numbers given on the sides, each row and column must have 2 filled cells. To ensure contiguity at the bottom, the filled cells should be placed in the bottom two rows. The first and third columns have a constraint of 4 filled cells, so those columns must have the bottom two cells filled. The second and fourth columns can have any two cells filled in the bottom two rows.\",\n\"answer\": [\n  [\"e\", \"e\", \"e\", \"e\"],\n  [\"e\", \"e\", \"e\", \"e\"],\n  [\"s\", \"s\", \"s\", \"s\"],\n  [\"s\", \"e\", \"s\", \"e\"]\n]\n}\n```"
+    },
+    {  
+        "role": "assistant",
+        "content": "Initial State\n[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]\nSolution\n[[0,0,0,0],[0,0,0,0],[s,s,s,s],[s,0,s,0]]"
+    },
+    {
+        "role": "user",
+        "content": "Yes. "
+    },
+    {
+        "role": "user",
+        "content": "```json\n{\n  \"perception\": [\n    [\"*\", \"*\", \"*\", \"*\", \"*\"],\n    [\"*\", \"*\", \"*\", \"*\", \"*\"],\n    [\"*\", \"*\", \"*\", \"*\", \"*\"],\n    [\"*\", \"*\", \"*\", \"*\", \"*\"],\n    [\"*\", \"*\", \"*\", \"*\", \"*\"]\n  ],\n  \"think\": \"The puzzle is a 4x5 grid. Each column and row has a number indicating how many cells should be filled in that row/column. The filled cells must be contiguous. \\nLet's start with the first column which has 4 filled cells. Since the filled cells must be contiguous, we can fill the bottom four cells of the first column. Similarly, the last column also has 4 filled cells, so we fill the bottom four cells. The second and third columns have 2 filled cells each. We can fill the bottom two cells in each of these columns. This satisfies the column constraints. Now let's check the row constraints. The bottom two rows have 4 filled cells each, which is satisfied by our current solution. The top two rows have 2 filled cells each, which is also satisfied. Therefore, this is the solution.\",\n  \"answer\": [\n    [\"e\", \"e\", \"e\", \"e\", \"e\"],\n    [\"e\", \"e\", \"e\", \"e\", \"e\"],\n    [\"s\", \"s\", \"s\", \"s\", \"s\"],\n    [\"s\", \"s\", \"s\", \"s\", \"s\"],\n    [\"s\", \"s\", \"s\", \"s\", \"s\"]\n  ]\n}\n```"
+    },
+    {
+        "role": "assistant",
+        "content": "Initial State\n[[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0]]\nSolution\n[[0,0,0,0,0],[0,0,0,0,0],[s,s,s,s,s],[s,s,s,s,s],[s,s,s,s,s]]"
+
+    },
+    {
+        "role": "user",
+        "content": "Yes. "
+    },
+    {
+        "role": "user",
+        "content":"```json\n{\n\"perception\": [[\"*\", \"*\", \"*\", \"*\"], [\"*\", \"*\", \"*\", \"*\"], [\"*\", \"*\", \"*\", \"*\"], [\"*\", \"*\", \"*\", \"*\"]],\n\"answer\": [[\"s\", \"s\", \"e\", \"e\"], [\"s\", \"s\", \"e\", \"e\"], [\"e\", \"e\", \"s\", \"s\"], [\"e\", \"e\", \"s\", \"s\"]]\n}\n```"
+    },
+    {
+        "role": "assistant", 
+        "content": "Initial State\n[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]\nSolution\n[[s,s,0,0],[s,s,0,0],[0,0,s,s],[0,0,s,s]]"
+    },
+    {
+        "role": "user",
+        "content": "Yes. "
+    },
+    {
+        "role": "user", 
+        "content": "**Current Game State:**\n```json\n{\n\"perception\": [\n[\"s\", \"e\", \"e\", \"e\"],\n[\"e\", \"e\", \"e\", \"s\"],\n[\"e\", \"s\", \"e\", \"s\"],\n[\"e\", \"e\", \"e\", \"s\"],\n[\"s\", \"e\", \"s\", \"e\"],\n[\"e\", \"s\", \"e\", \"e\"],\n[\"e\", \"e\", \"e\", \"s\"]\n]\n}\n```\n\n**Solution:**\n```json\n{\n\"answer\": [\n[\"s\", \"s\", \"e\", \"s\"],\n[\"e\", \"s\", \"s\", \"s\"],\n[\"e\", \"s\", \"e\", \"s\"],\n[\"e\", \"e\", \"s\", \"s\"],\n[\"s\", \"s\", \"e\", \"e\"],\n[\"e\", \"s\", \"e\", \"s\"],\n[\"s\", \"e\", \"e\", \"s\"]\n]\n}\n```\n\n**Final Answer:**\nThe solution is represented by the \"answer\" array, where \"s\" denotes filled cells and \"e\" denotes empty cells."
+    },
+    {
+        "role": "assistant", 
+        "content": "Initial State\n[[s,0,0,0],[0,0,0,s],[0,s,0,s],[0,0,0,s],[s,0,s,0],[0,s,0,0],[0,0,0,s]]\nSolution\n[[s,s,0,s],[0,s,s,s],[0,s,0,s],[0,0,s,s],[s,s,0,0],[0,s,0,s],[s,0,0,s]]"
+
+    },
+    {
+        "role": "user",
+        "content": "Yes. "
+    },
+    {
+        "role": "user", 
+        "content": "```json\n{\n\"perception\": [\n[0, 0, 0, 0, 0],\n[0, 0, 0, 0, 0],\n[0, 0, 0, 0, 0],\n[0, 0, 0, 0, 0],\n[0, 0, 0, 0, 0]\n],\n\"think\": \"The grid is initially empty. We need to fill the aquariums to satisfy the given row and column constraints. The numbers on the sides indicate the total number of filled cells in each row and column. We can start by placing the first filled cell in each row and column as shown in the solution. Then, we can fill the remaining cells while ensuring that each aquarium's water cells are contiguous at the bottom of that region.\",\n\"answer\": [\n[0, 0, 0, 0, 0],\n[0, 1, 1, 0, 0],\n[0, 1, 1, 0, 0],\n[0, 1, 1, 0, 0],\n[0, 1, 1, 0, 0]\n]\n}"
+    },
+    {
+        "role": "assistant", 
+        "content": "Initial State\n[[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0]]\nSolution\nWrong"
+
+    },
+    {
+        "role": "user",
+        "content": "Yes. Because 1 is undefined, so put a Wrong there"
+    },
+    {
+        "role": "user", 
+        "content": "```json\n{\n\"perception\": [\n[0, 0, 0, 0],\n[0, 0, 0, 0],\n[0, 2, 2, 0],\n[0, 2, 2, 0]\n],\n\"answer\": [\n[0, 0, s, s],\n[0, 0, s, s],\n[0, s, s, 0],\n[0, s, s, 0]\n]\n}\n```"
+    },
+    {
+        "role": "assistant", 
+        "content": "Initial State\nWrong\nSolution\n[[0,0,s,s],[0,0,s,s],[0,s,s,0],[0,s,s,0]]"
+
+    },
+    {
+        "role": "user",
+        "content": "Yes. As 2 is not defined"
+    },
+    {
+        "role": "user", 
+        "content": "```json\n{\n\"answer\": [\n    [\"e\", \"e\", \"s\", \"s\"],\n    [\"e\", \"s\", \"s\", \"e\"],\n    [\"s\", \"s\", \"e\", \"e\"],\n    [\"s\", \"e\", \"e\", \"e\"]\n]\n}\n```\n\nThis solution satisfies the given constraints:\n\n1. Each aquarium's water cells are contiguous at the bottom of that region.\n2. The row counts match the number of filled cells in each row: [0, 2, 2, 2].\n3. The column counts match the number of filled cells in each column: [2, 2, 2, 2].\n\nThe aquariums are filled as follows:\n- Aquarium 1: [[2, 0], [1, 0], [0, 0]]\n- Aquarium 2: [[2, 1], [2, 2]]\n- Aquarium 3: [[1, 3], [0, 3], [0, 2], [1, 2], [1, 1], [0, 1]]\n- Aquarium 4: [[2, 3], [3, 3], [3, 2]]"
+    },
+    {
+        "role": "assistant", 
+        "content": "Initial State\nWrong\nSolution\n[[0,0,s,s],[0,s,s,0],[s,s,0,0],[s,0,0,0]]"
+    },
+    {
+        "role": "user",
+        "content": "Yes. there is no perception, but the answer is valid, so put it there."
+    },
+    {
+        "role": "user", 
+        "content": "```json\n{\n  \"think\": \"To solve this puzzle, I will first identify the filled cells and their positions in the given board state. Then, I will use these positions to fill the aquariums with water according to the given row and column counts. Finally, I will check if the solution is correct by ensuring that the water cells are contiguous at the bottom of each region.\",\n  \"answer\": [\n    [\"s\", \"s\", \"e\", \"e\"],\n    [\"s\", \"s\", \"e\", \"e\"],\n    [\"s\", \"s\", \"e\", \"e\"],\n    [\"e\", \"s\", \"e\", \"s\"]\n  ]\n}\n```"
+    },
+    {
+        "role": "assistant", 
+        "content": "Initial State\nWrong\nSolution\n[[s,s,0,0],[s,s,0,0],[s,s,0,0],[0,s,0,s]]"
+
+    },
+    {
+        "role": "user",
+        "content": "Yes. there is no perception, but the answer is valid, so put it there."
+    },
+    {
+        "role": "user", 
+        "content": "```json\n{\n\"answer\": [\n[1, 1, 1, 1],\n[1, 0, 0, 1],\n[1, 0, 0, 1],\n[1, 0, 0, 1]\n]\n}\n```"
+    },
+    {
+        "role": "assistant", 
+        "content": "Initial State\nWrong\nSolution\nWrong"
+    },
+    {
+        "role": "user",
+        "content": "Yes. there is no perception, so Wrong; for answer, 1 is not defined."
+    }
+]

VLMEvalKit-sudoku/vlmeval/dataset/utils/vgrpbench/configs/formating-prompt/battleships/filter_prompt.json

@@ -0,0 +1,91 @@
+[
+    {
+        "role": "system", 
+        "content": "You are a text formater, your goal is to extract two parts, perception and answer from the answer and put them into a good format. Please according to the conversation history with the user feedback. The desired format is a 2d array, where there is only three types values 0 or s; if you see * or _  or - or e or #, you should convert them into 0. But if there is any number in the grid, it is Wrong. If the perception / answer is not a valid solution or not existe, please put a Wrong there. Your goal is only to format the user's input, not to check if it is correct or not"
+    },
+    {
+        "role": "user",
+        "content": "```json\n{\n\"perception\": [\n    [\"*\", \"*\", \"*\", \"*\"],\n    [\"*\", \"s\", \"*\", \"*\"],\n    [\"*\", \"*\", \"*\", \"*\"],\n    [\"*\", \"*\", \"*\", \"*\"]\n],\n\"think\": \"Based on the given information, there is a ship of size 2 and two ships of size 1. The row hints indicate that the ship of size 2 must be placed in the second row, and the column hints suggest that one of the size 1 ships must be placed in the second column. The other size 1 ship can be placed in either the first, third, or fourth column without violating the rules.\",\n\"answer\": [\n    [\"e\", \"s\", \"e\", \"e\"],\n    [\"e\", \"s\", \"e\", \"e\"],\n    [\"e\", \"e\", \"s\", \"e\"],\n    [\"e\", \"e\", \"e\", \"s\"]\n]\n}\n```"
+    },
+    {  
+        "role": "assistant",
+        "content": "Initial State\n[[0,0,0,0],[0,s,0,0],[0,0,0,0],[0,0,0,0]]\nSolution\n[[0,s,0,0],[0,s,0,0],[0,0,s,0],[0,0,0,s]]"
+    },
+    {
+        "role": "user",
+        "content": "Yes. "
+    },
+    {
+        "role": "user",
+        "content": "model_output\": \"```json\n{\n  \"perception\": [\n    [\"*\", \"*\", \"*\", \"*\", \"*\"],\n    [\"*\", \"*\", \"*\", \"*\", \"*\"],\n    [\"*\", \"*\", \"s\", \"s\", \"*\"],\n    [\"*\", \"*\", \"*\", \"*\", \"*\"],\n    [\"*\", \"*\", \"*\", \"*\", \"*\"]\n  ],\n  \"answer\": [\n    [\"e\", \"e\", \"e\", \"e\", \"e\"],\n    [\"e\", \"e\", \"e\", \"e\", \"e\"],\n    [\"e\", \"e\", \"s\", \"s\", \"e\"],\n    [\"e\", \"e\", \"e\", \"e\", \"s\"],\n    [\"e\", \"s\", \"e\", \"e\", \"e\"]\n  ]\n}\n```"
+    },
+    {  
+        "role": "assistant",
+        "content": "Initial State\n[[0,0,0,0,0],[0,0,0,0,0],[0,0,s,s,0],[0,0,0,0,0],[0,0,0,0,0]]\nSolution\n[[0,0,0,0,0],[0,0,0,0,0],[0,0,s,s,0],[0,0,0,0,s],[0,s,0,0,0]]"
+
+    },
+    {
+        "role": "user",
+        "content": "Yes. "
+    },
+    {
+        "role": "user",
+        "content": "**Step 1: Analyze the given information**\n\n*   The grid is 6x6.\n*   There are three ships of sizes 2, 1, and 1.\n*   The hints indicate that there are two cells in the first row and one cell in the second row.\n*   There is one cell in the first column and one cell in the second column.\n\n**Step 2: Place the ships**\n\n*   We can start by placing the two-cell ship in the first row. We can place it in the first two columns or the last two columns.\n*   Let's place it in the first two columns. This leaves us with a 4x4 grid to place the remaining ships.\n*   We can place the one-cell ship in the second row and the first column.\n*   This leaves us with a 4x4 grid to place the remaining one-cell ship.\n*   We can place it in the second row and the second column.\n\n**Step 3: Check for any constraints**\n\n*   There are no constraints mentioned in the problem, so we can proceed with our current placement.\n\n**Step 4: Write the solution**\n\n```json\n{\"perception\": [[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]], \"think\": \"Place the two-cell ship in the first two columns, then place the one-cell ship in the second row and the first column, and finally place the remaining one-cell ship in the second row and the second column.\", \"answer\": [[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]}\n```\n\n**Answer:** {\"perception\": [[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]], \"think\": \"Place the two-cell ship in the first two columns, then place the one-cell ship in the second row and the first column, and finally place the remaining one-cell ship in the second row and the second column.\", \"answer\": [[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]}"
+    },
+    {  
+        "role": "assistant",
+        "content": "Initial State\n[[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0]]\nSolution\n[[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0]]"
+    },
+    {
+        "role": "user",
+        "content": "Yes. "
+    },
+    {
+        "role": "user",
+        "content": "```json\n{\n\"perception\": [\n[\"#\", \"s\", \"#\", \"#\"],\n[\"#\", \"s\", \"#\", \"#\"],\n[\"#\", \"#\", \"#\", \"#\"],\n[\"#\", \"#\", \"#\", \"#\"]\n],\n\"think\": \"The grid is 4x4, and there are two ships: one of size 1 and one of size 2. The size-1 ship is already placed in the bottom-left corner (x1=0, y1=3). The size-2 ship must be placed horizontally or vertically, not overlapping with the size-1 ship.\",\n\"answer\": [\n[\"#\", \"s\", \"#\", \"#\"],\n[\"#\", \"s\", \"#\", \"#\"],\n[\"#\", \"#\", \"#\", \"#\"],\n[\"#\", \"#\", \"#\", \"#\"]\n]\n}\n```"
+    },
+    {  
+        "role": "assistant",
+        "content": "Initial State\n[[0,s,0,0],[0,s,0,0],[0,0,0,0],[0,0,0,0]]\nSolution\n[[0,s,0,0],[0,s,0,0],[0,0,0,0],[0,0,0,0]]"
+    },
+    {
+        "role": "user",
+        "content": "Yes. "
+    },   
+    {
+        "role": "user",
+        "content": "```json\n{\n\"perception\": [\n[\"*\", \"*\", \"*\", \"e\"],\n[\"*\", \"*\", \"s\", \"*\"],\n[\"*\", \"*\", \"s\", \"*\"],\n[\"*\", \"e\", \"*\", \"*\"]\n],\n\"think\": \"Let's analyze this 4x4 grid:\n1. We need to place 1 size-2 ship and 2 size-1 ships\n2. The row hints (0,2,1,1) and column hints (2,0,2,0) tell us how many cells are ships\n3. We can see:\n   - A size-2 ship vertically placed in column 2, rows 1-2\n   - Two water cells marked with dots\n4. Looking at row 0 with hint 0, all cells must be water\n5. Column 1 has hint 0, so all cells must be water\n6. The remaining two size-1 ships must be placed in valid positions without touching the existing size-2 ship\n7. Given the constraints, one size-1 ship must be in row 3, column 0 and the other in row 3, column 2\",\n\"answer\": [\n[\"e\", \"e\", \"e\", \"e\"],\n[\"e\", \"e\", \"s\", \"e\"],\n[\"e\", \"e\", \"s\", \"e\"],\n[\"s\", \"e\", \"s\", \"e\"]\n]\n}\n```"
+    },
+    {  
+        "role": "assistant",
+        "content": "Initial State\n[[0,0,0,0],[0,0,s,0],[0,0,s,0],[0,0,0,0]]\nSolution\n[[0,0,0,0],[0,0,s,0],[0,0,s,0],[s,0,s,0]]"
+    },
+    {
+        "role": "user",
+        "content": "Yes. "
+    },   
+    {
+        "role": "user",
+        "content": "```json\n{\n  \"perception\": [\n    [\"*\", \"*\", \"*\"],\n    [\"*\", \"*\", \"*\"],\n    [\"*\", \"*\", \"*\"]\n  ],\n  \"think\": \"Analyze the given grid. We are given hints indicating how many ship cells are in each row and column. Small black circles represent single-cell ship cells, and two-cell ships must be placed as per the hints. From the row and column numbers, I will determine where the ship segments must go, ensuring no ships touch each other, even diagonally.\",\n  \"answer\": [\n    [],\n}\n```"
+    },
+    {  
+        "role": "assistant",
+        "content": "Initial State\n[[0,0,0],[0,0,0],[0,0,0]]\nSolution\nWrong"
+    },
+    {
+        "role": "user",
+        "content": "Yes. as there is no answer could be extracted from the model output"
+    }, 
+    {
+        "role": "user",
+        "content": "```json\n{\n  \"perception\": [\n    [\"*\", \"*\", \"*\", \"*\"],\n    [\"*\", \"*\", \"*\", \"*\"],\n    [\"*\", \"*\", \"*\", \"*\"],\n    [\"*\", \"*\", \"*\", \"s\"]\n  ],\n  \"answer\": [\n    [\"e\", \"s\", \"e\", \"e\"],\n    [\"e\", \"e\", \"s\", \"e\"],\n    [\"e\", \"e\", \"e\", \"e\"],\n    [\"s\", \"e\", \"e\", \"s\"]\n  ]\n}\n```"
+    },
+    {  
+        "role": "assistant",
+        "content": "Initial State\n[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,s]]\nSolution\n[[0,s,0,0],[0,0,s,0],[0,0,0,0],[s,0,0,s]]"
+    },
+    {
+        "role": "user",
+        "content": "Yes. "
+    } 
+]

VLMEvalKit-sudoku/vlmeval/dataset/utils/vgrpbench/configs/formating-prompt/binairo/filter_prompt.json

@@ -0,0 +1,67 @@
+[
+    {
+        "role": "system", 
+        "content": 
+        "You are a text formater, your goal is to extract two parts, perception and answer from the answer and put them into a good format. Please according to the conversation history with the user feedback. The desired format is a 2d array, where there is only three types values 0 or w or b; if you see * or _  or - or e or #, you should convert them into 0. If you see other numbers such as 1, 2, or 3, it is wrong.If the perception / answer is not a valid solution or not existe, please put a Wrong there. Your goal is only to format the user's input, not to check if it is correct or not"
+    },
+    {
+        "role": "user",
+        "content": "```json\n{\n\"perception\": [\n[\"*\", \"*\", \"w\", \"w\"],\n[\"b\", \"b\", \"*\", \"w\"],\n[\"w\", \"w\", \"*\", \"b\"],\n[\"w\", \"*\", \"*\", \"*\"]\n],\n\"think\": [\n\"1. Looking at row 1 (0-based), there are two black circles (b,b), so the remaining two must be white to avoid three consecutive blacks\",\n\"2. Looking at column 3 (0-based), there are already three whites (w,w,w), so the last cell must be black\",\n\"3. In row 2, we have (w,w,*,b) - to avoid three whites in a row, the empty cell must be black\",\n\"4. In row 3, we have (w,*,*,*) - given the column constraints and avoiding three consecutive same colors, it must be (w,b,w,b)\",\n\"5. This completes the grid while satisfying all constraints\"\n],\n\"answer\": [\n[\"b\", \"b\", \"w\", \"w\"],\n[\"b\", \"b\", \"w\", \"w\"],\n[\"w\", \"w\", \"b\", \"b\"],\n[\"w\", \"b\", \"w\", \"b\"]\n]\n}\n```"
+    },
+    {
+        "role": "assistant",
+        "content": "Perception\n[[0,0,w,w],[b,b,0,w],[w,w,0,b],[w,0,0,0]]\nAnswer\n[[b,b,w,w],[b,b,w,w],[w,w,b,b],[w,b,w,b]]"
+    },
+    {
+        "role": "user",
+        "content": "Yes. "
+    },
+    {
+        "role": "user",
+        "content": "```json\n{\n  \"perception\": [\n    [\"b\", \"b\", \"*\", \"*\"],\n    [\"*\", \"b\", \"*\", \"w\"],\n    [\"*\", \"*\", \"b\", \"b\"],\n    [\"w\", \"*\", \"w\", \"b\"]\n  ],\n  \"think\": \"To solve this, we apply the Binairo rules. Here\u2019s the step-by-step reasoning: \n1. Row 0: The first two cells are 'b'. According to the rules, no more than two same-colored pieces can be adjacent. Thus, the third cell must be 'w'.\n2. Row 3: The fourth cell is 'b', and the second cell is blank. Following the row's structure and aiming for balanced numbers of 'b' and 'w', the second cell must be 'b.\"\n3. Each horizontal"
+    },
+    {
+        "role": "assistant",
+        "content": "Perception\n[[b,b,0,0],[0,b,0,w],[0,0,b,b],[w,0,w,b]]\nAnswer\nWrong"
+    },
+    {
+        "role": "user",
+        "content": "Yes. as there is no answer section, so you should put a Wrong there."
+    },
+    {
+        "role": "user",
+        "content": "```json\n{\n  \"perception\": [\n    [\"*\", \"*\", \"*\", \"w\"],\n    [\"b\", \"b\", \"*\", \"*\"],\n    [\"w\", \"*\", \"w\", \"b\"],\n    [\"w\", \"*\", \"*\", \"*\"]\n  ],\n  \"answer\": [\n    [\"b\", \"w\", \"b\", \"w\"],\n    [\"b\", \"b\", \"w\", \"b\"],\n    [\"w\", \"b\", \"w\", \"b\"],\n    [\"w\", \"b\", \"w\", \"b\"]\n  ]\n}\n```"
+    },
+    {
+        "role": "assistant",
+        "content": "Perception\n[[0,0,0,w],[b,b,0,0],[w,0,w,b],[w,0,0,0]]\nAnswer\n[[b,w,b,w],[b,b,w,b],[w,b,w,b],[w,b,w,b]]"
+    },
+    {
+        "role": "user",
+        "content": "Yes. "
+    },
+    {
+        "role": "user",
+        "content": "```json\n{\n  \"perception\": [\n    [\"*\", \"*\", \"*\", \"w\"],\n    [\"b\", \"b\", \"*\", \"*\"],\n    [\"w\", \"*\", \"w\", \"b\"],\n    [\"w\", \"*\", \"*\", \"*\"]\n  ],\n  \"answer\": [\n    [\"b\", \"w\", \"b\", \"w\"],\n    [\"b\", \"b\", \"w\", \"b\"],\n    [\"w\", \"b\", \"w\", \"b\"],\n    [\"w\", \"b\", \"w\", \"b\"]\n  ]\n}\n```"
+    },
+    {
+        "role": "assistant",
+        "content": "Perception\n[[0,0,0,w],[b,b,0,0],[w,0,w,b],[w,0,0,0]]\nAnswer\n[[b,w,b,w],[b,b,w,b],[w,b,w,b],[w,b,w,b]]"
+    },
+    {
+        "role": "user",
+        "content": "Yes. "
+    },
+    {
+        "role": "user", 
+        "content": "The user wants me to solve a Binairo puzzle.\nI need to identify the black and white circles in the image and represent them as 'b' and 'w' respectively. Empty cells will be represented by '*'.\nThen, I need to apply the Binairo rules to fill the empty cells.\nThe rules are:\n1. No more than two adjacent cells can have the same color.\n2. Each row and column must have an equal number of black and white cells.\n\nLet's represent the initial state of the grid.\nRow 0: *, *, *, b\nRow 1: w, *, *, *\nRow 2: *, b, w, *\nRow 3: b, *, *, w\n\nNow, let's apply the rules to fill the empty cells.\n\n**Step 1:** Analyze row 0. It has one 'b'. It needs one more 'b' and two 'w'.\n**Step 2:** Analyze row 1. It has one 'w'. It needs one more 'w' and two 'b'.\n**Step 3:** Analyze row 2. It has one 'b' and one 'w'. It needs one more 'b' and one more 'w'.\n**Step 4:** Analyze row 3. It has one 'b' and one 'w'. It needs one more 'b' and one more 'w'.\n\n**Step 5:** Analyze column 0. It has one 'w' and one 'b'. It needs one more 'w' and one more 'b'.\n**Step 6:** Analyze column 1. It has one 'b'. It needs one more 'b' and two 'w'.\n**Step 7:** Analyze column 2. It has one 'w'. It needs one more 'w' and two 'b'.\n**Step 8:** Analyze column 3. It has one 'b' and one 'w'. It needs one more 'b' and one more 'w'.\n\nLet's start filling based on the no-three-in-a-row rule.\nIn row 0, the last cell is 'b'. So the cell at (0,2) cannot be 'b'.\nIn row 3, the first cell is 'b'. So the cell at (3,1) cannot be 'b'.\n\nConsider row 0: *, *, *, b. If the second to last cell is 'b', we have *, *, b, b. Then the first two must be 'w'. So w, w, b, b. This is valid.\nConsider row 3: b, *, *, w. If the second cell is 'w', we have b, w, *, w. The third cell must be 'b'. So b, w, b, w. This is valid.\n\nLet's update the grid:\nw, w, b, b\nw, *, *, *\n*, b, w, *\nb, w, b, w\n\nConsider row 1: w, *, *, *. It needs one more 'w' and two 'b'.\nConsider row 2: *, b, w, *. It needs one more 'b' and one more 'w'.\n\nConsider column 1: w, *, b, w. The empty cell must be 'b'.\nConsider column 2: b, *, w, b. The empty cell must be 'w'.\n\nLet's update the grid:\nw, w, b, b\nw, b, w, *\n*, b, w, *\nb, w, b, w\n\nConsider row 1: w, b, w, *. The last cell must be 'b'.\nConsider row 2: *, b, w, *. The last cell must be 'b'.\n\nLet's update the grid:\nw, w, b, b\nw, b, w, b\n*, b, w, b\nb, w, b, w\n\nConsider row 2: *, b, w, b. The first cell must be 'w'.\n\nLet's update the grid:\nw, w, b, b\nw, b, w, b\nw, b, w, b\nb, w, b, w\n\nNow let's check the column counts.\nColumn 0: w, w, w, b (3w, 1b) - Incorrect.\nThere must be an error in the previous steps.\n\nLet's go back to the state:\nw, w, b, b\nw, *, *, *\n*, b, w, *\nb, w, b, w\n\nConsider row 1: w, *, *, *. It needs one more 'w' and two 'b'.\nIf the second cell is 'b', we have w, b, *, *.\nIf the third cell is 'b', we have w, b, b, *. The last cell must be 'w'. So w, b, b, w.\nConsider row 2: *, b, w, *. It needs one more 'b' and one more 'w'.\n\nLet's update the grid:\nw, w, b, b\nw, b, b, w\n*, b, w, *\nb, w, b, w\n\nConsider column 0: w, w, *, b. The empty cell must be 'b'.\nConsider column 3: b, w, *, w. The empty cell must be 'b'.\n\nLet's update the grid:\nw, w, b, b\nw, b, b, w\nb, b, w, b\nb, w, b, w\n\nConsider row 2: b, b, w, b. This violates the no-three-in-a-row rule.\n\nLet's go back to the state:\nw, w, b, b\nw, *, *, *\n*, b, w, *\nb, w, b, w\n\nConsider row 1: w, *, *, *. It needs one more 'w' and two 'b'.\nIf the second cell is 'w', we have w, w, *, *. The last two must be 'b'. So w, w, b, b. This is the same as row 0, which is not allowed.\n\nLet's try filling based on column constraints.\nColumn 0: w, *, *, b. It needs one 'w' and one 'b'.\nColumn 1: w, b, b, w. This is valid.\nColumn 2: b, w, w, b. This is valid.\nColumn 3: b, *, *, w. It needs one 'w' and one 'b'.\n\nLet's go back to the initial state:\n*, *, *, b\nw, *, *, *\n*, b, w, *\nb, *, *, w\n\nFrom row 0: *, *, *, b. The cells at (0,0) and (0,1) cannot be 'b'.\nFrom row 3: b, *, *, w. The cell at (3,1) cannot be 'b'.\n\nFrom column 1: *, *, b, *. The cells at (0,1) and (3,1) cannot be 'b'.\nFrom column 2: *, *, w, *. The cells at (0,2) and (3,2) cannot be 'w'.\n\nConsider row 0: *, *, *, b. If the first two are 'w', we have w, w, *, b. The third must be 'b'. So w, w, b, b.\nConsider row 3: b, *, *, w. If the middle two are 'w', we have b, w, w, w. This is invalid.\n\nLet's restart the thought process with the initial grid.\n```json\n{\n\"perception\": [\n[\"*\", \"*\", \"*\", \"b\"],\n[\"w\", \"*\", \"*\", \"*\"],\n[\"*\", \"b\", \"w\", \"*\"],\n[\"b\", \"*\", \"*\", \"w\"]\n],\n\"think\": \"The grid is 4x4. Each row and column must have two 'w' and two 'b'.\\n\\n**Step 1:** Analyze row 0: [*, *, *, b]. To avoid three consecutive 'b', the cells at (0,0) and (0,1) cannot both be 'b'.\\n\\n**Step 2:** Analyze row 3: [b, *, *, w]. To avoid three consecutive 'b', the cell at (3,1) cannot be 'b'.\\n\\n**Step 3:** Analyze column 1: [*, *, b, *]. To avoid three consecutive 'b', the cell at (0,1) cannot be 'b'.\\n\\n**Step 4:** Consider row 0: [*, *, *, b]. If we place 'w' in (0,0) and (0,1), we get [w, w, *, b]. The remaining cell must be 'b' to have two 'b's in the row: [w, w, b, b]. This is valid.\\n\\n**Step 5:** Consider row 3: [b, *, *, w]. If we place 'w' in (3,1), we get [b, w, *, w]. The remaining cell must be 'b': [b, w, b, w]. This is valid.\\n\\n**Step 6:** Update the grid:\\n[w, w, b, b]\\n[w, *, *, *]\\n[*, b, w, *]\\n[b, w, b, w]\\n\\n**Step 7:** Consider column 1: [w, *, b, w]. The missing cell must be 'b': [w, b, b, w].\\n\\n**Step 8:** Consider column 2: [b, *, w, b]. The missing cell must be 'w': [b, w, w, b].\\n\\n**Step 9:** Update the grid:\\n[w, w, b, b]\\n[w, b, w, *]\\n[*, b, w, b]\\n[b, w, b, w]\\n\\n**Step 10:** Consider row 1: [w, b, w, *]. The missing cell must be 'b': [w, b, w, b].\\n\\n**Step 11:** Consider row 2: [*, b, w, b]. The missing cell must be 'w': [w, b, w, b].\\n\\n**Step 12:** Update the grid:\\n[w, w, b, b]\\n[w, b, w, b]\\n[w, b, w, b]\\n[b, w, b, w]\\n\\n**Step 13:** Check column counts:\\nColumn 0: w, w, w, b (Incorrect)\\n\\nLet's backtrack to Step 6 and try a different approach.\\n\\n**Step 6 (Retry):** Consider row 1: [w, *, *, *]. To have two 'w's, let's place 'w' at (1,2). Then we have [w, *, w, *]. The remaining cells must be 'b': [w, b, w, b].\\n\\n**Step 7:** Consider row 2: [*, b, w, *]. To have two 'b's, let's place 'b' at (2,0). Then we have [b, b, w, *]. The remaining cell must be 'w': [b, b, w, w].\\n\\n**Step 8:** Update the grid:\\n[w, w, b, b]\\n[w, b, w, b]\\n[b, b, w, w]\\n[b, w, b, w]\\n\\n**Step 9:** Check column counts:\\nColumn 0: w, w, b, b\\nColumn 1: w, b, b, w\\nColumn 2: b, w, w, b\\nColumn 3: b, b, w, w\\nAll columns have two 'w' and two 'b'.\\n\\n**Step 10:** Check row counts:\\nRow 0: w, w, b, b\\nRow 1: w, b, w, b\\nRow 2: b, b, w, w\\nRow 3: b, w, b, w\\nAll rows have two 'w' and two 'b'.\\n\\n**Step 11:** Check for three consecutive same colors.\\nNo three consecutive same colors in any row or column.\",\n\"answer\": [\n[\"w\", \"w\", \"b\", \"b\"],\n[\"w\", \"b\", \"w\", \"b\"],\n[\"b\", \"b\", \"w\", \"w\"],\n[\"b\", \"w\", \"b\", \"w\"]\n]\n}\n```"
+    },
+    {
+        "role": "assistant",
+        "content": "Perception\n[[0,0,0,b],[w,0,0,0],[0,b,w,0],[b,0,0,w]]\nAnswer\n[[w,w,b,b],[w,b,w,b],[b,b,w,w],[b,w,b,w]]"
+    },
+    {
+        "role": "user",
+        "content": "Yes. "
+    }
+]

VLMEvalKit-sudoku/vlmeval/dataset/utils/vgrpbench/configs/formating-prompt/fieldexplore/filter_prompt.json

@@ -0,0 +1,102 @@
+[
+    {
+        "role": "system", 
+        "content": "You are a text formater, your goal is to extract two parts, perception and answer from the answer and put them into a good format. Please according to the conversation history with the user feedback. The desired format is a 2d array, where there is only 0 or s or numbers; *, or 0, or _, or -, or e might indicates empty that you should convert to 0. If the perception / answer is not a valid solution or not existe, please put a Wrong there. Your goal is only to format the user's input, not to check if it is correct or not"},
+    {
+        "role": "user",
+        "content": "```json\n{\n\"perception\": [\n  [\"*\", \"*\", \"*\", \"*\"],\n  [\"1\", \"*\", \"*\", \"2\"],\n  [\"2\", \"*\", \"*\", \"*\"],\n  [\"*\", \"s\", \"3\", \"*\"]\n],\n\"think\": \"Based on the given information, we can make the following deductions:\n1. The cell with the value '1' has one mine adjacent to it, which must be the revealed mine cell.\n2. The cell with the value '2' in the second row has two mines adjacent to it. One of them is the revealed mine, so there must be another mine in one of the remaining hidden cells adjacent to it.\n3. The cell with the value '3' has three mines adjacent to it. One of them is the revealed mine, so there must be two more mines in the remaining hidden cells adjacent to it.\n4. The cell with the value '2' in the third row has two mines adjacent to it. One of them is the revealed mine, so there must be another mine in one of the remaining hidden cells adjacent to it.\n5. Based on the constraints of the '2' values, the only possible location for the second mine adjacent to the '2' in the third row is the cell to its left.\n6. With the second mine location determined, the remaining two mines adjacent to the '3' cell must be in the two cells above it.\",\n\"answer\": [\n  [\"e\", \"e\", \"s\", \"e\"],\n  [\"1\", \"e\", \"e\", \"2\"],\n  [\"2\", \"s\", \"e\", \"e\"],\n  [\"e\", \"s\", \"3\", \"s\"]\n]\n}\n```"
+    },
+    {
+        "role": "assistant",
+        "content": "Initial State\n[[0,0,0,0],[1,0,0,2],[2,0,0,0],[0,s,3,0]]\nSolution\n[[0,0,s,0],[1,0,0,2],[2,s,0,0],[0,s,3,s]]"
+    },
+    {
+        "role": "user",
+        "content": "Right"
+    },
+    {
+        "role": "user",
+        "content": "```json\n{\n  \"perception\": [\n    [1, 2, \"*\", \"*\", \"*\"],\n    [1, \"*\", \"*\", 3, 2],\n    [2, 3, \"*\", \"*\", \"*\"],\n    [1, \"*\", \"*\", 3, \"*\"]\n  ],\n  \"think\": \"Let's analyze the grid step by step.\\n\\n1. Look at the '3' at (1, 3). It has at most one hidden mine. If there is a mine at (1, 2), then the '3' at (1, 3) will be satisfied. \\n2. Look at the '2' at (0, 1). It has at most one hidden mine. If there is a mine at (1, 1), then the '2' at (0, 1) will be satisfied. \\n3. Look at the '1' at (0, 0). It has at most one hidden mine. If there is a mine at (1, 0), then the '1' at (0, 0) will be satisfied. \\n4. Look at the '2' at (2, 0). It has at most one hidden mine. If there is a mine at (2, 1), then the '2' at (2, 0) will be satisfied. \\n5. Look at the '3' at (3, 3). It has at most one hidden mine. If there is a mine at (3, 2), then the '3' at (3, 3) will be satisfied. \\n6. Look at the '1' at (3, 0). It has at most one hidden mine. If there is a mine at (3, 1), then the '1' at (3, 0) will be satisfied. \\n7. Considering the above analysis, we can place mines at (1, 1), (1, 2), (2, 1), (3, 1), (3, 2).\",\n  \"answer\": [\n    [1, 2, \"e\", \"e\", \"e\"],\n    [1, \"s\", \"s\", 3, 2],\n    [2, 3, \"s\", \"e\", \"e\"],\n    [1, \"s\", \"s\", 3, \"e\"]\n  ]\n}\n```"
+    },
+    {
+        "role": "assistant",
+        "content": "Initial State\n[[1,2,0,0,0],[1,0,0,3,2],[2,3,0,0,0],[1,0,0,3,0]]\nSolution\n[[1,2,0,0,0],[1,s,s,3,2],[2,3,s,0,0],[1,s,s,3,0]]"
+    },
+    {
+        "role": "user",
+        "content": "Right"
+    },
+    {
+        "role": "user",
+        "content": "To solve this problem, we need to analyze the given grid and use the information provided by the numbers to deduce the locations of the mines. \n\nThe grid is a 4x4 grid with some cells already revealed with numbers indicating how many mines are adjacent to them (including diagonals). The goal is to identify the locations of the mines based on this information.\n\nLet's start by examining the revealed cells:\n\n* Cell (0,0) has a value of 1, indicating that there is one mine adjacent to it.\n* Cell (0,1) has a value of 2, indicating that there are two mines adjacent to it.\n* Cell (1,0) has a value of 1, indicating that there is one mine adjacent to it.\n* Cell (1,1) has a value of 3, indicating that there are three mines adjacent to it.\n* Cell (2,2) has a value of 2, indicating that there are two mines adjacent to it.\n* Cell (2,3) has a value of 3, indicating that there are three mines adjacent to it.\n* Cell (3,2) has a value of 2, indicating that there are two mines adjacent to it.\n* Cell (3,3) has a value of 3, indicating that there are three mines adjacent to it.\n\nBased on this information, we can start making deductions about the locations of the mines.\n\n* Since cell (0,0) has a value of 1, it means that there is exactly one mine adjacent to it. The only possible location for this mine is cell (0,1), because if the mine were in any other adjacent cell, it would not be adjacent to cell (0,0).\n* Similarly, since cell (0,1) has a value of 2, it means that there are exactly two mines adjacent to it. One of these mines is already accounted for by cell (0,0), so the other mine must be in cell (1,1).\n* Continuing this process, we can deduce the locations of the remaining mines.\n\nHere is the solution:\n\n```json\n{\"perception\": [[1, 2, 's', '*'], [1, 3, 's', 2], [2, 3, 's', 2], ['*', 3, 3, 's']], \"think\": \"Use the given numbers to deduce the locations of the mines.\", \"answer\": [['e', 'e', 's', 'e'], ['e', 'e', 's', 'e'], ['e', 'e', 's', 'e'], ['e', 'e', 'e', 's']]}\n```\n\nIn the solution, 'e' indicates an empty cell (no mine), and 's' indicates a cell with a mine."
+
+    },
+    {
+        "role": "assistant",
+        "content": "Initial State\n[[1,2,s,0],[1,3,s,2],[2,3,s,2],[0,3,3,s]]\nSolution\n[[0,0,s,0],[0,0,s,0],[0,0,s,0],[0,0,0,s]]"
+    },
+    {
+        "role": "user",
+        "content": "Right"
+    },
+    {
+        "role": "user",
+        "content": "```json\n{\n  \"perception\": [\n    [0, 0, 0, 0],\n    [0, 0, 0, 0],\n    [0, 0, 0, 0],\n    [0, 0, 0, 0]\n  ],\n  \"think\": [\n    \"There are no numbers or mines visible in this grid. Since it's a standard game layout, I'll need to start with general reasoning to identify potential mine locations based on the given number clues.\",\n    \"Starting with the top left and moving across rows, the number 1 indicates that there is a single mine in one of the four adjacent cells. Similarly, the number 2 suggests a single mine in two of the adjacent cells. The number 3 indicates a single mine in three of the adjacent cells. However, without more information, we cannot pinpoint the exact locations of the mines.\",\n    \"To narrow down the possibilities, I'll need to identify the patterns created by the revealed numbers. For example, if two cells have a number 3, we can infer that the mine must be in one of those cells. Similarly, if two cells have a number 1, we can infer that the mine must be in one of those cells. By analyzing the revealed numbers and their patterns, we can make educated guesses about the mine locations.\"\n  ],\n  \"answer\": [\n    [0, 0, 0, 0],\n    [0, 0, 0, 0],\n    [0, 0, 0, 0],\n    [0, 0, 0, 0]\n  ]\n}\n```"
+    },
+    {
+        "role": "assistant",
+        "content": "Initial State\n[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]\nSolution\n[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]"
+    },
+    {
+        "role": "user",
+        "content": "Right"
+    },
+    {
+        "role": "user",
+        "content": "```json\n{\n\"perception\": [\n  [\"1\", \"2\", \"*\", \"1\", \"*\"],\n  [\"*\", \"*\", \"3\", \"*\", \"2\"],\n  [\"2\", \"3\", \"3\", \"*\", \"*\"],\n  [\"*\", \"*\", \"3\", \"*\", \"*\"]\n],\n\"think\": \"We start by analyzing the revealed numbers. The grid indicates the number of adjacent mines for the cells. We will deduce where the mines must be based on the numbers given:\\n- The cell (0, 0) is 1 and only touches (0, 1), so (0, 1) has a mine, thus confirming 1 mine at (0, 1).\\n- The cell (0, 3) is also 1, and it can only have a mine in (1, 2) since (0, 2) is adjacent to another number.\\n- For cell (1, 2) which is 3, it should have 3 adjacent mines. Currently (0, 1) is already one of them.\\n- The cell (3, 2) is 3; for it to be true, it requires careful placement in surrounding cells (2, 1), (2, 2), and (2, 3) based on existing clues.\\nBy logically deducing, it turns out that the placement of mines leads to the conclusion below:\\n- Cells (0, 1), (1, 2), (2, 1), (2, 2), (2, 3), and (3, 2) are filled with mines. The remaining cells turn out not to have any mines.\",\n\"answer\": [\n  [\"e\", \"s\", \"e\", \"e\", \"e\"],\n  [\"e\", \"e\", \"s\", \"e\", \"s\"],\n  [\"s\", \"s\", \"s\", \"e\", \"e\"],\n  [\"e\", \"e\", \"s\", \"e\", \"e\"]\n]\n}\n```"
+    },
+    {
+        "role": "assistant",
+        "content": "Initial State\n[[1,2,0,1,0],[0,0,3,0,2],[2,3,3,0,0],[0,0,3,0,0]]\nSolution\n[[0,s,0,0,0],[0,0,s,0,s],[s,s,s,0,0],[0,0,s,0,0]]"
+    },
+    {
+        "role": "user",
+        "content": "Right"
+    },
+    {
+        "role": "user",
+        "content": "```json\n{\n\"perception\": [\n[\"*\", \"2\", \"*\", \"*\"],\n[\"*\", \"s\", \"3\", \"*\"],\n[\"*\", \"*\", \"*\", \"*\"],\n[\"1\", \"s\", \"3\", \"*\"]\n],\n\"think\": \"1. The '2' at [0, 1] has one revealed mine adjacent to it at [1, 1]. Thus, there must be one more mine adjacent to it. Since the other adjacent cells are [0, 0], [0, 2], [1, 0], and [1, 2], and [1, 2] is adjacent to '3' at [1, 2] which already has a mine at [1, 1], the mine must be at [0, 0], [0, 2], or [1, 0].\\n2. The '3' at [1, 2] has one revealed mine adjacent to it at [1, 1]. Thus, there must be two more mines adjacent to it. The adjacent cells are [0, 1], [0, 2], [0, 3], [1, 1], [1, 3], [2, 1], [2, 2], [2, 3]. Since [0, 1] has a '2' and already has a mine adjacent to it, it cannot be a mine. Thus, the two mines must be among [0, 2], [0, 3], [1, 3], [2, 1], [2, 2], [2, 3].\\n3. The '1' at [3, 0] has one revealed mine adjacent to it at [3, 1]. Thus, all other adjacent cells must be empty. \\n4. The '3' at [3, 2] has one revealed mine adjacent to it at [3, 1]. Thus, there must be two more mines adjacent to it. The adjacent cells are [2, 1], [2, 2], [2, 3], [3, 1], [3, 3]. Since [3, 1] is already a mine, the two mines must be among [2, 1], [2, 2], [2, 3], [3, 3].\",\n\"answer\": [\n[\"s\", \"2\", \"s\", \"e\"],\n[\"e\", \"s\", \"3\", \"s\"],\n[\"e\", \"e\", \"s\", \"e\"],\n[\"1\", \"s\", \"3\", \"s\"]\n]\n}\n```"
+    },
+    {
+        "role": "assistant",
+        "content": "Initial State\n[[0,2,0,0],[0,s,3,0],[0,0,0,0],[1,s,3,0]]\nSolution\n[[s,2,s,0],[0,s,3,s],[0,0,s,0],[1,s,3,s]]"
+    },
+    {
+        "role": "user",
+        "content": "Right"
+    },
+    {
+        "role": "user",
+        "content": "```json\n{\n\"perception\": [\n  [\"*\", \"*\", \"*\", \"*\"],\n  [\"1\", \"*\", \"*\", \"2\"],\n  [\"2\", \"*\", \"*\", \"*\"],\n  [\"*\", \"s\", \"3\", \"*\"]\n],\n\"answer\": [\n  [\"e\", \"e\", \"s\", \"e\"],\n  [\"1\", \"s\", \"s\", \"2\"],\n  [\"2\", \"s\", \"s\", \"e\"],\n  [\"e\", \"s\", \"3\", \"s\"]\n]\n}\n```"
+    },
+    {
+        "role": "assistant",
+        "content": "Initial State\n[[0,0,0,0],[1,0,0,2],[2,0,0,0],[0,s,3,0]]\nSolution\n[[0,0,s,0],[1,0,0,2],[2,s,s,0],[0,s,3,s]]"
+    },
+    {
+        "role": "user",
+        "content": "Right"
+    },
+    {
+        "role": "user",
+        "content": "```json\n{\n\"perception\": [\n  [\"1\", \"*\", \"*\", \"1\"],\n  [\"1\", \"s\", \"3\", \"*\"],\n  [\"2\", \"*\", \"*\", \"*\"],\n  [\"1\", \"s\", \"3\", \"*\"]\n],\n\"answer\": [\n  [\"e\", \"s\", \"s\", \"e\"],\n  [\"e\", \"s\", \"s\", \"s\"],\n  [\"e\", \"s\", \"e\", \"e\"],\n  [\"e\", \"s\", \"s\", \"s\"]\n]\n}\n```"
+    },
+    {
+        "role": "assistant",
+        "content": "Initial State\n[[1,0,0,1],[1,s,3,0],[2,0,0,0],[1,s,3,0]]\nSolution\n[[0,s,s,0],[0,s,s,s],[0,s,0,0],[0,s,s,s]]"
+    },
+    {
+        "role": "user",
+        "content": "Right"
+    }
+]