arctic-hs.py

# Copyright 2024 RealNetworks

# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at

#     http://www.apache.org/licenses/LICENSE-2.0

# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


from pathlib import Path
from typing import (
    Any,
    Dict,
    Iterable,
    List,
    Tuple,
)

from datasets import (
    Audio,
    BuilderConfig,
    DatasetInfo,
    Features,
    GeneratorBasedBuilder,
    Split,
    SplitGenerator,
    Value,
)
from datasets.download.download_manager import (
    ArchiveIterable,
    DownloadManager,
)
import pandas as pd


class ARCTICHSConfig(BuilderConfig):
    def __init__(
        self,
        name,
        **kwargs,
    ):
        super(
            ARCTICHSConfig,
            self,
        ).__init__(
            name=name,
            **kwargs,
        )

        if self.name.endswith("_symmetric"):
            self.is_symmetric = True
            self.part = "_".join(self.name.split("_")[:-1])
        else:
            self.is_symmetric = False
            self.part = self.name


class ARCTICHSDataset(GeneratorBasedBuilder):
    DEFAULT_CONFIG_NAME = "cmu_us_symmetric"

    BUILDER_CONFIGS = [
        ARCTICHSConfig(name=name)
        for name in (
            "cmu_non-us",
            "cmu_us",
            "l2",
            "cmu_non-us_symmetric",
            "cmu_us_symmetric",
            "l2_symmetric",
        )
    ]

    def get_audio_archive_path(
        self,
    ) -> Path:
        return Path("data") / self.config.part / "splits" / f"test.tar.gz"

    def get_metadata_paths(
        self,
    ) -> Dict[str, Path]:
        if self.config.part == "cmu_non-us":
            return {
                speaker: Path("data") / self.config.part / "pairs" / f"{speaker}.csv"
                for speaker in (
                    "ahw",
                    "aup",
                    "awb",
                    "axb",
                    "fem",
                    "gka",
                    "jmk",
                    "ksp",
                    "rxr",
                    "slp",
                )
            }
        elif self.config.part == "cmu_us":
            return {
                speaker: Path("data") / self.config.part / "pairs" / f"{speaker}.csv"
                for speaker in (
                    "aew",
                    "bdl",
                    "clb",
                    "eey",
                    "ljm",
                    "lnh",
                    "rms",
                    "slt",
                )
            }
        elif self.config.part == "l2":
            return {
                speaker: Path("data") / self.config.part / "pairs" / f"{speaker}.csv"
                for speaker in (
                    "aba",
                    "asi",
                    "bwc",
                    "ebvs",
                    "erms",
                    "hjk",
                    "hkk",
                    "hqtv",
                    "lxc",
                    "mbmps",
                    "ncc",
                    "njs",
                    "pnv",
                    "rrbi",
                    "ska",
                    "svbi",
                    "thv",
                    "tlv",
                    "tni",
                    "txhc",
                    "ybaa",
                    "ydck",
                    "ykwk",
                    "zhaa",
                )
            }

    def _info(self) -> DatasetInfo:
        return DatasetInfo(
            description="ARCTIC Human-Synthetic test dataset",
            features=Features(
                {
                    "audio": Audio(sampling_rate=16000),
                    "label": Value("string"),
                }
            ),
            supervised_keys=None,
            homepage="https://huggingface.co/datasets/realnetworks-kontxt/arctic-hs",
            license="CC BY 4.0",
            citation="\n".join(
                (
                    "@inproceedings{dropuljic-ssdww2v2ivls",
                    "author={Dropuljić, Branimir and Šuflaj, Miljenko and Jertec, Andrej and Obadić, Leo}",
                    "booktitle={2024 IEEE International Conference on Acoustics, Speech, and Signal Processing Workshops (ICASSPW)}",
                    "title={Synthetic speech detection with Wav2Vec 2.0 in various language settings}",
                    "year={2024}",
                    "volume={}",
                    "number={}",
                    "pages={1-5}",
                    "keywords={Synthetic speech detection;text-to-speech;wav2vec 2.0;spoofing attack;multilingualism}",
                    "doi={}",  # TODO: Add DOI once known
                    "}",
                )
            ),
        )

    def _split_generators(
        self,
        download_manager: DownloadManager,
    ) -> List[SplitGenerator]:
        archive_iterable = self.get_audio_archive_path()
        archive_iterable = download_manager.download(archive_iterable)
        archive_iterable = download_manager.iter_archive(archive_iterable)

        speaker_to_metadata_path = self.get_metadata_paths()
        speaker_to_metadata_path = download_manager.download(speaker_to_metadata_path)

        return [
            SplitGenerator(
                name=Split.TEST,
                gen_kwargs={
                    "archive_iterable": archive_iterable,
                    "speaker_to_metadata_path": speaker_to_metadata_path,
                },
            ),
        ]

    def _generate_examples(
        self,
        archive_iterable: ArchiveIterable,
        speaker_to_metadata_path: Dict[str, Path],
    ) -> Iterable[Tuple[int, Dict[str, Any]]]:
        speaker_to_symmetric = dict()
        for speaker, metadata_path in speaker_to_metadata_path.items():
            df = pd.read_csv(metadata_path).astype(
                {
                    "name": str,
                    "has_human_and_synthetic": bool,
                }
            )

            symmetric_names = df[df["has_human_and_synthetic"]]["name"].tolist()
            symmetric_names = set(symmetric_names)
            if len(symmetric_names) != 0:
                speaker_to_symmetric[speaker] = symmetric_names

        current_index = 0
        for audio_path, audio_file in archive_iterable:
            path = Path(audio_path)

            name = path.name

            # Samples are located in one of 2 folders:
            # - 'human'
            # - 'synthetic`
            #
            # Therefore the label is the name of their parent folder
            label = path.parent.name

            speaker = path.parent.parent.name

            if not self.config.is_symmetric or (
                speaker in speaker_to_symmetric
                and name in speaker_to_symmetric[speaker]
            ):
                audio = {
                    "path": audio_path,
                    "bytes": audio_file.read(),
                }

                yield current_index, {
                    "audio": audio,
                    "label": label,
                }

            current_index += 1