crfm-helm 0.4.0__py3-none-any.whl → 0.5.10__py3-none-any.whl

helm/benchmark/scenarios/vision_language/image2struct/webpage_scenario.py

@@ -0,0 +1,256 @@
+from typing import Dict, List, Any, Optional
+
+from helm.benchmark.annotation.image2struct.image_compiler_annotator import CompilationError
+from helm.benchmark.scenarios.scenario import VALID_SPLIT
+from helm.benchmark.scenarios.vision_language.image2struct.image2struct_scenario import (
+    Image2StructureScenario,
+    PROCESSED,
+    DIFFICULTY_ALL,
+)
+from helm.benchmark.scenarios.vision_language.image2struct.webpage.jekyll_server import JekyllServer
+from helm.benchmark.scenarios.vision_language.image2struct.webpage.driver import (
+    save_random_screenshot,
+    ScreenshotOptions,
+)
+from helm.benchmark.scenarios.vision_language.image2struct.webpage.utils import convert_html_to_text
+from helm.common.general import ensure_directory_exists
+from helm.common.optional_dependencies import handle_module_not_found_error
+from helm.common.hierarchical_logger import hlog
+
+try:
+    from html2text import HTML2Text
+except ModuleNotFoundError as e:
+    handle_module_not_found_error(e, suggestions=["image2struct"])
+
+
+import base64
+import os
+import threading
+import tarfile
+import shutil
+import time
+import pickle
+
+
+def extract_repo(base64_encoding: str, repo_path: str) -> None:
+    # Decode the base64 string which corresponds to an archive
+    # and extract the files to the repo_path
+    try:
+        archive = base64.b64decode(base64_encoding)
+        # Write to .tar file
+        with open(os.path.join(repo_path, "repo.tar.gz"), "wb") as f:
+            f.write(archive)
+        # Extract
+        with tarfile.open(os.path.join(repo_path, "repo.tar.gz"), "r:gz") as tar:
+            tar.extractall(repo_path)
+    except Exception as e:
+        raise ValueError(f"Failed to decode and extract the base64 archive: {e}")
+
+
+def list_assets(repo_path: str, extensions: List[str]) -> List[str]:
+    asset_paths: List[str] = []
+    for root, _, files in os.walk(repo_path):
+        for file in files:
+            if file.split(".")[-1].lower() in extensions:
+                # Remove repo_path from the file path
+                # ignore paths that start with a dot or in _site
+                if not root.startswith(os.path.join(repo_path, "_site")) and not root.startswith(
+                    os.path.join(repo_path, ".")
+                ):
+                    asset_paths.append(os.path.relpath(os.path.join(root, file), repo_path))
+    return asset_paths
+
+
+def serve_and_take_screenshot(
+    repo_path: str,
+    destination_path: str,
+    screenshot_options: ScreenshotOptions = ScreenshotOptions(),
+    max_tries: int = 5,
+) -> Dict[str, Any]:
+    # Start the Jekyll server
+    # Select a unique port per thread
+    port: int = 4000 + int(threading.get_ident()) % 1000
+    server = JekyllServer(repo_path, port=port, verbose=False)
+    success: bool = server.start()
+    if not success:
+        # This runs on examples that are not expected to fail
+        server.stop()
+        hlog(f"Failed to start the Jekyll server: {repo_path} on port {port}. Will raise a ValueError.")
+        raise ValueError(f"Jekyll server failed to start: {repo_path}")
+
+    # Take a screenshot of a random page
+    success = False
+    error: Optional[Exception] = None
+
+    MAX_TRIES_ALL_ERRORS = 3
+    MAX_TRIES_CONNECTION_REFUSED = 5
+    MAX_TRIES = max(MAX_TRIES_ALL_ERRORS, MAX_TRIES_CONNECTION_REFUSED)
+    for compilation_attempt in range(MAX_TRIES):
+        try:
+            infos: Dict[str, Any] = save_random_screenshot(destination_path, port=port, options=screenshot_options)
+            success = True
+            break
+        except Exception as e:
+            error = e
+
+            if "net::ERR_CONNECTION_REFUSED" in str(e) and compilation_attempt < MAX_TRIES_CONNECTION_REFUSED:
+                hlog(
+                    f"Failed to take a screenshot: ERR_CONNECTION_REFUSED [Attempt {compilation_attempt + 1}/"
+                    f"{MAX_TRIES_CONNECTION_REFUSED}]. Error: {e}. Retrying..."
+                )
+                server.stop()
+                time.sleep(0.5)
+                server.start()
+                time.sleep(0.5)
+            elif compilation_attempt < MAX_TRIES_ALL_ERRORS:
+                hlog(
+                    f"Failed to take a screenshot: Unknown [Attempt {compilation_attempt + 1}/{MAX_TRIES_ALL_ERRORS}]."
+                    f" Error: {e}. Retrying..."
+                )
+            else:
+                # Do not retry
+                hlog(
+                    f"Failed to take a screenshot: Unknown [Attempt {compilation_attempt + 1}/{MAX_TRIES_ALL_ERRORS}]."
+                    f" Error: {e}. Raising CompilationError."
+                )
+                break
+
+    if not success:
+        raise CompilationError(f"Failed to take a screenshot: {error}")
+
+    # Stop the server
+    server.stop()
+    time.sleep(0.1)
+
+    return infos
+
+
+class WebpageScenario(Image2StructureScenario):
+    BASE_PROMPT = (
+        "Please generate the source code to generate a webpage that looks like this image as much as feasibly possible.\n"  # noqa: E501
+        "You should output a json object associating each file name with its content.\n\n"
+        "Here is a simple example of the expected structure (that does not correspond to the image)."
+        " In this example, 3 files are created: index.html, style.css and script.js.\n"
+        "[\n"
+        "  {\n"
+        '    "filename": "index.html",\n'
+        '    "content": "<!DOCTYPE html>\\n<html>\\n<head>\\n<title>Title of the document</title>\\n</head>\\n<body>\\n\\n<p>Content of the document......</p>\\n\\n</body>\\n</html>"\n'  # noqa: E501
+        "  },\n"
+        "  {\n"
+        '    "filename": "style.css",\n'
+        '    "content": "body {\\n  background-color: lightblue;\\n}\\nh1 {\\n  color: white;\\n  text-align: center;\\n}"\n'  # noqa: E501
+        "  },\n"
+        "  {\n"
+        '    "filename": "script.js",\n'
+        '    "content": "document.getElementById(\\"demo\\").innerHTML = \\"Hello JavaScript!\\";"\n'
+        "  }\n"
+        "]\n"
+        "You do not have to create files with the same names. Create as many files as you need, you can even use directories if necessary,"  # noqa: E501
+        " they will be created for you automatically. Try to write some realistic code keeping in mind that it should"
+        " look like the image as much as feasibly possible."
+    )
+
+    HUGGINGFACE_DATASET_NAME = "stanford-crfm/i2s-webpage"
+    SUBSETS = ["css", "html", "javascript", "wild", "wild_legacy"]
+    MAX_TRIES: int = 5
+    ASSETS_EXTENSIONS: List[str] = ["png", "jpg", "jpeg", "gif", "svg", "webp", "ico", "bmp", "tiff"]
+
+    name = "image2webpage"
+    description = "Evaluate multimodal models on webpage generation to recreate a provided image"
+
+    def __init__(
+        self,
+        subset: str,
+        recompile_prompt: bool = True,
+        split: str = VALID_SPLIT,
+        difficulty: str = DIFFICULTY_ALL,
+        screenshot_options: ScreenshotOptions = ScreenshotOptions(),
+    ):
+        super().__init__(subset, recompile_prompt, split, difficulty)
+        self._screenshot_options = screenshot_options
+        self._html2text = HTML2Text()
+        self._html2text.ignore_links = True
+
+    def preprocess_row(self, row: Dict[str, Any], assets_path: str) -> Dict[str, Any]:
+        """Extract the base64 encoding of the repo from the row and return it."""
+        # No need to reprocess if the assets are already saved
+        assets_save_path: str = os.path.join(assets_path, str(row["uuid"].replace('"', "")))
+        if os.path.exists(assets_save_path):
+            try:
+                with open(os.path.join(assets_save_path, "assets_paths.pkl"), "rb") as f:
+                    row["assets_paths"] = pickle.load(f)
+                with open(os.path.join(assets_save_path, "assets_names.pkl"), "rb") as f:
+                    row["assets_names"] = pickle.load(f)
+                del row["assets"]
+                row["structure"] = PROCESSED
+                return row
+            except Exception:
+                # There was an issue when loading the assets, reprocess
+                shutil.rmtree(assets_save_path)
+        ensure_directory_exists(assets_save_path)
+
+        if "wild" in self._subset:
+            # There is no stucture
+            del row["assets"]
+            row["assets_paths"] = []
+            row["assets_names"] = []
+            return row
+
+        # Structure is a base64 encoding of the repo
+        if self._output_path is None:
+            raise ValueError("Output path not set")
+        repo_path = os.path.join(self._output_path, f"tmp{threading.get_ident()}_{self._subset}")
+        ensure_directory_exists(repo_path)
+
+        # Decode the base64 string which corresponds to an archive
+        # and extract the files to the repo_path
+        structure: str = row["structure"]
+        extract_repo(structure, repo_path)
+        row["structure"] = PROCESSED
+        row["repo_path"] = repo_path  # Stored for cleanup
+
+        # Process the assets
+        asset_paths: List[str] = list_assets(repo_path, self.ASSETS_EXTENSIONS)
+        del row["assets"]
+        row["assets_paths"] = []
+        row["assets_names"] = []
+        # Copy each asset to a unique persistent path
+        for i, asset_local_path in enumerate(asset_paths):
+            asset_name: str = asset_local_path
+            asset_dest_path = os.path.join(assets_save_path, f"{i}.{asset_local_path.split('.')[-1]}")
+            shutil.copyfile(os.path.join(row["repo_path"], asset_local_path), asset_dest_path)
+            row["assets_paths"].append(asset_dest_path)
+            row["assets_names"].append(asset_name)
+
+        # Save both assets_paths and assets_names as files than can be loaded
+        with open(os.path.join(assets_save_path, "assets_paths.pkl"), "wb") as f:
+            pickle.dump(row["assets_paths"], f)
+        with open(os.path.join(assets_save_path, "assets_names.pkl"), "wb") as f:
+            pickle.dump(row["assets_names"], f)
+
+        return row
+
+    def build_prompt(self, row: Dict[str, Any]) -> str:
+        prompt: str = self.BASE_PROMPT
+        assert "assets_paths" in row, "No assets paths in the row"
+        assert "assets_names" in row, "No assets names in the row"
+        assert len(row["assets_paths"]) == len(row["assets_names"])
+        if len(row["assets_names"]) > 0:
+            prompt += "\nYou have access to the following assets:\n"
+            for asset_local_path in row["assets_names"]:
+                prompt += f"- {asset_local_path}\n"
+        return prompt
+
+    def compile_and_save(self, structure: str, assets_path: str, destination_path: str) -> str:
+        # Structure is the path to the repo
+        # Serve and take screenshot
+        repo_path: str = structure
+        infos: Dict[str, Any] = serve_and_take_screenshot(repo_path, destination_path, self._screenshot_options)
+        text: str = convert_html_to_text(self._html2text, infos["html"])
+        return text
+
+    def finalize(self, row: Dict[str, Any]) -> None:
+        """Perform cleanup operations after the instance has been generated."""
+        if "repo_path" in row:
+            repo_path: str = row["repo_path"]
+            shutil.rmtree(repo_path)

