crfm-helm 0.5.3__py3-none-any.whl → 0.5.5__py3-none-any.whl

helm/benchmark/scenarios/audio_language/mutox_scenario.py

@@ -0,0 +1,254 @@
+from io import BytesIO
+from typing import List
+import os
+import requests
+
+from pydub import AudioSegment
+from tqdm import tqdm
+import pandas as pd
+
+from helm.benchmark.scenarios.scenario import (
+    TEST_SPLIT,
+    Scenario,
+    Instance,
+    Reference,
+    CORRECT_TAG,
+    Input,
+    Output,
+)
+from helm.common.audio_utils import is_invalid_audio_file
+from helm.common.media_object import MediaObject, MultimediaObject
+from helm.common.general import ensure_directory_exists, ensure_file_downloaded
+from helm.common.hierarchical_logger import hlog, htrack_block
+
+
+class MuToxScenario(Scenario):
+    """
+    MuTox: MuTox: Universal MUltilingual Audio-based TOXicity Dataset and Zero-shot Detector
+
+    MuTox, the first highly multilingual audio-based dataset with toxicity labels. The dataset consists of 20k
+    audio utterances for English and Spanish, and 4k for the other languages. To showcase the quality of this
+    dataset, we train the MuTox audio-based toxicity classifier, which allows zero-shot toxicity detection across
+    a broad range of languages. This classifier outperforms existing text-based trainable classifiers by more than
+    1% AUC, while increasing the language coverage from 8 to 100+ languages. When compared to a wordlist-based
+    classifier that covers a similar number of languages, MuTox improves precision and recall by ∼2.5 times.
+
+    Languages:
+        "Arabic": "arb",
+        "Bengali": "ben",
+        "Bulgarian": "bul",
+        "Catalan": "cat",
+        "Czech": "ces",
+        "Mandarin Chinese": "cmn",
+        "Danish": "dan",
+        "German": "deu",
+        "Greek": "ell",
+        "English": "eng",
+        "Estonian": "est",
+        "Western Persian": "fas",
+        "Finnish": "fin",
+        "French": "fra",
+        "Hebrew": "heb",
+        "Hindi": "hin",
+        "Hungarian": "hun",
+        "Indonesian": "ind",
+        "Italian": "ita",
+        "Dutch": "nld",
+        "Polish": "pol",
+        "Portuguese": "por",
+        "Russian": "rus",
+        "Spanish": "spa",
+        "Slovak": "slk",
+        "Swahili": "swh",
+        "Tagalog": "tgl",
+        "Turkish": "tur",
+        "Urdu": "urd",
+        "Vietnamese": "vie",
+
+    The columns of the dataset are:
+
+    id: a string id of the segment;
+    lang: 3-letter language code;
+    partition: one of train, dev, or devtest
+    public_url_segment: a string formatted as url:start:end, where start and end are indicated in milliseconds;
+    audio_file_transcript: text transctiption of the segment;
+    contains_toxicity, toxicity_types, perlocutionary_effects: annotation results as strings
+    label: an integer label, equal to 1 if contains_toxicity equals Yes and 0 otherwise;
+    etox_result: toxic word (or multiple words, separated by |) detected by the Etox matcher;
+    detoxify_score: toxicity probabilities predicted by the Detoxify system (float numbers between 0 and 1);
+    mutox_speech_score, mutox_text_score, mutox_zero_shot_speech_score, mutox_zero_shot_text_score: MuTox predictions
+    as float numbers with any value (they can be interpreted as logits,
+    i.e. probabilities before a sigmoid transformation).
+
+    Citation:
+
+    @misc{costajussà2023mutox,
+      title={MuTox: Universal MUltilingual Audio-based TOXicity Dataset and Zero-shot Detector},
+      author={ Marta R. Costa-jussà, Mariano Coria Meglioli, Pierre Andrews, David Dale, Prangthip Hansanti,
+      Elahe Kalbassi, Alex Mourachko, Christophe Ropers, Carleigh Wood},
+      year={2023},
+      eprint={},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+    }
+    """
+
+    ANNOTATIONS_URL = "https://dl.fbaipublicfiles.com/seamless/datasets/mutox.tsv"
+
+    LANGAUGE_CODES = {
+        "Arabic": "arb",
+        "Bengali": "ben",
+        "Bulgarian": "bul",
+        "Catalan": "cat",
+        "Czech": "ces",
+        "Mandarin_Chinese": "cmn",
+        "Danish": "dan",
+        "German": "deu",
+        "Greek": "ell",
+        "English": "eng",
+        "Estonian": "est",
+        "Western_Persian": "fas",
+        "Finnish": "fin",
+        "French": "fra",
+        "Hebrew": "heb",
+        "Hindi": "hin",
+        "Hungarian": "hun",
+        "Indonesian": "ind",
+        "Italian": "ita",
+        "Dutch": "nld",
+        "Polish": "pol",
+        "Portuguese": "por",
+        "Russian": "rus",
+        "Spanish": "spa",
+        "Slovak": "slk",
+        "Swahili": "swh",
+        "Tagalog": "tgl",
+        "Turkish": "tur",
+        "Urdu": "urd",
+        "Vietnamese": "vie",
+    }
+
+    name = "mutox"
+    description = "Toxicity detection benchmark ([Costa-jussà et al, 2024](https://arxiv.org/abs/2401.05060))."
+    tags = ["audio", "classification", "toxicity "]
+
+    @staticmethod
+    def track_bad_audio_file(bad_audio_file: str, output_path: str) -> None:
+        """
+        Many of the links do not exist or point to broken so we keep track of them
+        and skip them in the future runs to significantly speed up gathering the instances.
+        """
+        with open(output_path, "a") as f:
+            f.write(bad_audio_file + "\n")
+
+    def __init__(self, language: str) -> None:
+        super().__init__()
+        self._language_code: str = self.LANGAUGE_CODES[language]
+
+    def get_instances(self, output_path: str) -> List[Instance]:
+        # Download the annotations
+        annotations_path: str = os.path.join(output_path, "mutox.tsv")
+        ensure_file_downloaded(self.ANNOTATIONS_URL, annotations_path)
+
+        # Read bad audio files
+        bad_audio_files: set[str] = set()
+        bad_audio_files_path: str = os.path.join(output_path, "bad_audio_files.txt")
+        if os.path.exists(bad_audio_files_path):
+            # Each line is the audio file name
+            with open(bad_audio_files_path, "r") as f:
+                for line in f:
+                    bad_audio_files.add(line.strip())
+            hlog(f"Found {len(bad_audio_files)} bad audio files.")
+
+        # Where the audio files will be downloaded to
+        audio_path: str = os.path.join(output_path, "audio")
+        ensure_directory_exists(audio_path)
+
+        instances: List[Instance] = []
+        df = pd.read_csv(annotations_path, delimiter="\t")
+        hlog(f"Found {len(df)} rows in the dataset")
+
+        valid_count: int = 0
+        total_count: int = 0
+        for row in tqdm(df.itertuples()):
+            # Only proces examples that are in devtest and the language we're interested in
+            if row.partition != "devtest":
+                continue
+
+            if row.lang != self._language_code:
+                continue
+
+            total_count += 1
+
+            # Discard known bad audio files
+            audio_filename: str = f"{row.id}.mp3"
+            with htrack_block(f"Processing audio file: {audio_filename}"):
+                if audio_filename in bad_audio_files:
+                    hlog(f"Skipping this example -- known bad audio file: {audio_filename}")
+                    continue
+
+                local_audio_path: str = os.path.join(audio_path, audio_filename)
+                if not os.path.exists(local_audio_path):
+                    # The provided URL has the complete audio, so we need to download it and clip it
+                    # public_url_segment: a string formatted as url:start:end,
+                    if not isinstance(row.public_url_segment, str):
+                        # Sometimes URL is just a float causing an error. Skip those.
+                        hlog(f"Skipping this example -- invalid URL: {row.public_url_segment}")
+                        continue
+
+                    parts = row.public_url_segment.split()
+                    if len(parts) != 3:
+                        hlog(f"Skipping this example -- invalid URL: {row.public_url_segment}")
+                        continue
+
+                    audio_url, start_ms_str, end_ms_str = parts
+                    start_ms, end_ms = int(start_ms_str), int(end_ms_str)
+
+                    # Download the full audio file
+                    try:
+                        response = requests.get(audio_url, stream=True)
+                        response.raise_for_status()
+
+                        # Load audio from the downloaded file
+                        audio = AudioSegment.from_file(BytesIO(response.content))
+
+                        # Clip the audio
+                        clipped_audio = audio[start_ms:end_ms]
+
+                        # Save the clipped file
+                        clipped_audio.export(local_audio_path, format="mp3")
+                    except Exception as e:
+                        # Some files are no longer available or invalid
+                        hlog(
+                            f"Skipping this example -- error downloading / processing audio file from {audio_url}: {e}"
+                        )
+                        self.track_bad_audio_file(audio_filename, bad_audio_files_path)
+                        continue
+
+                if is_invalid_audio_file(local_audio_path):
+                    hlog(f"Skipping this example -- Invalid audio file even after downloading at {local_audio_path}")
+                    self.track_bad_audio_file(audio_filename, bad_audio_files_path)
+                    continue
+                else:
+                    valid_count += 1
+                    hlog(f"Valid audio file found at {local_audio_path} (valid/total: {valid_count}/{total_count})")
+
+            input = Input(
+                multimedia_content=MultimediaObject(
+                    media_objects=[
+                        # Following what was prompted annotators as outlined in the paper
+                        MediaObject(text="Does the utterance contain toxicity?", content_type="text/plain"),
+                        MediaObject(location=local_audio_path, content_type="audio/mpeg"),
+                    ]
+                )
+            )
+
+            is_toxic: bool = row.label == 1
+            references = [
+                Reference(Output(text="Yes"), tags=[CORRECT_TAG] if is_toxic else []),
+                Reference(Output(text="No"), tags=[CORRECT_TAG] if not is_toxic else []),
+            ]
+            instances.append(Instance(input=input, references=references, split=TEST_SPLIT))
+
+        assert len(instances) > 0, f"No instances found for language: {self._language_code}"
+        return instances

