crfm-helm 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

helm/benchmark/scenarios/vision_language/mme_scenario.py

@@ -0,0 +1,145 @@
+import os.path
+from typing import List
+
+from datasets import load_dataset
+from tqdm import tqdm
+
+from helm.benchmark.scenarios.scenario import (
+    CORRECT_TAG,
+    TEST_SPLIT,
+    Instance,
+    Input,
+    Output,
+    Reference,
+    Scenario,
+)
+from helm.common.media_object import MediaObject, MultimediaObject
+from helm.common.general import ensure_directory_exists
+
+
+class MMEScenario(Scenario):
+    """
+        MME: A Comprehensive Evaluation Benchmark for Multimodal Large Language Models
+
+        Multimodal Large Language Model (MLLM) relies on the powerful LLM to perform
+        multimodal tasks, showing amazing emergent abilities in recent studies. However,
+        it is difficult for these case studies to fully reflect the performance of MLLM,
+        lacking a comprehensive evaluation. In MME, we fill in this blank, presenting
+        the first comprehensive MLLM Evaluation benchmark MME. It measures both perception
+        and cognition abilities on a total of 14 subtasks. In order to avoid data leakage
+        that may arise from direct use of public datasets for evaluation, the annotations
+        of instruction-answer pairs are all manually designed. The concise instruction design
+        allows us to fairly compare MLLMs, instead of struggling in prompt engineering.
+        Besides, with such an instruction, we can also easily carry out quantitative
+        statistics. We rephrase the answer type of MME to multiple-choice question-answering.
+        We use the multiple-choice metrics for 14 different evaluation tasks.
+
+        @article{fu2023mme,
+        title={MME: A Comprehensive Evaluation Benchmark for Multimodal Large Language Models},
+        author={Fu, Chaoyou and Chen, Peixian and Shen, Yunhang and Qin, Yulei and
+        Zhang, Mengdan and Lin, Xu and Yang, Jinrui and Zheng, Xiawu and Li, Ke and
+        Sun, Xing and Wu, Yunsheng and Ji, Rongrong},
+        journal={arXiv preprint arXiv:2306.13394},
+        year={2023}
+    }
+
+        Paper: https://arxiv.org/abs/2306.13394
+    """
+
+    MME_HUGGINGFACE_DATASET_NAME: str = "lmms-lab/MME"
+
+    SUBJECTS: List[str] = [
+        "existence",
+        "scene",
+        "posters",
+        "color",
+        "OCR",
+        "position",
+        "celebrity",
+        "artwork",
+        "commonsense_reasoning",
+        "numerical_calculation",
+        "landmark",
+        "count",
+        "text_translation",
+        "code_reasoning",
+    ]
+
+    name = "mme"
+    description = "Evaluate multimodal models on  ([paper](https://arxiv.org/abs/2306.13394))."
+    tags = ["vision-language"]
+    options: List[str] = ["Yes", "No"]
+
+    def __init__(self, subject: str):
+        super().__init__()
+        assert subject in self.SUBJECTS, f"Invalid subject: {subject}"
+        self._subject: str = subject
+
+    def get_label_from_answer(self, answer: str):
+        label: str
+        if answer == "Yes":
+            label = "A"
+        elif answer == "No":
+            label = "B"
+        else:
+            raise NotImplementedError(f"Invalid answer: {answer}")
+        return label
+
+    def remove_question_suffix_for_mcqa(self, question: str):
+        return question.replace("Please answer yes or no.", "").strip()
+
+    def get_question_id(self, question_id: str):
+        return question_id.split(".")[0].replace("/", "-")
+
+    def get_instances(self, output_path: str) -> List[Instance]:
+        images_path: str = os.path.join(output_path, "images")
+        ensure_directory_exists(images_path)
+
+        # There is only the test split in Unicorn benchmark
+        instances: List[Instance] = []
+        # Process the test set
+        # Two open-ended generation instances and
+        # one multi-choice generation instance per row
+        for row in tqdm(
+            load_dataset(
+                self.MME_HUGGINGFACE_DATASET_NAME,
+                split=TEST_SPLIT,
+                cache_dir=output_path,
+            )
+        ):
+            if row["category"] != self._subject:
+                continue
+            question_id: str = self.get_question_id(row["question_id"])
+            # Save the image locally
+            image_path: str = os.path.join(images_path, f"{question_id}.png")
+            if not os.path.exists(image_path):
+                row["image"].save(image_path)
+
+            question: str = self.remove_question_suffix_for_mcqa(row["question"])
+            answer: str = row["answer"]
+            references: List[Reference] = []
+
+            answer = self.get_label_from_answer(answer)
+            # The given correct answer is a letter, but we need an index
+            correct_answer_index: int = ord(answer) - ord("A")
+            # The options are originally appended to the question
+
+            for i, option in enumerate(self.options):
+                reference: Reference
+                is_correct: bool = i == correct_answer_index
+                reference = Reference(Output(text=option), tags=[CORRECT_TAG] if is_correct else [])
+                references.append(reference)
+
+            content = [
+                MediaObject(location=image_path, content_type="image/png"),
+                MediaObject(text=question, content_type="text/plain"),
+            ]
+            instances.append(
+                Instance(
+                    Input(multimedia_content=MultimediaObject(content)),
+                    references=references,
+                    split=TEST_SPLIT,
+                )
+            )
+
+        return instances