helm/benchmark/scenarios/vision_language/math_vista_scenario.py

@@ -0,0 +1,117 @@
+import os
+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 MathVistaScenario(Scenario):
+    """
+    MathVista: Evaluating Math Reasoning in Visual Contexts
+
+    To bridge this gap, we present MathVista, a benchmark designed to combine challenges from diverse
+    mathematical and visual tasks. It consists of 6,141 examples, derived from 28 existing multimodal datasets
+    involving mathematics and 3 newly created datasets (i.e., IQTest, FunctionQA, and PaperQA). Completing these
+    tasks requires fine-grained, deep visual understanding and compositional reasoning, which all state-of-the-art
+    foundation models find challenging.
+
+        @inproceedings{lu2024mathvista,
+          author    = {Lu, Pan and Bansal, Hritik and Xia, Tony and Liu, Jiacheng and Li, Chunyuan and Hajishirzi,
+                       Hannaneh and Cheng, Hao and Chang, Kai-Wei and Galley, Michel and Gao, Jianfeng},
+          title     = {MathVista: Evaluating Mathematical Reasoning of Foundation Models in Visual Contexts},
+          booktitle={International Conference on Learning Representations (ICLR)},
+          year      = {2024}
+        }
+
+    Paper: https://arxiv.org/abs/2310.02255
+    Website: https://mathvista.github.io/
+    """
+
+    HUGGINGFACE_DATASET_NAME: str = "AI4Math/MathVista"
+
+    # Only the testmini split has answers
+    SPLIT: str = "testmini"
+
+    # Supported difficulties
+    GRADES: List[str] = ["elementary_school", "high_school", "college", "daily_life"]
+    QUESTION_TYPES: List[str] = ["multi_choice", "free_form"]
+
+    name = "math_vista"
+    description = (
+        "A benchmark designed to combine challenges from diverse mathematical and visual tasks. "
+        "([Lu et al., 2024](https://arxiv.org/abs/2310.02255))."
+    )
+    tags = ["vision-language", "reasoning", "math"]
+
+    def __init__(self, grade: str, question_type: str):
+        super().__init__()
+        assert grade in self.GRADES, f"Not supported: {grade}"
+        self._grade: str = grade.replace("_", " ")
+
+        assert question_type in self.QUESTION_TYPES, f"Invalid question type: {question_type}"
+        self._question_type: str = question_type
+
+    def get_instances(self, output_path: str) -> List[Instance]:
+        ensure_directory_exists(os.path.join(output_path, "images"))
+        instances: List[Instance] = []
+
+        for row in tqdm(load_dataset(self.HUGGINGFACE_DATASET_NAME, split=self.SPLIT, cache_dir=output_path)):
+            # Filter out the questions by type and grade (or difficulty)
+            if row["question_type"] != self._question_type or row["metadata"]["grade"] != self._grade:
+                continue
+
+            pid: str = row["pid"]
+            question: str = row["question"]
+            answer: str = row["answer"]
+
+            # Save the image locally
+            assert row["image"] == f"images/{pid}.jpg", f"Invalid image path: {row['image']} for question {pid}"
+            image_path: str = os.path.join(output_path, row["image"])
+
+            if not os.path.exists(image_path):
+                image = row["decoded_image"]
+                if image.mode in ("RGBA", "P", "LA"):
+                    image = image.convert("RGB")
+                image.save(image_path)
+
+            content: List[MediaObject] = [
+                MediaObject(text=question, content_type="text/plain"),
+                MediaObject(location=image_path, content_type="image/jpeg"),
+            ]
+
+            # Add the references
+            references: List[Reference] = []
+            if self._question_type == "multi_choice":
+                options: List[str] = row["choices"]
+                for option in options:
+                    references.append(Reference(Output(text=option), tags=[CORRECT_TAG] if option == answer else []))
+            else:
+                references.append(Reference(Output(text=answer), tags=[CORRECT_TAG]))
+
+                if row["unit"] is not None:
+                    references.append(Reference(Output(text=f"{answer} {row['unit']}"), tags=[CORRECT_TAG]))
+
+            instances.append(
+                Instance(
+                    Input(multimedia_content=MultimediaObject(content)),
+                    references=references,
+                    split=TEST_SPLIT,
+                )
+            )
+
+        assert (
+            len(instances) > 0
+        ), f"No instances found for subject {self._grade} and question type {self._question_type}"
+        return instances