helm/benchmark/scenarios/audio_language/parade_scenario.py

@@ -0,0 +1,97 @@
+from typing import List
+import os
+import json
+
+from helm.benchmark.scenarios.scenario import (
+    Scenario,
+    Instance,
+    Reference,
+    TEST_SPLIT,
+    CORRECT_TAG,
+    Input,
+    Output,
+)
+from tqdm import tqdm
+from helm.common.media_object import MediaObject, MultimediaObject
+from helm.common.general import ensure_file_downloaded
+
+
+class PARADEScenario(Scenario):
+    """PARADE
+
+    PARADE dataset is inspired by the PAIRS dataset for evaluating occupation and status bias
+    in vision-language models. We collect a new dataset of audio-text multi-choice QA task that
+    involves exploring occupation and status bias. The dataset consists of 436 audio-text QA pairs
+    with 3 options each.
+    """
+
+    ANNOT_URL = (
+        "https://huggingface.co/datasets/UCSC-VLAA/PARADE_audio/resolve/main/audio_result" "_path_mapping_v2.json"
+    )
+    MALE_AUDIO = "https://huggingface.co/datasets/UCSC-VLAA/PARADE_audio/resolve/main/onyx.zip"
+    FEMALE_AUDIO = "https://huggingface.co/datasets/UCSC-VLAA/PARADE_audio/resolve/main/nova.zip"
+
+    PARADE_INSTRUCTION = "\n\n Answer the question with one of the following options: A, B, or C."
+
+    SUBSET_LIST = ["occupation", "status"]
+    VOICE_MAPPING = {"male": "onyx", "female": "nova"}
+
+    name = "parade"
+    description = "Exploring occupation and status bias in the audio-text multi-choice QA task."
+    tags: List[str] = ["audio", "bias"]
+
+    def __init__(self, subset: str, voice: str) -> None:
+        super().__init__()
+
+        subset = subset.lower()
+        voice = voice.lower()
+        if subset not in PARADEScenario.SUBSET_LIST:
+            raise ValueError(f"Invalid subset. Valid subsets are: {PARADEScenario.SUBSET_LIST}")
+
+        if voice not in PARADEScenario.VOICE_MAPPING.keys():
+            raise ValueError(f"Invalid voice. Valid voices are: {PARADEScenario.VOICE_MAPPING.keys()}")
+
+        self._subset: str = subset
+        self._voice: str = voice
+
+    def _convert_answer_to_label(self, options: list, answer: str) -> str:
+        option_list = ["A", "B", "C"]
+        return option_list[options.index(answer)]
+
+    def get_instances(self, output_path: str) -> List[Instance]:
+        instances: List[Instance] = []
+        annot_save_path = os.path.join(output_path, "annotation.json")
+        ensure_file_downloaded(source_url=PARADEScenario.ANNOT_URL, target_path=annot_save_path)
+        annotations = json.load(open(annot_save_path))[self.VOICE_MAPPING[self._voice]][self._subset]
+        test_annotations = []
+        for key in annotations:
+            for key2 in annotations[key]:
+                test_annotations.append(annotations[key][key2])
+        audio_save_dir = os.path.join(output_path, "audio_files")
+        if self._voice == "male":
+            ensure_file_downloaded(source_url=PARADEScenario.MALE_AUDIO, target_path=audio_save_dir, unpack=True)
+        else:
+            ensure_file_downloaded(source_url=PARADEScenario.FEMALE_AUDIO, target_path=audio_save_dir, unpack=True)
+        for row in tqdm(test_annotations):
+            local_audio_path = os.path.join(output_path, "audio_files", row["path"])
+            answer = self._convert_answer_to_label(row["options"], row["label"])
+            # The given correct answer is a letter, but we need an index
+            correct_answer_index: int = ord(answer) - ord("A")
+            references: List[Reference] = []
+            question = row["question"]
+            for i, option in enumerate(row["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)
+
+            input = Input(
+                multimedia_content=MultimediaObject(
+                    [
+                        MediaObject(content_type="audio/mpeg", location=local_audio_path),
+                        MediaObject(content_type="text/plain", text=question + self.PARADE_INSTRUCTION),
+                    ]
+                )
+            )
+            instances.append(Instance(input=input, references=references, split=TEST_SPLIT))
+        return instances

helm/benchmark/scenarios/audio_language/speech_robust_bench_scenario.py

@@ -0,0 +1,124 @@
+"""Scenarios for audio models"""
+
+from typing import List
+import os
+import json
+
+from helm.benchmark.scenarios.scenario import (
+    Scenario,
+    Instance,
+    Reference,
+    TEST_SPLIT,
+    CORRECT_TAG,
+    Input,
+    Output,
+)
+from tqdm import tqdm
+from datasets import load_dataset
+from helm.common.media_object import MediaObject, MultimediaObject
+from helm.common.audio_utils import ensure_audio_file_exists_from_array
+from helm.common.general import ensure_file_downloaded
+
+
+class SpeechRobustBenchScenario(Scenario):
+    """Speech Robust Bench Scenario
+
+    Speech Robust Bench (Shah et al, 2024) is a comprehensive benchmark for evaluating
+    the robustness of ASR models to diverse corruptions. SRB is composed of 114 input
+    perturbations which simulate an heterogeneous range of corruptions that ASR models
+    may encounter when deployed in the wild. In this scenario, we select four subsets
+    in the benchmark for evaluation, each corresponds to a clean version of audio task.
+
+    Paper: https://arxiv.org/abs/2403.07937
+    Code: https://github.com/ahmedshah1494/speech_robust_bench
+
+    Citation:
+    @article{shah2024speech,
+        title={Speech robust bench: A robustness benchmark for speech recognition},
+        author={Shah, Muhammad A and Noguero, David Solans and Heikkila, Mikko A and Raj,
+        Bhiksha and Kourtellis, Nicolas},
+        journal={arXiv preprint arXiv:2403.07937},
+        year={2024}
+        }
+    """
+
+    HF_DATASET_NAME = "mshah1/speech_robust_bench"
+    HF_MAPPING_URL = (
+        "https://huggingface.co/datasets/PahaII/SRB_instance_key_mapping/resolve/main/srb_instance_keys.json"
+    )
+
+    # Select four subsets of the dataset for the benchmark
+    SUBJECTS_DICT = {
+        "ami_far": {
+            "name": "in-the-wild-AMI",
+            "split": "farfield",
+            "type": "audio/wav",
+            "mapping_key": "srb_aim_field_key2audio",
+        },
+        "ami_near": {
+            "name": "in-the-wild-AMI",
+            "split": "nearfield",
+            "type": "audio/wav",
+            "mapping_key": "srb_aim_field_key2audio",
+        },
+        "librispeech_gnoise": {
+            "name": "librispeech_asr-test.clean_pertEval_500_30",
+            "split": "gnoise.1",
+            "type": "audio/mp3",
+            "mapping_key": "srb_librispeech_noises_key2audio",
+        },
+        "librispeech_env_noise": {
+            "name": "librispeech_asr-test.clean_pertEval_500_30",
+            "split": "env_noise_esc50.1",
+            "type": "audio/mp3",
+            "mapping_key": "srb_librispeech_noises_key2audio",
+        },
+    }
+    # There are 30 different perturbation samples for each LibriSpeech ID
+    PERTURBATION_LEVELS = list(range(1, 31))
+    name = "speech_robust_bench"
+    description = (
+        "Speech recognition for 4 datasets with a wide range of corruptions"
+        "([Shah et al, 2024](https://arxiv.org/abs/2403.07937))."
+    )
+    tags: List[str] = ["audio", "recognition", "robustness", "multilinguality"]
+
+    def __init__(self, subject: str, level: int) -> None:
+        super().__init__()
+
+        self._subject = subject
+        if self._subject not in SpeechRobustBenchScenario.SUBJECTS_DICT.keys():
+            raise ValueError(f"Invalid subject. Valid subjects are: {SpeechRobustBenchScenario.SUBJECTS_DICT.keys()}")
+        self._level = level
+        if self._level not in SpeechRobustBenchScenario.PERTURBATION_LEVELS:
+            raise ValueError(f"Invalid level. Valid levels are: {SpeechRobustBenchScenario.PERTURBATION_LEVELS}")
+
+    def get_instances(self, output_path: str) -> List[Instance]:
+        instances: List[Instance] = []
+        subject_name = SpeechRobustBenchScenario.SUBJECTS_DICT[self._subject]["name"]
+        subject_split = SpeechRobustBenchScenario.SUBJECTS_DICT[self._subject]["split"]
+        subject_type = SpeechRobustBenchScenario.SUBJECTS_DICT[self._subject]["type"]
+        subject_audio_type = subject_type.split("/")[-1]
+        subject_mapping = SpeechRobustBenchScenario.SUBJECTS_DICT[self._subject]["mapping_key"]
+        audio_save_dir = os.path.join(output_path, "audio_files")
+        mapping_local_path = os.path.join(output_path, "srb_instance_keys.json")
+        ensure_file_downloaded(source_url=SpeechRobustBenchScenario.HF_MAPPING_URL, target_path=mapping_local_path)
+        mapping_keys = json.load(open(mapping_local_path))[subject_mapping][subject_split]
+        meta_data = load_dataset(
+            SpeechRobustBenchScenario.HF_DATASET_NAME,
+            name=subject_name,
+            cache_dir=output_path,
+            split=subject_split,
+        )
+        for line_num in tqdm(list(mapping_keys.keys())):
+            row = meta_data[int(mapping_keys[line_num][self._level - 1])]
+            local_audio_name = f"{self._subject}_{subject_split}_{line_num}.{subject_audio_type}"
+            local_audio_path = os.path.join(audio_save_dir, local_audio_name)
+            ensure_audio_file_exists_from_array(local_audio_path, row["audio"]["array"], row["audio"]["sampling_rate"])
+            answer = row["text"].lower()
+            input = Input(
+                multimedia_content=MultimediaObject([MediaObject(content_type=subject_type, location=local_audio_path)])
+            )
+            references = [Reference(Output(text=answer), tags=[CORRECT_TAG])]
+            instances.append(Instance(input=input, references=references, split=TEST_SPLIT))
+        return instances

helm/benchmark/scenarios/audio_language/vocal_sound_scenario.py

@@ -0,0 +1,69 @@
+"""Scenarios for audio models"""
+
+from typing import List
+import os
+
+from helm.benchmark.scenarios.scenario import (
+    Scenario,
+    Instance,
+    Reference,
+    TEST_SPLIT,
+    CORRECT_TAG,
+    Input,
+    Output,
+)
+from tqdm import tqdm
+
+from helm.common.media_object import MediaObject, MultimediaObject
+from helm.common.general import ensure_file_downloaded
+from helm.common.audio_utils import is_invalid_audio_file
+
+
+class VocalSoundScenario(Scenario):
+    """Vocal Sound Scenario
+
+    The VocalSound (Gong et al, 2022) dataset consists of 21,000 crowdsourced recordings
+    of laughter, sighs, coughs, throat clearing, sneezes, and sniffs from 3,365 unique subjects.
+    The task is to classify the human behaviour from the audio sample.
+
+    Paper: https://arxiv.org/abs/2205.03433
+    Code: https://github.com/YuanGongND/vocalsound
+
+    Citation:
+    @INPROCEEDINGS{gong_vocalsound,
+                author={Gong, Yuan and Yu, Jin and Glass, James},
+                booktitle={ICASSP 2022 - 2022 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP)},
+                title={Vocalsound: A Dataset for Improving Human Vocal Sounds Recognition},
+                year={2022},
+                pages={151-155},
+                doi={10.1109/ICASSP43922.2022.9746828}
+                }
+    """  # noqa: E501
+
+    DOWNLOADING_URL = "https://www.dropbox.com/s/c5ace70qh1vbyzb/vs_release_16k.zip"
+
+    name = "vocal_sound"
+    description = "Classify an audio sample of a spoken digit ([Gong et al, 2022](https://arxiv.org/abs/2205.03433))."
+    tags: List[str] = ["audio", "classification"]
+
+    def get_instances(self, output_path: str) -> List[Instance]:
+        instances: List[Instance] = []
+        down_loading_path = os.path.join(output_path, "download")
+        ensure_file_downloaded(VocalSoundScenario.DOWNLOADING_URL, down_loading_path, unpack=True)
+        wav_save_dir = os.path.join(down_loading_path, "audio_16k")
+        for file_name in tqdm(os.listdir(wav_save_dir)):
+            local_audio_path: str = os.path.join(wav_save_dir, file_name)
+            if not file_name.endswith(".wav") or is_invalid_audio_file(local_audio_path):
+                continue
+
+            input = Input(
+                multimedia_content=MultimediaObject([MediaObject(content_type="audio/wav", location=local_audio_path)])
+            )
+
+            answer: str = file_name.split("_")[-1].split(".")[0]
+            if answer == "throatclearing":
+                answer = "throat clearing"
+
+            references = [Reference(Output(text=str(answer)), tags=[CORRECT_TAG])]
+            instances.append(Instance(input=input, references=references, split=TEST_SPLIT))
+        return instances

helm/benchmark/scenarios/audio_language/voice_jailbreak_attacks_scenario.py

@@ -0,0 +1,87 @@
+import os
+from typing import List
+
+from helm.benchmark.scenarios.scenario import (
+    TEST_SPLIT,
+    Scenario,
+    Instance,
+    Input,
+)
+from helm.common.audio_utils import is_invalid_audio_file
+from helm.common.media_object import MediaObject, MultimediaObject
+
+
+class VoiceJailbreakAttacksScenario(Scenario):
+    """
+    Voice Jailbreak Attacks Against GPT-4o
+
+    Paper: https://arxiv.org/abs/2405.19103
+
+    The examples used in this scenario was generated following the instructions in the GitHub:
+    https://github.com/TrustAIRLab/VoiceJailbreakAttack
+    Note: The more advanced jailbreaking subset addresses the AI as "ChatGPT".
+
+    We ran:
+    python tts/prompt2audio.py --dataset baseline --voice fable
+    python tts/prompt2audio.py --dataset baseline --voice fable
+
+    then placed the generated folders at benchmark_output/scenarios/voice_jailbreak_attacks:
+
+    voice_jailbreak_attacks/
+        baseline_fable/
+            *.wav
+        textjailbreak_fable/
+            *.wav
+
+    Base prompts (30 total):
+    https://github.com/TrustAIRLab/VoiceJailbreakAttack/blob/main/data/question_set/questions_tiny.csv
+    Jailbreak templates:
+    https://github.com/TrustAIRLab/VoiceJailbreakAttack/blob/main/data/jailbreak_prompts/text_jailbreak_prompts.csv
+
+    The authors used Attack Success Rate (ASR) as the evaluation metric.
+    Specifically, two authors manually label each response to determine if it answers the forbidden
+    question. If there is any uncertainty, the authors discuss to reach a conclusion
+
+    Citation:
+
+    @article{SWBZ24,
+      author = {Xinyue Shen and Yixin Wu and Michael Backes and Yang Zhang},
+      title = {{Voice Jailbreak Attacks Against GPT-4o}},
+      journal = {{CoRR abs/2405.19103}},
+      year = {2024}
+    }
+    """
+
+    VALID_SUBSETS = ["baseline", "textjailbreak"]
+
+    name = "voice_jailbreak_attacks"
+    description = "Voice jailbreak attacks against GPT-4o ([Shen et al, 2024](https://arxiv.org/abs/2405.19103))."
+    tags = ["audio", "safety"]
+
+    def __init__(self, subset: str = "baseline") -> None:
+        super().__init__()
+        assert subset in self.VALID_SUBSETS, f"Invalid subset: {subset}"
+        self._subset = subset
+
+    def get_instances(self, output_path: str) -> List[Instance]:
+        audio_directory_path: str = os.path.join(output_path, f"{self._subset}_fable")
+        assert os.path.exists(audio_directory_path), f"Audio directory does not exist: {audio_directory_path}"
+
+        instances: List[Instance] = []
+        for file in os.listdir(audio_directory_path):
+            if not file.endswith("wav"):
+                continue
+
+            audio_path: str = os.path.join(audio_directory_path, file)
+            assert not is_invalid_audio_file(audio_path), f"Invalid audio file: {audio_path}"
+
+            input = Input(
+                multimedia_content=MultimediaObject(
+                    media_objects=[
+                        MediaObject(location=audio_path, content_type="audio/wav"),
+                    ]
+                )
+            )
+            instances.append(Instance(input=input, references=[], split=TEST_SPLIT))
+
+        return instances