init commit

librispeech-phones-and-mel.py

@@ -0,0 +1,159 @@
+"""LibriSpeech dataset with phone alignments, prosody and mel spectrograms."""
+
+import os
+from pathlib import Path
+import hashlib
+import pickle
+
+import datasets
+import pandas as pd
+import numpy as np
+from tqdm.contrib.concurrent import process_map
+from tqdm.auto import tqdm
+from multiprocessing import cpu_count
+from PIL import Image
+
+logger = datasets.logging.get_logger(__name__)
+
+_VERSION = "0.0.1"
+
+_CITATION = """\
+@inproceedings{panayotov2015librispeech,
+  title={Librispeech: an asr corpus based on public domain audio books},
+  author={Panayotov, Vassil and Chen, Guoguo and Povey, Daniel and Khudanpur, Sanjeev},
+  booktitle={2015 IEEE international conference on acoustics, speech and signal processing (ICASSP)},
+  pages={5206--5210},
+  year={2015},
+  organization={IEEE}
+}
+"""
+
+_DESCRIPTION = """\
+Dataset containing Mel Spectrograms, Prosody and Phone Alignments for the LibriSpeech dataset.
+"""
+
+_URLS = {
+    "dev.clean": "https://huggingface.co/datasets/cdminix/librispeech-phones-and-mel/resolve/main/data/dev_clean.tar.gz",
+    "dev.other": "https://huggingface.co/datasets/cdminix/librispeech-phones-and-mel/resolve/main/data/dev_other.tar.gz",
+    "test.clean": "https://huggingface.co/datasets/cdminix/librispeech-phones-and-mel/resolve/main/data/test_clean.tar.gz",
+    "test.other": "https://huggingface.co/datasets/cdminix/librispeech-phones-and-mel/resolve/main/data/test_other.tar.gz",
+    "train.clean.100": "https://huggingface.co/datasets/cdminix/librispeech-phones-and-mel/resolve/main/data/train_clean_100.tar.gz",
+    "train.clean.360": "https://huggingface.co/datasets/cdminix/librispeech-phones-and-mel/resolve/main/data/train_clean_360.tar.gz",
+    "train.other.500": "https://huggingface.co/datasets/cdminix/librispeech-phones-and-mel/resolve/main/data/train_other_500.tar.gz",
+}
+
+
+class LibrispeechConfig(datasets.BuilderConfig):
+    """BuilderConfig for LibriTTSAlign."""
+
+    def __init__(self, **kwargs):
+        """BuilderConfig for LibriTTSAlign.
+
+        Args:
+          **kwargs: keyword arguments forwarded to super.
+        """
+        super(LibrispeechConfig, self).__init__(**kwargs)
+
+
+class Librispeech(datasets.GeneratorBasedBuilder):
+    """LibriTTSAlign dataset."""
+
+    BUILDER_CONFIGS = [
+        LibrispeechConfig(
+            name="libritts",
+            version=datasets.Version(_VERSION, ""),
+        ),
+    ]
+
+    def _info(self):
+        features = {
+            "id": datasets.Value("string"),
+            "speaker_id": datasets.Value("string"),
+            "chapter_id": datasets.Value("string"),
+            "phones": datasets.Value("string"),
+            "mel": datasets.Value("string"),
+            "prosody": datasets.Value("string"),
+            "speaker_utterance": datasets.Value("string"),
+            "mean_speaker_utterance": datasets.Value("string"),
+            "mean_speaker": datasets.Value("string"),
+        }
+
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=datasets.Features(features),
+            supervised_keys=None,
+            homepage="https://huggingface.co/datasets/cdminix/librispeech-phones-and-mel",
+            citation=_CITATION,
+            task_templates=None,
+        )
+
+    def _split_generators(self, dl_manager):
+        splits = [
+            datasets.SplitGenerator(
+                name=key,
+                gen_kwargs={"data_path": dl_manager.download_and_extract(value)},
+            )
+            for key, value in _URLS.items()
+        ]
+
+        return splits
+
+    def _df_from_path(self, path):
+        mel_path = Path(path)
+        prosody_path = Path(str(mel_path).replace("_mel.png", "_prosody.png"))
+        phones_path = Path(str(mel_path).replace("_mel.png", "_phones.npy"))
+        overall_speaker_path = Path(str(mel_path).replace("_mel.png", "_speaker.npy"))
+        temporal_speaker_path = Path(str(mel_path).replace("_mel.png", "_speaker.png"))
+        mean_speaker_path = mel_path.parent.parent / "mean_speaker.npy"
+
+        speaker_id = mel_path.parent.parent.name
+        chapter_id = mel_path.parent.name
+        _id = str(mel_path).replace("_mel.png", "")
+
+        return {
+            "id": _id,
+            "speaker_id": speaker_id,
+            "chapter_id": chapter_id,
+            "phones": phones_path,
+            "mel": mel_path,
+            "prosody": prosody_path,
+            "speaker_utterance": temporal_speaker_path,
+            "mean_speaker_utterance": overall_speaker_path,
+            "mean_speaker": mean_speaker_path,
+        }
+
+    def _df_from_paths_mp(self, paths):
+        return pd.DataFrame(
+            process_map(
+                self._df_from_path,
+                paths,
+                desc="Reading files",
+                max_workers=cpu_count(),
+                chunksize=100,
+            )
+        )
+
+    def _create_mean_speaker(self, df):
+        # Create mean speaker for each speaker
+        for _, speaker_df in df.groupby("speaker_id"):
+            if not Path(speaker_df["mean_speaker"].iloc[0]).exists():
+                mean_speaker = np.mean(
+                    np.array(
+                        [np.load(path) for path in speaker_df["mean_speaker_utterance"]]
+                    ),
+                    axis=0,
+                )
+                np.save(speaker_df["mean_speaker"].iloc[0], mean_speaker)
+
+    def _generate_examples(self, data_path):
+        """Generate examples."""
+        logger.info("⏳ Generating examples from = %s", data_path)
+
+        paths = sorted(list(Path(data_path).rglob("*_mel.png")))
+
+        df = self._df_from_paths_mp(paths)
+
+        self._create_mean_speaker(df)
+
+        for i, row in tqdm(df.iterrows(), desc="Generating examples"):
+            yield row["id"], row.to_dict()

