add metadata

Multidialog.py

@@ -0,0 +1,242 @@
+# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
+#
+# 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.
+
+import csv
+import os
+import json 
+import datasets
+
+_CITATION = """\
+"""
+
+_DESCRIPTION = """\
+Multidialog is the first large-sccale multimodal (i.e. audio, visual, and text) dialogue corpus, consisting of approximately 400 hours of audio-visual conversation strems between 6 pairs of conversation partners. 
+
+It contina
+"""
+
+_HOMEPAGE = "https://multidialog.github.io/"
+
+_LICENSE = "Apache License 2.0"
+
+_BASE_DATA_URL = "https://huggingface.co/datasets/IVLLab/MultiDialog/resolve/main/"
+
+_AUDIO_ARCHIVE_URL = _BASE_DATA_URL + "{subset}/{subset}_chunks_{archive_id:04}.tar.gz"
+
+_META_URL = _BASE_DATA_URL + "metadata/{subset}_metadata_{archive_id:04}.jsonl"
+
+
+logger = datasets.utils.logging.get_logger(__name__)
+
+
+class MultidialogConfig(datasets.BuilderConfig):
+    """BuilderConfig for Multidialog."""
+
+    def __init__(self, name, *args, **kwargs):
+        """BuilderConfig for Multidialog
+        """
+        super().__init__(name=name, *args, **kwargs)
+        self.subsets_to_download = (name,)
+
+
+class Multidialog(datasets.GeneratorBasedBuilder):
+    """
+    """
+
+    VERSION = datasets.Version("1.0.0")
+
+    BUILDER_CONFIGS = [MultidialogConfig(name=subset) for subset in ["train", "test_freq", "test_rare", "valid_freq", "valid_rare"]]
+
+    DEFAULT_WRITER_BATCH_SIZE = 128
+
+    def _info(self):
+        features = datasets.Features(
+            {
+                "file_name": datasets.Value("string"),
+                "conv_id": datasets.Value("string"),
+                "utterance_id": datasets.Value("float32"),
+                "audio": datasets.Audio(sampling_rate=16_000),
+                "from": datasets.Value("string"),
+                "value": datasets.Value("string"),
+                "emotion": datasets.Value("string"),
+                "original_full_path": datasets.Value("string"),  # relative path to full audio in original data dirs
+            }
+        )
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=features,
+            homepage=_HOMEPAGE,
+            license=_LICENSE,
+            citation=_CITATION,
+        )
+
+    def _read_n_archives(self, n_archives_path):
+        with open(n_archives_path, encoding="utf-8") as f:
+            return int(f.read().strip())
+
+    def _split_generators(self, dl_manager):
+        splits = ("train", "test_freq", "test_rare", "valid_freq", "valid_rare")
+
+        n_archives = {
+            "train" : [15, 4], 
+            "test_freq": [1, 1], 
+            "test_rare": [1, 1],
+            "valid_freq": [1, 1], 
+            "valid_rare": [1, 1], 
+        }
+
+        # 2. prepare sharded archives with audio files
+        audio_archives_urls = {
+            split: [
+                    _AUDIO_ARCHIVE_URL.format(subset=split, archive_id=i)
+                    for i in range(n_archives[split][0])
+                ]
+            for split in splits
+        }
+        audio_archives_paths = dl_manager.download(audio_archives_urls)
+        # flatten archives paths from
+        # {"train": {"xs": [path1, path2,], "s": [path3], "m": [path5, path5]}, "dev": {"dev": [path6,...]}, "test": {"test": [...]}}
+        # to {"train": [path1, path2, path3, path4, path5], "dev": [path6, ...], "test": [...]}
+        audio_archives_paths = _flatten_nested_dict(audio_archives_paths)
+        local_audio_archives_paths = dl_manager.extract(audio_archives_paths) if not dl_manager.is_streaming \
+            else None
+
+        # 3. prepare sharded metadata csv files
+        meta_urls = {
+            split: [
+                    _META_URL.format(subset=split, archiv_id=i)
+                    for i in range(n_archives[split][1])
+                ]
+            for split in splits
+        }
+        meta_paths = dl_manager.download_and_extract(meta_urls)
+        meta_paths = _flatten_nested_dict(meta_paths)
+
+        if self.config.name == "test_freq":
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TEST,
+                    gen_kwargs={
+                        "audio_archives_iterators": [
+                            dl_manager.iter_archive(archive_path) for archive_path in audio_archives_paths["test_freq"]
+                        ],
+                        "local_audio_archives_paths": local_audio_archives_paths[
+                            "test_freq"] if local_audio_archives_paths else None,
+                        "meta_paths": meta_paths["test_freq"]
+                    },
+                ),
+            ]
+        
+        if self.config.name == "test_rare":
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TEST,
+                    gen_kwargs={
+                        "audio_archives_iterators": [
+                            dl_manager.iter_archive(archive_path) for archive_path in audio_archives_paths["test_rare"]
+                        ],
+                        "local_audio_archives_paths": local_audio_archives_paths[
+                            "test_rare"] if local_audio_archives_paths else None,
+                        "meta_paths": meta_paths["test_rare"]
+                    },
+                ),
+            ]    
+            
+        if self.config.name == "valid_freq":
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.VALIDATION,
+                    gen_kwargs={
+                        "audio_archives_iterators": [
+                            dl_manager.iter_archive(archive_path) for archive_path in audio_archives_paths["valid_freq"]
+                        ],
+                        "local_audio_archives_paths": local_audio_archives_paths[
+                            "valid_freq"] if local_audio_archives_paths else None,
+                        "meta_paths": meta_paths["valid_freq"]
+                    },
+                ),
+            ]    
+            
+        if self.config.name == "valid_rare":
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.VALIDATION,
+                    gen_kwargs={
+                        "audio_archives_iterators": [
+                            dl_manager.iter_archive(archive_path) for archive_path in audio_archives_paths["valid_rare"]
+                        ],
+                        "local_audio_archives_paths": local_audio_archives_paths[
+                            "valid_rare"] if local_audio_archives_paths else None,
+                        "meta_paths": meta_paths["valid_rare"]
+                    },
+                ),
+            ]   
+
+        if self.config.name == "train":
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TRAIN,
+                    gen_kwargs={
+                        "audio_archives_iterators": [
+                            dl_manager.iter_archive(archive_path) for archive_path in audio_archives_paths["train"]
+                        ],
+                        "local_audio_archives_paths": local_audio_archives_paths[
+                            "train"] if local_audio_archives_paths else None,
+                        "meta_paths": meta_paths["train"]
+                    },
+                ),
+            ]
+
+    def _generate_examples(self, audio_archives_iterators, local_audio_archives_paths, meta_paths):
+        assert len(audio_archives_iterators) == len(meta_paths)
+        if local_audio_archives_paths:
+            assert len(audio_archives_iterators) == len(local_audio_archives_paths)
+
+        for i, (meta_path, audio_archive_iterator) in enumerate(zip(meta_paths, audio_archives_iterators)):
+            meta_dict = dict()
+            with open(meta_path) as jsonl_file:
+                for line in jsonl_file:
+                    meta_dict[os.path.filename(line["audpath"])[:-4]] = line
+                #     data = json.loads(line.strip())
+                # meta_csv = csv.DictReader(csvfile)
+                # for line in meta_csv:
+                    
+
+            for audio_path_in_archive, audio_file in audio_archive_iterator:
+                # `audio_path_in_archive` is like "dev_chunks_0000/YOU1000000029_S0000095.wav"
+                audio_filename = os.path.split(audio_path_in_archive)[1]
+                audio_id = audio_filename.split(".wav")[0]
+                audio_meta = meta_dict[audio_id]
+                audio_meta["conv_id"] = audio_meta.pop("conv_id")
+                audio_meta["utterance_id"] = audio_meta.pop("utterance_id")
+                audio_meta["from"] = audio_meta.pop("from")
+                audio_meta["value"] = audio_meta.pop("value")
+                audio_meta["emotion"] = audio_meta.pop("emotion")
+                audio_meta["original_full_path"] = audio_meta.pop("audpath")
+                audio_meta["audio_id"] = audio_id
+
+                path = os.path.join(local_audio_archives_paths[i], audio_path_in_archive) if local_audio_archives_paths \
+                    else audio_path_in_archive
+
+                yield audio_id, {
+                    "audio": {"path": path , "bytes": audio_file.read()},
+                    **{feature: value for feature, value in audio_meta.items() if feature in self.info.features}
+                }
+
+
+def _flatten_nested_dict(nested_dict):
+    return {
+        key: [inner_list_element for inner_list in value_to_lists.values() for inner_list_element in inner_list]
+        for key, value_to_lists in nested_dict.items()
+    }