Init

README.md

@@ -1,3 +1,195 @@
 ---
-license: cc-by-4.0
+annotations_creators:
+- crowdsourced
+language: []
+language_creators:
+- crowdsourced
+license:
+- cc-by-4.0
+multilinguality:
+- multilingual
+pretty_name: VoxCeleb
+size_categories:
+- 1K<n<10K
+- 10K<n<100K
+- 100K<n<1M
+source_datasets: []
+tags: []
+task_categories:
+- automatic-speech-recognition
+- audio-classification
+- image-classification
+task_ids:
+- speaker-identification
 ---
+
+# Dataset Card for VoxCeleb
+
+## Table of Contents
+- [Table of Contents](#table-of-contents)
+- [Dataset Description](#dataset-description)
+  - [Dataset Summary](#dataset-summary)
+  - [Supported Tasks and Leaderboards](#supported-tasks-and-leaderboards)
+  - [Languages](#languages)
+- [Dataset Structure](#dataset-structure)
+  - [Data Instances](#data-instances)
+  - [Data Fields](#data-fields)
+  - [Data Splits](#data-splits)
+- [Dataset Creation](#dataset-creation)
+  - [Curation Rationale](#curation-rationale)
+  - [Source Data](#source-data)
+  - [Annotations](#annotations)
+  - [Personal and Sensitive Information](#personal-and-sensitive-information)
+- [Considerations for Using the Data](#considerations-for-using-the-data)
+  - [Social Impact of Dataset](#social-impact-of-dataset)
+  - [Discussion of Biases](#discussion-of-biases)
+  - [Other Known Limitations](#other-known-limitations)
+- [Additional Information](#additional-information)
+  - [Dataset Curators](#dataset-curators)
+  - [Licensing Information](#licensing-information)
+  - [Citation Information](#citation-information)
+  - [Contributions](#contributions)
+
+## Dataset Description
+
+### Dataset Summary
+
+VoxCeleb is an audio-visual dataset consisting of short clips of human speech, extracted from interview videos uploaded to YouTube.
+
+NOTE: Although this dataset can be automatically downloaded, you must manually request credentials to access it from the creators' website.
+
+### Supported Tasks and Leaderboards
+
+[More Information Needed]
+
+### Languages
+
+[More Information Needed]
+
+## Dataset Structure
+
+### Data Instances
+
+Each datapoint has a path to the audio/video clip along with metadata about the speaker.
+
+```
+{
+  'file': '/datasets/downloads/extracted/[hash]/wav/id10271/_YimahVgI1A/00003.wav',
+  'file_format': 'wav',
+  'dataset_id': 'vox1',
+  'speaker_id': 'id10271',
+  'speaker_gender': 'm',
+  'speaker_name': 'Ed_Westwick',
+  'speaker_nationality': 'UK',
+  'video_id': '_YimahVgI1A',
+  'clip_id': '00003',
+  'audio': {
+    'path': '/datasets/downloads/extracted/[hash]/wav/id10271/_YimahVgI1A/00003.wav',
+    'array': array([...], dtype=float32),
+    'sampling_rate': 16000
+  }
+}
+```
+
+### Data Fields
+
+Each row includes the following fields:
+- `file`: The path to the audio/video clip
+- `file_format`: The file format in which the clip is stored (e.g. `wav`, `aac`, `mp4`)
+- `dataset_id`: The ID of the dataset this clip is from (`vox1`, `vox2`)
+- `speaker_id`: The ID of the speaker in this clip
+- `speaker_gender`: The gender of the speaker (`m`/`f`)
+- `speaker_name` (VoxCeleb1 only): The full name of the speaker in the clip
+- `speaker_nationality` (VoxCeleb1 only): The speaker's country of origin
+- `video_id`: The ID of the video from which this clip was taken
+- `clip_index`: The index of the clip for this specific video
+- `audio` (Audio dataset only): The audio signal data
+
+### Data Splits
+
+The dataset has a predefined dev set and test set, but no training set. For training purposes, the dev set may be split into training and validation sets.
+
+## Dataset Creation
+
+### Curation Rationale
+
+[More Information Needed]
+
+### Source Data
+
+#### Initial Data Collection and Normalization
+
+[More Information Needed]
+
+#### Who are the source language producers?
+
+[More Information Needed]
+
+### Annotations
+
+#### Annotation process
+
+[More Information Needed]
+
+#### Who are the annotators?
+
+[More Information Needed]
+
+### Personal and Sensitive Information
+
+The dataset includes recordings of clips (mostly of celebrities and public figures) from public YouTube videos. The names of speakers in VoxCeleb1 are provided.
+
+## Considerations for Using the Data
+
+### Social Impact of Dataset
+
+[More Information Needed]
+
+### Discussion of Biases
+
+[More Information Needed]
+
+### Other Known Limitations
+
+[More Information Needed]
+
+## Additional Information
+
+### Dataset Curators
+
+[More Information Needed]
+
+### Licensing Information
+
+[More Information Needed]
+
+### Citation Information
+
+The VoxCeleb authors request that anyone who uses VoxCeleb1 or VoxCeleb2 includes the following three citations:
+```
+@Article{Nagrani19,
+    author = "Arsha Nagrani and Joon~Son Chung and Weidi Xie and Andrew Zisserman",
+    title = "Voxceleb: Large-scale speaker verification in the wild",
+    journal = "Computer Science and Language",
+    year = "2019",
+    publisher = "Elsevier",
+}
+
+@InProceedings{Chung18b,
+    author = "Chung, J.~S. and Nagrani, A. and Zisserman, A.",
+    title = "VoxCeleb2: Deep Speaker Recognition",
+    booktitle = "INTERSPEECH",
+    year = "2018",
+}
+
+@InProceedings{Nagrani17,
+    author = "Nagrani, A. and Chung, J.~S. and Zisserman, A.",
+    title = "VoxCeleb: a large-scale speaker identification dataset",
+    booktitle = "INTERSPEECH",
+    year = "2017",
+}
+```
+
+### Contributions
+
+Thanks to [@101arrowz](https://github.com/101arrowz) for adding this dataset.

vox_celeb.py

@@ -0,0 +1,383 @@
+# coding=utf-8
+# Copyright 2022 The HuggingFace Datasets Authors and Arjun Barrett.
+#
+# 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.
+
+# Lint as: python3
+"""VoxCeleb audio-visual human speech dataset."""
+
+import json
+import os
+from getpass import getpass
+from hashlib import sha256
+from itertools import repeat
+from multiprocessing import Manager, Pool, Process
+from pathlib import Path
+from queue import Queue
+from shutil import copyfileobj
+from typing import Optional, cast
+
+import pandas as pd
+import requests
+
+import datasets
+
+_CITATION = """\
+@Article{Nagrani19,
+    author = "Arsha Nagrani and Joon~Son Chung and Weidi Xie and Andrew Zisserman",
+    title = "Voxceleb: Large-scale speaker verification in the wild",
+    journal = "Computer Science and Language",
+    year = "2019",
+    publisher = "Elsevier",
+}
+
+@InProceedings{Chung18b,
+    author = "Chung, J.~S. and Nagrani, A. and Zisserman, A.",
+    title = "VoxCeleb2: Deep Speaker Recognition",
+    booktitle = "INTERSPEECH",
+    year = "2018",
+}
+
+@InProceedings{Nagrani17,
+    author = "Nagrani, A. and Chung, J.~S. and Zisserman, A.",
+    title = "VoxCeleb: a large-scale speaker identification dataset",
+    booktitle = "INTERSPEECH",
+    year = "2017",
+}
+"""
+
+_DESCRIPTION = """\
+VoxCeleb is an audio-visual dataset consisting of short clips of human speech, extracted from interview videos uploaded to YouTube
+"""
+
+_URL = "https://mm.kaist.ac.kr/datasets/voxceleb"
+
+_URLS = {
+    "video": {
+        "placeholder": "http://143.248.230.30/voxceleb/vox1a/vox2_dev_mp4_parta",
+        "dev": (
+            "http://143.248.230.30/voxceleb/vox1a/vox2_dev_mp4_partaa",
+            "http://143.248.230.30/voxceleb/vox1a/vox2_dev_mp4_partab",
+            "http://143.248.230.30/voxceleb/vox1a/vox2_dev_mp4_partac",
+            "http://143.248.230.30/voxceleb/vox1a/vox2_dev_mp4_partad",
+            "http://143.248.230.30/voxceleb/vox1a/vox2_dev_mp4_partae",
+            "http://143.248.230.30/voxceleb/vox1a/vox2_dev_mp4_partaf",
+            "http://143.248.230.30/voxceleb/vox1a/vox2_dev_mp4_partag",
+            "http://143.248.230.30/voxceleb/vox1a/vox2_dev_mp4_partah",
+            "http://143.248.230.30/voxceleb/vox1a/vox2_dev_mp4_partai",
+        ),
+        "test": "http://143.248.230.30/voxceleb/vox1a/vox2_test_mp4.zip",
+    },
+    "audio1": {
+        "placeholder": "http://143.248.230.30/voxceleb/vox1a/vox1_dev_wav_parta",
+        "dev": (
+            "http://143.248.230.30/voxceleb/vox1a/vox1_dev_wav_partaa",
+            "http://143.248.230.30/voxceleb/vox1a/vox1_dev_wav_partab",
+            "http://143.248.230.30/voxceleb/vox1a/vox1_dev_wav_partac",
+            "http://143.248.230.30/voxceleb/vox1a/vox1_dev_wav_partad",
+        ),
+        "test": "http://143.248.230.30/voxceleb/vox1a/vox1_test_wav.zip",
+    },
+    "audio2": {
+        "placeholder": "http://143.248.230.30/voxceleb/vox1a/vox2_dev_aac_parta",
+        "dev": (
+            "http://143.248.230.30/voxceleb/vox1a/vox2_dev_aac_partaa",
+            "http://143.248.230.30/voxceleb/vox1a/vox2_dev_aac_partab",
+            "http://143.248.230.30/voxceleb/vox1a/vox2_dev_aac_partac",
+            "http://143.248.230.30/voxceleb/vox1a/vox2_dev_aac_partad",
+            "http://143.248.230.30/voxceleb/vox1a/vox2_dev_aac_partae",
+            "http://143.248.230.30/voxceleb/vox1a/vox2_dev_aac_partaf",
+            "http://143.248.230.30/voxceleb/vox1a/vox2_dev_aac_partag",
+            "http://143.248.230.30/voxceleb/vox1a/vox2_dev_aac_partah",
+        ),
+        "test": "http://143.248.230.30/voxceleb/vox1a/vox2_test_aac.zip",
+    },
+}
+
+_DATASET_IDS = {"video": "vox2", "audio1": "vox1", "audio2": "vox2"}
+
+_PLACEHOLDER_MAPS = dict(
+    value
+    for urls in _URLS.values()
+    for value in ((urls["placeholder"], urls["dev"]), (urls["test"], (urls["test"],)))
+)
+
+
+def _mp_download(
+    url: str,
+    tmp_path: Path,
+    cred_user: str,
+    cred_pass: str,
+    resume_pos: int,
+    length: int,
+    queue: Queue,
+):
+    if length == resume_pos:
+        return
+    with open(tmp_path, "ab" if resume_pos else "wb") as tmp:
+        headers: dict[str, str] = {}
+        if resume_pos != 0:
+            headers["Range"] = f"bytes={resume_pos}-"
+        response = requests.get(
+            url, auth=(cred_user, cred_pass), headers=headers, stream=True
+        )
+        if response.status_code >= 200 and response.status_code < 300:
+            for chunk in response.iter_content(chunk_size=65536):
+                queue.put(len(chunk))
+                tmp.write(chunk)
+        else:
+            raise ConnectionError("failed to fetch dataset")
+
+
+# TODO: Name of the dataset usually matches the script name with CamelCase instead of snake_case
+class VoxCeleb(datasets.GeneratorBasedBuilder):
+    """TODO: Short description of my dataset."""
+
+    VERSION = datasets.Version("1.0.0")
+
+    BUILDER_CONFIGS = [
+        datasets.BuilderConfig(
+            name="video", version=VERSION, description="Video clips of human speech"
+        ),
+        datasets.BuilderConfig(
+            name="audio", version=VERSION, description="Audio clips of human speech"
+        ),
+        datasets.BuilderConfig(
+            name="audio1",
+            version=datasets.Version("1.0.0"),
+            description="Audio clips of human speech from VoxCeleb1",
+        ),
+        datasets.BuilderConfig(
+            name="audio2",
+            version=datasets.Version("2.0.0"),
+            description="Audio clips of human speech from VoxCeleb2",
+        ),
+    ]
+
+    def _info(self):
+        features = cast(
+            dict,
+            {
+                "file": datasets.Value("string"),
+                "file_format": datasets.Value("string"),
+                "dataset_id": datasets.Value("string"),
+                "speaker_id": datasets.Value("string"),
+                "speaker_gender": datasets.Value("string"),
+                "video_id": datasets.Value("string"),
+                "clip_index": datasets.Value("int32"),
+            },
+        )
+        if self.config.name == "audio1":
+            features["speaker_name"] = datasets.Value("string")
+            features["speaker_nationality"] = datasets.Value("string")
+        if self.config.name.startswith("audio"):
+            features["audio"] = datasets.Audio(sampling_rate=16000)
+
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            homepage=_URL,
+            supervised_keys=datasets.info.SupervisedKeysData("file", "speaker_id"),
+            features=datasets.Features(features),
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager):
+        if dl_manager.is_streaming:
+            raise TypeError("Streaming is not supported for VoxCeleb")
+        targets = (
+            ["audio1", "audio2"] if self.config.name == "audio" else [self.config.name]
+        )
+        cred_user: Optional[str] = os.environ.get("HUGGING_FACE_VOX_CELEB_USER")
+        cred_pass: Optional[str] = os.environ.get("HUGGING_FACE_VOX_CELEB_PASS")
+        creds_path = Path(
+            f"~/.huggingface/voxceleb_{self.VERSION}_credentials"
+        ).expanduser()
+
+        if cred_user is None and cred_pass is None:
+            if creds_path.exists():
+                with open(creds_path, "r") as creds:
+                    cred_user, cred_pass = json.load(creds)
+            else:
+                print(
+                    "You need a temporary username and password to access VoxCeleb.",
+                    f"Go to the project homepage ({_URL}) and fill out the form to request credentials.",
+                )
+                cred_user = input("VoxCeleb username: ")
+                cred_pass = getpass("VoxCeleb password: ")
+
+        if not cred_user or not cred_pass:
+            raise ValueError("could not find username and password to log in")
+
+        saved_credentials = False
+
+        def save_credentials():
+            nonlocal saved_credentials, cred_user, cred_pass, creds_path
+            if not saved_credentials:
+                creds_path.parent.mkdir(exist_ok=True)
+                with open(creds_path, "w") as creds:
+                    json.dump((cred_user, cred_pass), creds)
+                saved_credentials = True
+
+        def download_custom(placeholder_url: str, path: str):
+            nonlocal dl_manager, cred_user, cred_pass
+            sources = _PLACEHOLDER_MAPS[placeholder_url]
+            tmp_paths: list[Path] = []
+            lengths: list[int] = []
+            start_positions: list[int] = []
+            for url in sources:
+                head = requests.head(url, auth=(cred_user, cred_pass))
+                if head.status_code == 401:
+                    raise ValueError("failed to authenticate with VoxCeleb host")
+                if head.status_code < 200 or head.status_code >= 300:
+                    raise ValueError("failed to fetch dataset")
+                save_credentials()
+                content_length = head.headers.get("Content-Length")
+                if content_length is None:
+                    raise ValueError("expected non-empty Content-Length")
+                content_length = int(content_length)
+                tmp_path = Path(path + "." + sha256(url.encode("utf-8")).hexdigest())
+                tmp_paths.append(tmp_path)
+                lengths.append(content_length)
+                start_positions.append(
+                    tmp_path.stat().st_size
+                    if tmp_path.exists() and dl_manager.download_config.resume_download
+                    else 0
+                )
+
+            def progress(q: Queue[int], cur: int, total: int):
+                with datasets.utils.logging.tqdm(
+                    unit="B",
+                    unit_scale=True,
+                    total=total,
+                    initial=cur,
+                    desc="Downloading",
+                    disable=not datasets.utils.logging.is_progress_bar_enabled(),
+                ) as progress:
+                    while cur < total:
+                        try:
+                            added = q.get(timeout=1)
+                            progress.update(added)
+                            cur += added
+                        except:
+                            continue
+
+            manager = Manager()
+            q = manager.Queue()
+            with Pool(len(sources)) as pool:
+                proc = Process(
+                    target=progress,
+                    args=(q, sum(start_positions), sum(lengths)),
+                    daemon=True,
+                )
+                proc.start()
+                pool.starmap(
+                    _mp_download,
+                    zip(
+                        sources,
+                        tmp_paths,
+                        repeat(cred_user),
+                        repeat(cred_pass),
+                        start_positions,
+                        lengths,
+                        repeat(q),
+                    ),
+                )
+                pool.close()
+                proc.join()
+            with open(path, "wb") as out:
+                for tmp_path in tmp_paths:
+                    with open(tmp_path, "rb") as tmp:
+                        copyfileobj(tmp, out)
+                    tmp_path.unlink()
+
+        metadata = dl_manager.download(
+            dict(
+                (
+                    target,
+                    f"https://mm.kaist.ac.kr/datasets/voxceleb/meta/{_DATASET_IDS[target]}_meta.csv",
+                )
+                for target in targets
+            )
+        )
+
+        mapped_paths = cast(
+            dict[str, dict[str, str]],
+            dl_manager.extract(
+                dl_manager.download_custom(
+                    dict(
+                        (
+                            placeholder_key,
+                            dict(
+                                (target, _URLS[target][placeholder_key])
+                                for target in targets
+                            ),
+                        )
+                        for placeholder_key in ("placeholder", "test")
+                    ),
+                    download_custom,
+                )
+            ),
+        )
+
+        return [
+            datasets.SplitGenerator(
+                name="validation",
+                gen_kwargs={
+                    "paths": mapped_paths["placeholder"],
+                    "meta_paths": metadata,
+                },
+            ),
+            datasets.SplitGenerator(
+                name="test",
+                gen_kwargs={
+                    "paths": mapped_paths["test"],
+                    "meta_paths": metadata,
+                },
+            ),
+        ]
+
+    def _generate_examples(self, paths: dict[str, str], meta_paths: dict[str, str]):
+        key = 0
+        for conf in paths:
+            dataset_id = "vox1" if conf == "audio1" else "vox2"
+            meta = pd.read_csv(
+                meta_paths[conf],
+                sep="\t" if conf == "audio1" else " ,",
+                index_col=0,
+                engine="python",
+            )
+            dataset_path = next(Path(paths[conf]).iterdir())
+            dataset_format = dataset_path.name
+            for speaker_path in dataset_path.iterdir():
+                speaker = speaker_path.name
+                speaker_info = meta.loc[speaker]
+                for video in speaker_path.iterdir():
+                    video_id = video.name
+                    for clip in video.iterdir():
+                        clip_index = int(clip.stem)
+                        info = {
+                            "file": str(clip),
+                            "file_format": dataset_format,
+                            "dataset_id": dataset_id,
+                            "speaker_id": speaker,
+                            "speaker_gender": speaker_info["Gender"],
+                            "video_id": video_id,
+                            "clip_index": clip_index,
+                        }
+                        if dataset_id == "vox1":
+                            info["speaker_name"] = speaker_info["VGGFace1 ID"]
+                            info["speaker_nationality"] = speaker_info["Nationality"]
+                        if conf.startswith("audio"):
+                            info["audio"] = info["file"]
+                        yield key, info
+                        key += 1