librispeech_phones_and_mel.py

@@ -1,364 +0,0 @@
-"""LibriSpeech dataset with phone alignments, prosody and mel spectrograms."""
-
-import os
-from pathlib import Path
-import hashlib
-import pickle
-
-import datasets
-import pandas as pd
-import numpy as np
-from tqdm.contrib.concurrent import process_map
-from tqdm.auto import tqdm
-from multiprocessing import cpu_count
-
-logger = datasets.logging.get_logger(__name__)
-
-_VERSION = "0.0.1"
-
-_CITATION = """\
-
-"""
-
-_DESCRIPTION = """\
-Dataset containing Mel Spectrograms, Prosody and Phone Alignments for the LibriSpeech dataset.
-"""
-
-
-def get_speaker_prompts(speaker, hash_ds):
-    ds = hash_ds.df
-    speaker_prompts = ds[ds["speaker"] == speaker]
-    speaker_prompts = tuple(speaker_prompts["audio"])
-    return speaker_prompts
-
-
-class LibriTTSAlignConfig(datasets.BuilderConfig):
-    """BuilderConfig for LibriTTSAlign."""
-
-    def __init__(self, sampling_rate=22050, hop_length=256, win_length=1024, **kwargs):
-        """BuilderConfig for LibriTTSAlign.
-
-        Args:
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(LibriTTSAlignConfig, self).__init__(**kwargs)
-
-        self.sampling_rate = sampling_rate
-        self.hop_length = hop_length
-        self.win_length = win_length
-
-        if _PATH is None:
-            raise ValueError(
-                "Please set the environment variable LIBRITTS_PATH to point to the LibriTTS dataset directory."
-            )
-        elif _PATH == os.environ.get("HF_DATASETS_CACHE", None):
-            logger.warning(
-                "Please set the environment variable LIBRITTS_PATH to point to the LibriTTS dataset directory. Using HF_DATASETS_CACHE as a fallback."
-            )
-
-
-class LibriTTSAlign(datasets.GeneratorBasedBuilder):
-    """LibriTTSAlign dataset."""
-
-    BUILDER_CONFIGS = [
-        LibriTTSAlignConfig(
-            name="libritts",
-            version=datasets.Version(_VERSION, ""),
-        ),
-    ]
-
-    def _info(self):
-        features = {
-            "id": datasets.Value("string"),
-            "speaker": datasets.Value("string"),
-            "text": datasets.Value("string"),
-            "start": datasets.Value("float32"),
-            "end": datasets.Value("float32"),
-            # phone features
-            "phones": datasets.Sequence(datasets.Value("string")),
-            "phone_durations": datasets.Sequence(datasets.Value("int32")),
-            # audio feature
-            "audio": datasets.Value("string"),
-            "audio_speaker_prompt": datasets.Sequence(datasets.Value("string")),
-        }
-
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=datasets.Features(features),
-            supervised_keys=None,
-            homepage="https://github.com/MiniXC/MeasureCollator",
-            citation=_CITATION,
-            task_templates=None,
-        )
-
-    def _split_generators(self, dl_manager):
-        ds_dict = {}
-        for name, url in _URLS.items():
-            ds_dict[name] = self._create_alignments_ds(name, url)
-        splits = [
-            datasets.SplitGenerator(
-                name=key.replace("-", "."), gen_kwargs={"ds": self._create_data(value)}
-            )
-            for key, value in ds_dict.items()
-        ]
-        # dataframe with all data
-        data_train = self._create_data(
-            [
-                ds_dict["train-clean-100"],
-                ds_dict["train-clean-360"],
-                ds_dict["train-other-500"],
-            ]
-        )
-        data_dev = self._create_data([ds_dict["dev-clean"], ds_dict["dev-other"]])
-        data_test = self._create_data([ds_dict["test-clean"], ds_dict["test-other"]])
-        splits += [
-            datasets.SplitGenerator(
-                name="train.all",
-                gen_kwargs={
-                    "ds": data_train,
-                },
-            ),
-            datasets.SplitGenerator(
-                name="dev.all",
-                gen_kwargs={
-                    "ds": data_dev,
-                },
-            ),
-            datasets.SplitGenerator(
-                name="test.all",
-                gen_kwargs={
-                    "ds": data_test,
-                },
-            ),
-        ]
-        data_all = pd.concat([data_train, data_dev, data_test])
-        # create a new split which takes one sample from each speaker in data_all and puts it into the dev split
-        # we then remove these samples from data_all
-        speakers = data_all["speaker"].unique()
-        # seed for reproducibility
-        np.random.seed(42)
-        self.data_all = data_all
-        del data_all
-        data_dev_all = [
-            x
-            for x in process_map(
-                self._create_dev_split,
-                speakers,
-                chunksize=1000,
-                max_workers=_MAX_WORKERS,
-                desc="creating dev split",
-                tqdm_class=tqdm,
-            )
-            if x is not None
-        ]
-        data_dev_all = pd.concat(data_dev_all)
-        data_all = self.data_all
-        data_all = data_all[data_all["speaker"].isin(data_dev_all["speaker"].unique())]
-        data_all = data_all[
-            ~data_all["basename"].isin(data_dev_all["basename"].unique())
-        ]
-        del self.data_all
-        self.speaker2idxs = {}
-        self.speaker2idxs["all"] = {
-            speaker: idx
-            for idx, speaker in enumerate(
-                sorted(list(data_dev_all["speaker"].unique()))
-            )
-        }
-        self.speaker2idxs["train"] = {
-            speaker: idx
-            for idx, speaker in enumerate(sorted(list(data_train["speaker"].unique())))
-        }
-        self.speaker2idxs["dev"] = {
-            speaker: idx
-            for idx, speaker in enumerate(sorted(list(data_dev["speaker"].unique())))
-        }
-        self.speaker2idxs["test"] = {
-            speaker: idx
-            for idx, speaker in enumerate(sorted(list(data_test["speaker"].unique())))
-        }
-        splits += [
-            datasets.SplitGenerator(
-                name="train",
-                gen_kwargs={
-                    "ds": data_all,
-                },
-            ),
-            datasets.SplitGenerator(
-                name="dev",
-                gen_kwargs={
-                    "ds": data_dev_all,
-                },
-            ),
-        ]
-        self.alignments_ds = None
-        self.data = None
-        return splits
-
-    def _create_dev_split(self, speaker):
-        data_speaker = self.data_all[self.data_all["speaker"] == speaker]
-        if len(data_speaker) < 10:
-            print(f"Speaker {speaker} has only {len(data_speaker)} samples, skipping")
-            return None
-        else:
-            data_speaker = data_speaker.sample(2)
-            return data_speaker
-
-    def _create_alignments_ds(self, name, url):
-        self.empty_textgrids = 0
-        ds_hash = hashlib.md5(
-            os.path.join(_PATH, f"{name}-alignments").encode()
-        ).hexdigest()
-        pkl_path = os.path.join(_PATH, f"{ds_hash}.pkl")
-        if os.path.exists(pkl_path):
-            ds = pickle.load(open(pkl_path, "rb"))
-        else:
-            tgt_dir = os.path.join(_PATH, f"{name}-alignments")
-            src_dir = os.path.join(_PATH, f"{name}-data")
-            if os.path.exists(tgt_dir):
-                src_dir = None
-                url = None
-            if os.path.exists(src_dir):
-                url = None
-            ds = LibrittsRDataset(
-                target_directory=tgt_dir,
-                source_directory=src_dir,
-                source_url=url,
-                verbose=_VERBOSE,
-                tmp_directory=os.path.join(_PATH, f"{name}-tmp"),
-                chunk_size=1000,
-            )
-            pickle.dump(ds, open(pkl_path, "wb"))
-        return ds, ds_hash
-
-    def _create_data(self, data):
-        entries = []
-        self.phone_cache = {}
-        self.phone_converter = Converter()
-        if not isinstance(data, list):
-            data = [data]
-        hashes = [ds_hash for ds, ds_hash in data]
-        ds = [ds for ds, ds_hash in data]
-        self.ds = ds
-        del data
-        for i, ds in enumerate(ds):
-            if os.path.exists(os.path.join(_PATH, f"{hashes[i]}-entries.pkl")):
-                add_entries = pickle.load(
-                    open(os.path.join(_PATH, f"{hashes[i]}-entries.pkl"), "rb")
-                )
-            else:
-                add_entries = [
-                    entry
-                    for entry in process_map(
-                        self._create_entry,
-                        zip([i] * len(ds), np.arange(len(ds))),
-                        chunksize=10_000,
-                        max_workers=_MAX_WORKERS,
-                        desc=f"processing dataset {hashes[i]}",
-                        tqdm_class=tqdm,
-                    )
-                    if entry is not None
-                ]
-                pickle.dump(
-                    add_entries,
-                    open(os.path.join(_PATH, f"{hashes[i]}-entries.pkl"), "wb"),
-                )
-            entries += add_entries
-        if self.empty_textgrids > 0:
-            logger.warning(f"Found {self.empty_textgrids} empty textgrids")
-        del self.ds, self.phone_cache, self.phone_converter
-        df = pd.DataFrame(
-            entries,
-            columns=[
-                "phones",
-                "duration",
-                "start",
-                "end",
-                "audio",
-                "speaker",
-                "text",
-                "basename",
-            ],
-        )
-        return df
-
-    def _create_entry(self, dsi_idx):
-        dsi, idx = dsi_idx
-        item = self.ds[dsi][idx]
-        start, end = item["phones"][0][0], item["phones"][-1][1]
-
-        phones = []
-        durations = []
-
-        for i, p in enumerate(item["phones"]):
-            s, e, phone = p
-            phone.replace("ˌ", "")
-            r_phone = phone.replace("0", "").replace("1", "")
-            if len(r_phone) > 0:
-                phone = r_phone
-            if "[" not in phone:
-                o_phone = phone
-                if o_phone not in self.phone_cache:
-                    phone = self.phone_converter(phone, _PHONESET, lang=None)[0]
-                    self.phone_cache[o_phone] = phone
-                phone = self.phone_cache[o_phone]
-            phones.append(phone)
-            durations.append(
-                int(
-                    np.round(e * self.config.sampling_rate / self.config.hop_length)
-                    - np.round(s * self.config.sampling_rate / self.config.hop_length)
-                )
-            )
-
-        if start >= end:
-            self.empty_textgrids += 1
-            return None
-
-        return (
-            phones,
-            durations,
-            start,
-            end,
-            item["wav"],
-            str(item["speaker"]).split("/")[-1],
-            item["transcript"],
-            Path(item["wav"]).name,
-        )
-
-    def _generate_examples(self, ds):
-        j = 0
-        hash_col = "audio"
-        hash_ds = HashableDataFrame(ds, hash_col)
-        for i, row in ds.iterrows():
-            # 10kB is the minimum size of a wav file for our purposes
-            if Path(row["audio"]).stat().st_size >= 10_000:
-                if len(row["phones"]) < 384:
-                    speaker_prompts = get_speaker_prompts(row["speaker"], hash_ds)
-                    result = {
-                        "id": row["basename"],
-                        "speaker": row["speaker"],
-                        "text": row["text"],
-                        "start": row["start"],
-                        "end": row["end"],
-                        "phones": row["phones"],
-                        "phone_durations": row["duration"],
-                        "audio": str(row["audio"]),
-                        "audio_speaker_prompt": speaker_prompts,
-                    }
-                    yield j, result
-                    j += 1
-
-
-class HashableDataFrame:
-    def __init__(self, df, hash_col):
-        self.df = df
-        self.hash_col = hash_col
-        self.hash = hashlib.md5(self.df[self.hash_col].values).hexdigest()
-        # to integer
-        self.hash = int(self.hash, 16)
-
-    def __hash__(self):
-        return self.hash
-
-    def __eq__(self, other):
-        return self.hash == other.hash