helm/benchmark/scenarios/vision_language/mmmu_scenario.py

@@ -0,0 +1,187 @@
+import os.path
+from typing import Dict, List
+
+from datasets import load_dataset
+from tqdm import tqdm
+
+from helm.benchmark.scenarios.scenario import (
+    CORRECT_TAG,
+    VALID_SPLIT,
+    Instance,
+    Input,
+    Output,
+    Reference,
+    Scenario,
+)
+from helm.common.media_object import MediaObject, MultimediaObject
+from helm.common.general import ensure_directory_exists
+
+
+class MMMUScenario(Scenario):
+    """
+    MMMU: A Massive Multi-discipline Multimodal Understanding and Reasoning Benchmark for Expert AGI
+
+    We introduce MMMU: a new benchmark designed to evaluate multimodal models on massive multi-discipline
+    tasks demanding college-level subject knowledge and deliberate reasoning. MMMU includes 11.5K meticulously
+    collected multimodal questions from college exams, quizzes, and textbooks, covering six core disciplines:
+    Art & Design, Business, Science, Health & Medicine, Humanities & Social Science, and Tech & Engineering.
+    These questions span 30 subjects and 183 subfields, comprising 30 highly heterogeneous image types, such
+    as charts, diagrams, maps, tables, music sheets, and chemical structures.
+
+      @article{yue2023mmmu,
+        title={MMMU: A Massive Multi-discipline Multimodal Understanding and Reasoning Benchmark for Expert AGI},
+        author={Xiang Yue and Yuansheng Ni and Kai Zhang and Tianyu Zheng and Ruoqi Liu and Ge Zhang and Samuel
+        Stevens and Dongfu Jiang and Weiming Ren and Yuxuan Sun and Cong Wei and Botao Yu and Ruibin Yuan and
+        Renliang Sun and Ming Yin and Boyuan Zheng and Zhenzhu Yang and Yibo Liu and Wenhao Huang and Huan Sun
+        and Yu Su and Wenhu Chen},
+        journal={arXiv preprint arXiv:2311.16502},
+        year={2023},
+      }
+
+    Paper: https://arxiv.org/abs/2311.16502
+    Website: https://mmmu-benchmark.github.io/
+    """
+
+    MMMU_HUGGINGFACE_DATASET_NAME: str = "MMMU/MMMU"
+    MAX_NUM_IMAGES: int = 7
+
+    SUBJECTS: List[str] = [
+        "Accounting",
+        "Agriculture",
+        "Architecture_and_Engineering",
+        "Art",
+        "Art_Theory",
+        "Basic_Medical_Science",
+        "Biology",
+        "Chemistry",
+        "Clinical_Medicine",
+        "Computer_Science",
+        "Design",
+        "Diagnostics_and_Laboratory_Medicine",
+        "Economics",
+        "Electronics",
+        "Energy_and_Power",
+        "Finance",
+        "Geography",
+        "History",
+        "Literature",
+        "Manage",
+        "Marketing",
+        "Materials",
+        "Math",
+        "Mechanical_Engineering",
+        "Music",
+        "Pharmacy",
+        "Physics",
+        "Psychology",
+        "Public_Health",
+        "Sociology",
+    ]
+
+    name = "mmmu"
+    description = (
+        "Evaluate multimodal models on massive multi-discipline tasks demanding college-level "
+        "subject knowledge and deliberate reasoning ([paper](https://arxiv.org/abs/2311.16502))."
+    )
+    tags = ["vision-language"]
+
+    def __init__(self, subject: str, question_type: str):
+        super().__init__()
+        assert subject in self.SUBJECTS, f"Invalid subject: {subject}"
+        self._subject: str = subject
+
+        assert question_type in ["multiple-choice", "open"], f"Invalid question type: {question_type}"
+        self._question_type: str = question_type
+
+    def get_instances(self, output_path: str) -> List[Instance]:
+        images_path: str = os.path.join(output_path, "images", self._subject)
+        ensure_directory_exists(images_path)
+
+        instances: List[Instance] = []
+
+        # Process the validation set
+        # There seems to be a dev set, but it's unavailable through load_dataset.
+        # When loading "dev", we get error: ValueError: Unknown split "dev". Should be one of ['test', 'validation'].
+        # The test set doesn't have answers, since the MMMU competition/leaderboard uses the test set
+        for row in tqdm(
+            load_dataset(self.MMMU_HUGGINGFACE_DATASET_NAME, self._subject, split="validation", cache_dir=output_path)
+        ):
+            # Skip questions that aren't in the subject we're interested in
+            if row["question_type"] != self._question_type:
+                continue
+
+            question_id: str = row["id"]
+            if self._subject not in question_id:
+                continue
+
+            question_template: str = row["question"]
+            options: List[str] = eval(row["options"])  # Convert the string to list of options
+            answer: str = row["answer"]
+
+            # Create the question. Questions can have text and images interleaved
+            question_template_to_image_path: Dict[str, str] = {}
+            content: List[MediaObject] = []
+            for img_number in range(1, self.MAX_NUM_IMAGES):
+                image_id: str = f"image_{img_number}"
+                if row[image_id] is None:
+                    # At this point, there are no more images for this question
+                    break
+
+                # Save the image locally
+                image_path: str = os.path.join(images_path, f"{question_id}_{image_id}.png")
+                if not os.path.exists(image_path):
+                    row[image_id].save(image_path)
+
+                image_template_tag: str = f"<image {img_number}>"
+                question_template_to_image_path[image_template_tag] = image_path
+
+                # There are cases when the image is included, but it is not used either in the
+                # question template or in the answer options
+                if image_template_tag not in question_template:
+                    # The image is not in the question template
+                    continue
+
+                head, question_template = question_template.split(image_template_tag, 1)
+                if head:
+                    content.append(MediaObject(text=head, content_type="text/plain"))
+                content.append(MediaObject(location=image_path, content_type="image/png"))
+
+            # Add the rest of the question template
+            if question_template:
+                content.append(MediaObject(text=question_template, content_type="text/plain"))
+
+            # Add the references
+            references: List[Reference] = []
+            if self._question_type == "multiple-choice":
+                # The given correct answer is a letter, but we need an index
+                correct_answer_index: int = ord(answer) - ord("A")
+
+                for i, option in enumerate(options):
+                    reference: Reference
+                    is_correct: bool = i == correct_answer_index
+
+                    if option in question_template_to_image_path:
+                        # Image answer choices
+                        image_path = question_template_to_image_path[option]
+                        image_choice = MediaObject(location=image_path, content_type="image/png")
+                        reference = Reference(
+                            Output(multimedia_content=MultimediaObject([image_choice])),
+                            tags=[CORRECT_TAG] if is_correct else [],
+                        )
+                    else:
+                        # Text answer choices
+                        reference = Reference(Output(text=option), tags=[CORRECT_TAG] if is_correct else [])
+
+                    references.append(reference)
+            else:
+                references.append(Reference(Output(text=answer), tags=[CORRECT_TAG]))
+
+            instances.append(
+                Instance(
+                    Input(multimedia_content=MultimediaObject(content)),
+                    references=references,
+                    split=VALID_SPLIT,
+                )
+            )
+
+        return instances