helm/benchmark/scenarios/vision_language/mementos_scenario.py

@@ -0,0 +1,124 @@
+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,
+    TRAIN_SPLIT,
+    Input,
+    Instance,
+    Output,
+    Reference,
+    Scenario,
+)
+from helm.common.general import ensure_directory_exists, ensure_file_downloaded
+from helm.common.media_object import MediaObject, MultimediaObject
+
+
+class MementosScenario(Scenario):
+    """
+    Mementos: A Comprehensive Benchmark for Multimodal Large Language Model Reasoning over Image Sequences
+
+    We introduces Mementos, a new benchmark designed to assess MLLMs' sequential image reasoning abilities. Mementos
+    features 4,761 diverse image sequences with varying lengths.
+
+    @misc{wang2024mementos,
+    title={Mementos: A Comprehensive Benchmark for Multimodal Large Language Model Reasoning over Image Sequences},
+    author={Xiyao Wang and Yuhang Zhou and Xiaoyu Liu and Hongjin Lu and Yuancheng Xu and Feihong He and Jaehong Yoon
+    and Taixi Lu and Gedas Bertasius and Mohit Bansal and Huaxiu Yao and Furong Huang},
+    year={2024},
+    eprint={2401.10529},
+    archivePrefix={arXiv},
+    primaryClass={cs.CV}
+    }
+
+    Paper: https://arxiv.org/abs/2401.10529
+    """
+
+    MEMENTOS_HUGGINGFACE_DATASET_NAME: str = "RussWang96/unofficial_mementos_dataset"
+
+    IMAGE_URL: str = (
+        "https://huggingface.co/datasets/RussWang96/unofficial_mementos_dataset/resolve/main/"
+        + "{subject}/{split}/{file_name}?download=true"
+    )
+
+    DATA_FILES: str = "{subject}/{split}/metadata.csv"
+
+    QUESTION_PROMPT: str = (
+        "Write a description for the given image sequence in a single paragraph, what is happening in this episode?"
+    )
+
+    SUBJECTS: List[str] = ["comics", "dailylife", "robotics"]
+
+    name = "mementos"
+    description = (
+        "A Comprehensive Benchmark for Multimodal Large Language Model Reasoning over Image Sequences"
+        " ([Wang et al., 2024](https://arxiv.org/abs/2401.10529))."
+    )
+    tags = ["vision-language"]
+
+    def __init__(self, subject: str):
+        super().__init__()
+        assert subject in self.SUBJECTS, f"Invalid subject: {subject}"
+        self._subject: str = subject
+
+    def get_instances(self, output_path: str) -> List[Instance]:
+        subject_output_path: str = os.path.join(output_path, self._subject)
+        ensure_directory_exists(subject_output_path)
+
+        data_files = {
+            split: self.DATA_FILES.format(subject=self._subject, split=split) for split in [TRAIN_SPLIT, TEST_SPLIT]
+        }
+        instances: List[Instance] = []
+
+        for split in [TRAIN_SPLIT, TEST_SPLIT]:
+            cur_output_path = os.path.join(subject_output_path, split)
+            ensure_directory_exists(cur_output_path)
+
+            # Process the test set
+            for row in tqdm(
+                load_dataset(
+                    self.MEMENTOS_HUGGINGFACE_DATASET_NAME.format(subject=self._subject),
+                    data_files=data_files,
+                    split=split,
+                    cache_dir=cur_output_path,
+                )
+            ):
+                # Download the image
+                file_name: str = row["file_name"]
+                local_image_path: str = os.path.join(cur_output_path, file_name)
+                ensure_file_downloaded(
+                    source_url=self.IMAGE_URL.format(subject=self._subject, split=split, file_name=file_name),
+                    target_path=local_image_path,
+                    unpack=False,
+                )
+
+                content: List[MediaObject] = [
+                    MediaObject(location=local_image_path, content_type="image/png"),
+                    MediaObject(text=self.QUESTION_PROMPT, content_type="text/plain"),
+                ]
+                answer: str = row["description"]
+                instances.append(
+                    Instance(
+                        Input(multimedia_content=MultimediaObject(content)),
+                        references=[Reference(Output(text=answer), tags=[CORRECT_TAG])],
+                        split=split,
+                    )
+                )
+
+            print()
+
+        return instances
+
+
+def main():
+    scenario = MementosScenario("robotics")
+    instances = scenario.get_instances("output")
+    print(instances)
+
+
+if __name__ == "__main__":
+    main()