helm/benchmark/scenarios/vision_language/multipanelvqa_scenario.py

@@ -0,0 +1,169 @@
+import os.path
+from typing import Dict, List
+
+from datasets import load_dataset
+from tqdm import tqdm
+
+from helm.benchmark.scenarios.scenario import (
+    CORRECT_TAG,
+    TEST_SPLIT,
+    Instance,
+    Input,
+    Output,
+    Reference,
+    Scenario,
+)
+from helm.common.media_object import MediaObject, MultimediaObject
+from helm.common.general import ensure_directory_exists
+
+
+class MultipanelVQAScenario(Scenario):
+    """
+    Muffin or Chihuahua? Challenging Large Vision-Language Models with Multipanel VQA
+
+    We introduce Multipanel Visual Question Answering (MultipanelVQA), a novel benchmark
+    comprising 6,600 triplets of questions, answers, and multipanel images that specifically
+    challenge models in comprehending multipanel images. Our evaluation shows that questions in
+    the MultipanelVQA benchmark pose significant challenges to the state-of-the-art Large Vision
+    Language Models (LVLMs) tested, even though humans can attain approximately 99% accuracy on
+    these questions. There are two types of questions in two different situations in the
+    MultipanelVQA benchmark: multiple-choice or open-ended generation paired with real-world or
+    synthetic images. We use the multiple-choice metrics and the exact match metric for two
+    different question-answering types, respectively.
+
+    @article{fan2024muffin,
+    title={Muffin or Chihuahua? Challenging Large Vision-Language Models with Multipanel VQA},
+    author={Fan, Yue and Gu, Jing and Zhou, Kaiwen and Yan, Qianqi and Jiang, Shan and
+    Kuo, Ching-Chen and Guan, Xinze and Wang, Xin Eric},
+    journal={arXiv preprint arXiv:2401.15847},
+    year={2024}
+    }
+
+    Paper: https://arxiv.org/abs/2401.15847
+    """
+
+    MULTIPANELVQA_HUGGINGFACE_DATASET_NAME: Dict[str, str] = {
+        "synthetic": "yfan1997/MultipanelVQA_synthetic",
+        "real-world": "yfan1997/MultipanelVQA_real-world",
+    }
+
+    SUBJECTS: List[str] = ["synthetic", "real-world"]
+
+    name = "multipanelvqa"
+    description = "Evaluate multimodal models on  ([paper](https://arxiv.org/abs/2401.15847))."
+    tags = ["vision-language"]
+
+    def __init__(self, subject: str, question_type: str):
+        super().__init__()
+        assert subject in self.SUBJECTS, f"Invalid subject: {subject}"
+        self._subject: str = subject
+
+        assert question_type in ["multiple-choice", "open"], f"Invalid question type: {question_type}"
+        self._question_type: str = question_type
+
+    def convert_text_answer_to_option(self, text_answer: str, question: str):
+        option_answer: str
+        # Some answer may have a ')' with it
+        if len(text_answer) <= 3:
+            option_answer = text_answer[0]
+        else:
+            # There are examples where the answer is the text answer
+            # instead of an option
+            for line in question.split("\n"):
+                if text_answer in line:
+                    option_answer = line[0]
+                    break
+        return option_answer.upper()
+
+    def split_options_and_question(self, original_question: str):
+        question_and_options: List[str] = [item.strip().lower() for item in original_question.split("\n")]
+        last_append_phrase: str = "(please select one)"
+        question: str = question_and_options[0]
+        options: List[str] = []
+        if len(question_and_options) >= 6:
+            for item in question_and_options[1:]:
+                if last_append_phrase in item:
+                    break
+                options.append(item[3:])
+        elif len(question_and_options) == 5:
+            for item in question_and_options[1:]:
+                if last_append_phrase in item:
+                    item = item[: -len(last_append_phrase)]
+                options.append(item[3:])
+        return question, options
+
+    def get_instances(self, output_path: str) -> List[Instance]:
+        images_path: str = os.path.join(output_path, "images")
+        ensure_directory_exists(images_path)
+
+        # There is only the test split in Unicorn benchmark
+        instances: List[Instance] = []
+        # Process the test set
+        # Two open-ended generation instances and
+        # one multi-choice generation instance per row
+        for image_index, row in enumerate(
+            tqdm(
+                load_dataset(
+                    self.MULTIPANELVQA_HUGGINGFACE_DATASET_NAME[self._subject],
+                    split=TEST_SPLIT,
+                    cache_dir=output_path,
+                )
+            )
+        ):
+            # Download the image
+            # Save the image locally
+            image_path: str = os.path.join(images_path, f"{image_index}.png")
+            if not os.path.exists(image_path):
+                row["image"].save(image_path)
+
+            # Add the references
+            references: List[Reference] = []
+            question: str
+            answer: str
+            content: List[MediaObject]
+            if self._question_type == "open":
+                question_1: str = row["question_1"]
+                question_2: str = row["question_2"]
+                answer_1: str = row["answer_1"]
+                answer_2: str = row["answer_2"]
+                for answer, question in zip([answer_1, answer_2], [question_1, question_2]):
+                    content = [
+                        MediaObject(location=image_path, content_type="image/png"),
+                        MediaObject(text=question, content_type="text/plain"),
+                    ]
+                    instances.append(
+                        Instance(
+                            Input(multimedia_content=MultimediaObject(content)),
+                            references=[Reference(Output(text=answer), tags=[CORRECT_TAG])],
+                            split=TEST_SPLIT,
+                        )
+                    )
+            else:
+                options: List[str]
+                original_question: str = row["question_3"]
+                question, options = self.split_options_and_question(original_question)
+                answer = row["answer_3"].strip()
+                answer = self.convert_text_answer_to_option(answer, original_question)
+                # The given correct answer is a letter, but we need an index
+                correct_answer_index: int = ord(answer) - ord("A")
+                # The options are originally appended to the question
+
+                for i, option in enumerate(options):
+                    reference: Reference
+                    is_correct: bool = i == correct_answer_index
+                    reference = Reference(Output(text=option), tags=[CORRECT_TAG] if is_correct else [])
+                    references.append(reference)
+
+                content = [
+                    MediaObject(location=image_path, content_type="image/png"),
+                    MediaObject(text=question, content_type="text/plain"),
+                ]
+                instances.append(
+                    Instance(
+                        Input(multimedia_content=MultimediaObject(content)),
+                        references=references,
+                        split=TEST_SPLIT,
+                    )
+                )
+
+        return instances