helm/benchmark/scenarios/vision_language/mm_safety_bench_scenario.py

@@ -0,0 +1,103 @@
+import os
+import json
+from typing import Any, Dict, List
+
+from helm.benchmark.scenarios.scenario import (
+    TEST_SPLIT,
+    Instance,
+    Input,
+    Scenario,
+)
+from helm.common.media_object import MediaObject, MultimediaObject
+from helm.common.general import ensure_file_downloaded
+
+
+class MMSafetyBenchScenario(Scenario):
+    """
+    To evaluate the extent of this vulnerability in open-source VLMs, compiled a substantial dataset encompassing
+    13 scenarios with a total of 5,040 text-image pairs
+
+    @misc{liu2023queryrelevant,
+          title={Query-Relevant Images Jailbreak Large Multi-Modal Models},
+          author={Xin Liu and Yichen Zhu and Yunshi Lan and Chao Yang and Yu Qiao},
+          year={2023},
+          eprint={2311.17600},
+          archivePrefix={arXiv},
+          primaryClass={cs.CV}
+    }
+
+    Paper: https://arxiv.org/abs/2311.17600
+    Website: https://isxinliu.github.io/Project/MM-SafetyBench/
+    Questions: https://github.com/isXinLiu/MM-SafetyBench/tree/main/data/processed_questions
+    """
+
+    SUBSET_TO_DATASET_FOLDER: Dict[str, str] = {
+        "illegal_activity": "01-Illegal_Activitiy",  # This is intentionally misspelled to match the original name
+        "hate_speech": "02-HateSpeech",
+        "malware_generation": "03-Malware_Generation",
+        "physical_harm": "04-Physical_Harm",
+        "economic_harm": "05-EconomicHarm",
+        "fraud": "06-Fraud",
+        "sex": "07-Sex",
+        "political_lobbying": "08-Political_Lobbying",
+        "privacy_violence": "09-Privacy_Violence",
+        "legal_opinion": "10-Legal_Opinion",
+        "financial_advice": "11-Financial_Advice",
+        "health_consultation": "12-Health_Consultation",
+        "government_decision": "13-Gov_Decision",
+    }
+
+    QUESTIONS_URL_TEMPLATE: str = (
+        "https://raw.githubusercontent.com/isXinLiu/MM-SafetyBench/main/data/processed_questions/{dataset}.json"
+    )
+    IMAGES_URL: str = "https://drive.google.com/uc?export=download&id=1xjW9k-aGkmwycqGCXbru70FaSKhSDcR_"
+
+    name = "mm_safety_bench"
+    description = (
+        "Expose the vulnerability of open-source VLMs with toxic and biased content "
+        "([Liu et al., 2023](https://arxiv.org/abs/2311.17600))."
+    )
+    tags = ["vision-language", "bias", "toxicity"]
+
+    def __init__(self, subset: str):
+        super().__init__()
+        assert subset in self.SUBSET_TO_DATASET_FOLDER, f"Invalid subset: {subset}"
+        self._dataset: str = self.SUBSET_TO_DATASET_FOLDER[subset]
+
+    def get_instances(self, output_path: str) -> List[Instance]:
+        # Download all the images
+        images_path: str = os.path.join(output_path, "MM-SafetyBench(imgs)")
+        assert os.path.exists(images_path), (
+            f"Images path does not exist: {images_path}. Download the images "
+            f"from {self.IMAGES_URL}, unzip and place it at {output_path}"
+        )
+        # SD_TYPO seems to have the greatest attack success rate on the models they evaluated
+        images_path = os.path.join(images_path, self._dataset, "SD_TYPO")
+        assert os.path.exists(images_path)
+
+        questions_path: str = os.path.join(output_path, f"{self._dataset}.json")
+        questions_url: str = self.QUESTIONS_URL_TEMPLATE.format(dataset=self._dataset)
+        ensure_file_downloaded(source_url=questions_url, target_path=questions_path)
+
+        instances: List[Instance] = []
+
+        with open(questions_path, "r") as questions_file:
+            questions: Dict[str, Any] = json.load(questions_file)
+            for question_id, question_data in questions.items():
+                local_image_path: str = os.path.join(images_path, f"{question_id}.jpg")
+                assert os.path.exists(local_image_path), f"Image does not exist: {local_image_path}"
+
+                question: str = question_data["Rephrased Question"]
+                content: List[MediaObject] = [
+                    MediaObject(location=local_image_path, content_type="image/jpeg"),
+                    MediaObject(text=question, content_type="text/plain"),
+                ]
+                instances.append(
+                    Instance(
+                        Input(multimedia_content=MultimediaObject(content)),
+                        references=[],
+                        split=TEST_SPLIT,
+                    )
+                )
+
+        return instances