helm/benchmark/scenarios/vision_language/pope_scenario.py

@@ -0,0 +1,104 @@
+from typing import List
+import os
+
+from helm.benchmark.scenarios.scenario import (
+    CORRECT_TAG,
+    TEST_SPLIT,
+    Instance,
+    Input,
+    Output,
+    Reference,
+    Scenario,
+)
+from datasets import load_dataset
+from tqdm import tqdm
+from helm.common.media_object import MediaObject, MultimediaObject
+from helm.common.general import ensure_directory_exists
+
+
+class POPEScenario(Scenario):
+    """
+    POPE dataset
+    Despite the promising progress on Large Vision-Language Models (LVLMs), we find that LVLMs suffer from
+    the hallucination problem, i.e. they tend to generate objects that are inconsistent with the target
+    images in the descriptions. To investigate it, this work presents the first systematic study on object
+    hallucination of LVLMs based on VQAv2 benchmark. We find that: objects that frequently occur in the
+    visual instructions or co-occur with the image objects, are obviously prone to be hallucinated by LVLMs.
+    In POPE, images from VQAv2 are matched with questions asking the appearance of certain objects in the
+    image. We use the exact match metric for model evaluation on POPE.
+
+    @inproceedings{li2023evaluating,
+    title={Evaluating Object Hallucination in Large Vision-Language Models},
+    author={Li, Yifan and Du, Yifan and Zhou, Kun and Wang, Jinpeng and Zhao, Wayne Xin and Wen, Ji-Rong},
+    booktitle={Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing},
+    pages={292--305},
+    year={2023}
+    }
+
+    Paper: https://aclanthology.org/2023.emnlp-main.20/
+    """
+
+    POPE_HUGGINGFACE_DATASET_NAME: str = "lmms-lab/POPE"
+
+    name = "pope"
+    description = (
+        "Open-ended questions about hallucination images ([paper](https://aclanthology.org/2023.emnlp-main.20/))."
+    )
+    tags = ["vision-language", "visual question answering"]
+    options: List[str] = ["Yes", "No"]
+
+    def get_label_from_answer(self, answer: str):
+        label: str
+        if answer == "yes":
+            label = "A"
+        elif answer == "no":
+            label = "B"
+        else:
+            raise NotImplementedError(f"Invalid answer: {answer}")
+        return label
+
+    def get_instances(self, output_path: str) -> List[Instance]:
+        images_path: str = os.path.join(output_path, "images")
+        ensure_directory_exists(images_path)
+        instances: List[Instance] = []
+        for row in tqdm(
+            load_dataset(
+                self.POPE_HUGGINGFACE_DATASET_NAME,
+                split=TEST_SPLIT,
+                cache_dir=output_path,
+            )
+        ):
+            image_source: str = row["image_source"]
+            # Save the image locally
+            image_path: str = os.path.join(images_path, f"{image_source}.jpg")
+            if not os.path.exists(image_path):
+                row["image"].save(image_path)
+
+            question: str = row["question"]
+            answer: str = row["answer"]
+            references: List[Reference] = []
+
+            answer = self.get_label_from_answer(answer)
+            # The given correct answer is a letter, but we need an index
+            correct_answer_index: int = ord(answer) - ord("A")
+            # The options are originally appended to the question
+
+            for i, option in enumerate(self.options):
+                reference: Reference
+                is_correct: bool = i == correct_answer_index
+                reference = Reference(Output(text=option), tags=[CORRECT_TAG] if is_correct else [])
+                references.append(reference)
+
+            content = [
+                MediaObject(location=image_path, content_type="image/jpeg"),
+                MediaObject(text=question, content_type="text/plain"),
+            ]
+            instances.append(
+                Instance(
+                    Input(multimedia_content=MultimediaObject(content)),
+                    references=references,
+                    split=TEST_SPLIT,
+                )
+            )
+
+        return instances