Delete scripts

scripts/.env.example

@@ -1,3 +0,0 @@
-R2_ACCOUNT_ID=
-R2_ACCESS_KEY_ID=
-R2_SECRET_ACCESS_KEY=

scripts/noise.py

@@ -1,81 +0,0 @@
-import os
-import sys
-from pathlib import Path
-
-import boto3
-from datasets import Audio, Dataset, IterableDataset, load_from_disk
-from dotenv import load_dotenv
-
-
-def download():
-    load_dotenv()
-
-    ACCOUNT_ID = os.getenv("R2_ACCOUNT_ID")
-    ACCESS_KEY_ID = os.getenv("R2_ACCESS_KEY_ID")
-    SECRET_ACCESS_KEY = os.getenv("R2_SECRET_ACCESS_KEY")
-
-    s3_client = boto3.client(
-        "s3",
-        endpoint_url=f"https://{ACCOUNT_ID}.r2.cloudflarestorage.com",
-        aws_access_key_id=ACCESS_KEY_ID,
-        aws_secret_access_key=SECRET_ACCESS_KEY,
-        region_name="auto",
-    )
-
-    paginator = s3_client.get_paginator("list_objects_v2")
-    pages = paginator.paginate(Bucket="musan-noise")
-
-    file_count = 0
-
-    os.makedirs("musan_noise", exist_ok=True)
-    for page in pages:
-        if "Contents" not in page:
-            return
-
-        for obj in page["Contents"]:
-            key = obj["Key"]
-
-            if key.endswith("/"):
-                continue
-
-            local_file_path = os.path.join("musan_noise", key)
-
-            s3_client.download_file("musan-noise", key, local_file_path)
-            file_count += 1
-
-    print(f"File count: {file_count}")
-
-
-def create_dataset():
-    files = []
-    for wav in Path("musan_noise").glob("*.wav"):
-        files.append(str(wav))
-
-    dataset = Dataset.from_dict({"audio": files})
-    dataset = dataset.cast_column("audio", Audio(sampling_rate=16000, num_channels=1))
-
-    dataset.save_to_disk("musan_noise_dataset")
-
-
-def test():
-    dataset = load_from_disk("musan_noise_dataset")
-    assert isinstance(dataset, Dataset)
-    dataset = dataset.to_iterable_dataset()
-    assert isinstance(dataset, IterableDataset)
-
-    count = 0
-    for row in dataset:
-        count += 1
-
-    print(count)
-
-
-if __name__ == "__main__":
-    arg = sys.argv[1]
-    match arg:
-        case "download":
-            download()
-        case "dataset":
-            create_dataset()
-        case "test":
-            test()

scripts/noizeus.py

@@ -1,84 +0,0 @@
-import os
-import shutil
-import sys
-import zipfile
-from itertools import product
-from pathlib import Path
-
-import requests
-from tqdm import tqdm
-from datasets import IterableDataset, Dataset, Audio, load_from_disk
-
-
-def download():
-    os.makedirs("noizeus/zips", exist_ok=True)
-    base = "https://ecs.utdallas.edu/loizou/speech/noizeus/"
-    noises = [
-        "train",
-        "babble",
-        "exhibition",
-        "restaurant",
-        "street",
-        "airport",
-        "station",
-    ]
-    snrs = ["_0dB", "_5dB", "_10dB"]
-
-    for noise, snr in tqdm(product(noises, snrs)):
-        name = f"{noise}{snr}"
-        url = f"{base}{name}.zip"
-        res = requests.get(url)
-        with open(f"noizeus/zips/{name}.zip", "wb") as f:
-            f.write(res.content)
-
-        with zipfile.ZipFile(f"noizeus/zips/{name}.zip", "r") as zip_ref:
-            zip_ref.extractall(f"noizeus/{name}")
-
-        os.remove(f"noizeus/zips/{name}.zip")
-
-        nested_dir = f"noizeus/{name}/{snr.replace('_', '')}"
-        if os.path.exists(nested_dir):
-            for filename in os.listdir(nested_dir):
-                shutil.move(
-                    os.path.join(nested_dir, filename), f"noizeus/{name}/{filename}"
-                )
-            os.rmdir(nested_dir)
-
-    os.rmdir("noizeus/zips")
-
-
-def create_dataset():
-    files = []
-    for dir in Path("noizeus").iterdir():
-        if dir.is_dir():
-            for wav in dir.glob("*.wav"):
-                files.append(str(wav))
-
-    dataset = Dataset.from_dict({"audio": files})
-    dataset = dataset.cast_column("audio", Audio(sampling_rate=16000, num_channels=1))
-
-    dataset.save_to_disk("noizeus_dataset")
-
-
-def test():
-    dataset = load_from_disk("noizeus_dataset")
-    assert isinstance(dataset, Dataset)
-    dataset = dataset.to_iterable_dataset()
-    assert isinstance(dataset, IterableDataset)
-
-    count = 0
-    for row in dataset:
-        count += 1
-
-    print(count)
-
-
-if __name__ == "__main__":
-    arg = sys.argv[1]
-    match arg:
-        case "download":
-            download()
-        case "dataset":
-            create_dataset()
-        case "test":
-            test()

scripts/process.py

@@ -1,514 +0,0 @@
-import io
-import jsonlines
-import os
-import sys
-import time
-
-import soundfile as sf
-from datasets import Audio, Dataset, IterableDataset, load_dataset, load_from_disk
-from pydub import AudioSegment, silence
-from silero_vad import get_speech_timestamps, load_silero_vad
-from torchcodec.decoders import AudioDecoder
-from tqdm import tqdm
-
-RAND_SEED = 381
-DATA_DIR = "data"
-
-NAMES = [
-    "clean",
-    "noisy",
-    "noisyenv",
-    "noise",
-    "jazz",
-    "country",
-    "folk",
-    "pop",
-    "rock",
-    "electronic",
-    "instrumental",
-    "vocal1",
-    "vocal2",
-    "vocal3",
-]
-
-sr = 16000
-fl = 20 * sr // 1000
-fh = 10 * sr // 1000
-
-
-class Silence:
-    def __init__(self): ...
-
-    def label(
-        self, x: AudioDecoder | dict[str, str | bytes], _
-    ) -> list[dict[str, dict[str, int]]]:
-        if isinstance(x, AudioDecoder):
-            siglen = int(x.get_all_samples().duration_seconds * 1000)
-        else:
-            if x["bytes"] is not None:
-                seg = AudioSegment.from_file(io.BytesIO(x["bytes"]))
-            else:
-                seg = AudioSegment.from_file(x["path"])
-
-            siglen = len(seg)
-
-        return [{"inactive": {"start": 0, "end": siglen}}]
-
-
-class VAD:
-    def __init__(self):
-        self.model = load_silero_vad()
-
-    def label(
-        self, decoder: AudioDecoder | dict[str, str | bytes], _
-    ) -> list[dict[str, dict[str, int]]]:
-        def stoms(sample: int) -> int:
-            # sample to ms
-            global sr
-            return int(sample * 1000 / sr)
-
-        assert isinstance(decoder, AudioDecoder)
-
-        x = decoder.get_all_samples()
-
-        stamps: list[dict[str, int]] = get_speech_timestamps(x.data, self.model)
-
-        if not stamps:
-            return [{"inactive": {"start": 0, "end": len(x.data)}}]
-
-        labels: list[dict[str, dict[str, int]]] = []
-        prev_end = 0
-
-        for stamp in stamps:
-            if stamp["start"] > prev_end:
-                labels.append(
-                    {
-                        "inactive": {
-                            "start": stoms(prev_end),
-                            "end": stoms(stamp["start"]),
-                        }
-                    }
-                )
-
-            labels.append(
-                {"speech": {"start": stoms(stamp["start"]), "end": stoms(stamp["end"])}}
-            )
-            prev_end = stamp["end"]
-
-        if prev_end < len(x.data):
-            labels.append(
-                {"inactive": {"start": stoms(prev_end), "end": stoms(len(x.data))}}
-            )
-
-        return labels
-
-
-class MusicSilenceDetector:
-    def __init__(self): ...
-
-    def label(
-        self, x: AudioDecoder | dict[str, str | bytes], thr: int
-    ) -> list[dict[str, dict[str, int]]]:
-        assert isinstance(x, dict)
-        labels: list[dict[str, dict[str, int]]] = []
-
-        if x["bytes"] is not None:
-            seg = AudioSegment.from_file(io.BytesIO(x["bytes"]))
-        else:
-            seg = AudioSegment.from_file(x["path"])
-
-        sil_stamps: list[list[int]] = silence.detect_silence(
-            seg, min_silence_len=260, silence_thresh=thr
-        )  # min_silence_len is in ms
-
-        if not sil_stamps:
-            return [{"music": {"start": 0, "end": len(seg)}}]
-
-        prev_end = 0
-
-        for stamp in sil_stamps:
-            if stamp[0] > prev_end:
-                labels.append(
-                    {
-                        "music": {
-                            "start": prev_end,
-                            "end": stamp[0],
-                        }
-                    }
-                )
-
-            labels.append({"inactive": {"start": stamp[0], "end": stamp[1]}})
-            prev_end = stamp[1]
-
-        if prev_end < len(seg):
-            labels.append({"music": {"start": prev_end, "end": len(seg)}})
-
-        return labels
-
-
-def process_file(
-    audio: AudioDecoder | dict[str, str | bytes],
-    silence_detector: VAD | MusicSilenceDetector | Silence,
-    split: str,
-    idx: int,
-    name: str,
-    sil_thr: int = -16,
-) -> tuple[bool, list[dict[str, dict[str, int]]]]:
-    labels = silence_detector.label(audio, sil_thr)
-
-    file_name = f"{DATA_DIR}/{split}/{name}_{idx:04d}.wav"
-    if os.path.exists(file_name):
-        return (False, labels)
-
-    if isinstance(audio, AudioDecoder):
-        audio_data = audio.get_all_samples().data
-        if hasattr(audio_data, "cpu"):
-            audio_data = audio_data.cpu()
-        audio_data = audio_data.numpy().squeeze()
-
-        sf.write(
-            file_name,
-            audio_data,
-            samplerate=sr,
-        )
-    else:
-        seg = AudioSegment.from_file(io.BytesIO(audio["bytes"]))
-        seg.export(file_name, format="wav")
-
-    return (True, labels)
-
-
-class Meta:
-    def __init__(self, _name, _split: str):
-        self.split = _split
-        self.name = _name
-        _dir = f"partial/{self.name}"
-        os.makedirs(_dir, exist_ok=True)
-        self.path = f"{_dir}/{self.split}.jsonl"
-        self.file = jsonlines.open(self.path, mode="w")
-        self.idx = 0
-
-    def __del__(self):
-        self.file.close()
-
-    def write(
-        self, _class: str, subclass: str, labels: list[dict[str, dict[str, int]]]
-    ):
-        self.file.write(
-            {
-                "file_name": f"{self.name}_{self.idx:04d}.wav",
-                "class": _class,
-                "subclass": subclass,
-                "labels": labels,
-            }
-        )
-        self.idx += 1
-
-
-def process_dataset(
-    dataset: IterableDataset,
-    silence_detector: VAD | MusicSilenceDetector | Silence,
-    _class: str,
-    subclass: str,
-    dataset_len: int,
-    name: str,
-    sil_thr: int = -16,
-):
-    print(f"Start processing {name}...")
-    train_end = int(0.8 * dataset_len)
-    val_end = int(0.9 * dataset_len)
-    splits = [
-        (dataset.take(train_end), Meta(name, "train")),
-        (dataset.skip(train_end).take(val_end - train_end), Meta(name, "val")),
-        (dataset.skip(val_end), Meta(name, "test")),
-    ]
-
-    for split, meta in splits:
-        for row in tqdm(split, desc=f"{name} - {meta.split}"):
-            new, labels = process_file(
-                row["audio"], silence_detector, meta.split, meta.idx, name, sil_thr
-            )
-            meta.write(_class, subclass, labels)
-
-    print("Finished\n")
-
-
-def combine_metas():
-    for split in ["train", "val", "test"]:
-        with jsonlines.open(f"{DATA_DIR}/{split}/metadata.jsonl", mode="w") as meta:
-            for name in NAMES:
-                try:
-                    with jsonlines.open(f"partial/{name}/{split}.jsonl") as part:
-                        for line in part:
-                            meta.write(line)
-                except FileNotFoundError:
-                    if split == "train":
-                        print(f"{name} not downloaded")
-
-
-def main():
-    for dir in [
-        f"{DATA_DIR}/train",
-        f"{DATA_DIR}/val",
-        f"{DATA_DIR}/test",
-    ]:
-        os.makedirs(dir, exist_ok=True)
-
-    vad = VAD()
-    msd = MusicSilenceDetector()
-    sil = Silence()
-
-    match sys.argv[1]:
-        case "clean":
-            print("Downloading clean")
-            clean = load_dataset(
-                "ammagra/english-arabic-speech-translation",
-                split="test",
-                streaming=True,
-            )
-            assert isinstance(clean, IterableDataset)
-            clean = (
-                clean.shuffle(seed=RAND_SEED)
-                .select_columns("audio")
-                .take(2000)
-                .cast_column("audio", Audio(sampling_rate=sr, num_channels=1))
-            )
-            process_dataset(clean, vad, "speech", "speech_clean", 2000, "clean")
-        case "noisy":
-            print("Downloading noisy")
-            noisy = load_dataset(
-                "Jzuluaga/atco2_corpus_1h", split="test", streaming=True
-            )
-            assert isinstance(noisy, IterableDataset)
-            noisy = (
-                noisy.shuffle(seed=RAND_SEED)
-                .select_columns("audio")
-                .cast_column("audio", Audio(sampling_rate=sr, num_channels=1))
-            )
-            process_dataset(noisy, vad, "speech", "speech_noisy", 871, "noisy")
-
-        case "noisyenv":
-            print("Downloading noisyenv")
-            noisy_env = load_from_disk("noizeus_dataset")
-            assert isinstance(noisy_env, Dataset)
-            noisy_env = noisy_env.to_iterable_dataset()
-            assert isinstance(noisy_env, IterableDataset)
-            noisy_env = (
-                noisy_env.shuffle(seed=RAND_SEED)
-                .select_columns("audio")
-                .cast_column("audio", Audio(sampling_rate=sr, num_channels=1))
-            )
-            process_dataset(
-                noisy_env, vad, "speech", "speech_noisyenv", 630, "noisyenv"
-            )
-
-        case "jazz":
-            print("Downloading jazz")
-
-            jazz = load_dataset(
-                "PlutoG99001/MusicGen-Jazz-Clean", split="train", streaming=True
-            )
-            assert isinstance(jazz, IterableDataset)
-            jazz = (
-                jazz.shuffle(seed=RAND_SEED)
-                .select_columns("audio")
-                .cast_column(
-                    "audio", Audio(sampling_rate=sr, num_channels=1, decode=False)
-                )
-            )
-            process_dataset(
-                jazz, msd, "music", "music_acoustic", 50, "jazz", sil_thr=-20
-            )
-
-        case "country":
-            print("Downloading country")
-
-            country = load_dataset(
-                "ylacombe/music_genres_Country", split="train", streaming=True
-            )
-            assert isinstance(country, IterableDataset)
-            country = (
-                country.shuffle(seed=RAND_SEED)
-                .select_columns("audio")
-                .cast_column(
-                    "audio", Audio(sampling_rate=sr, num_channels=1, decode=False)
-                )
-            )
-            process_dataset(
-                country, msd, "music", "music_acoustic", 142, "country", sil_thr=-25
-            )
-
-        case "folk":
-            print("Downloading folk")
-            folk = load_dataset("lewtun/music_genres", split="train", streaming=True)
-            assert isinstance(folk, IterableDataset)
-            folk = (
-                folk.shuffle(seed=RAND_SEED)
-                .select_columns(["audio", "genre"])
-                .filter(lambda row: row["genre"] == "Folk")
-                .take(1000)
-                .cast_column(
-                    "audio", Audio(sampling_rate=sr, num_channels=1, decode=False)
-                )
-            )
-            process_dataset(
-                folk, msd, "music", "music_acoustic", 1000, "folk", sil_thr=-33
-            )
-
-        case "pop":
-            print("Downloading pop")
-
-            pop = load_dataset(
-                "memepottaboah/POPMUSIC1981", split="train", streaming=True
-            )
-            assert isinstance(pop, IterableDataset)
-            pop = (
-                pop.shuffle(seed=RAND_SEED)
-                .select_columns("audio")
-                .cast_column(
-                    "audio", Audio(sampling_rate=sr, num_channels=1, decode=False)
-                )
-            )
-            process_dataset(
-                pop, msd, "music", "music_mainstream", 268, "pop", sil_thr=-22
-            )
-
-        case "rock":
-            print("Downloading rock")
-            rock = load_dataset("lewtun/music_genres", split="train", streaming=True)
-            assert isinstance(rock, IterableDataset)
-            rock = (
-                rock.shuffle(seed=RAND_SEED)
-                .select_columns(["audio", "genre"])
-                .filter(lambda row: row["genre"] == "Rock")
-                .take(2000)
-                .cast_column(
-                    "audio", Audio(sampling_rate=sr, num_channels=1, decode=False)
-                )
-            )
-            process_dataset(
-                rock, msd, "music", "music_mainstream", 2000, "rock", sil_thr=-30
-            )
-
-        case "electronic":
-            print("Downloading electronic")
-
-            electronic = load_dataset(
-                "PlutoG99001/MusicGen-Electronic-Clean", split="train", streaming=True
-            )
-            assert isinstance(electronic, IterableDataset)
-            electronic = (
-                electronic.shuffle(seed=RAND_SEED)
-                .select_columns("audio")
-                .cast_column(
-                    "audio", Audio(sampling_rate=sr, num_channels=1, decode=False)
-                )
-            )
-            process_dataset(
-                electronic,
-                msd,
-                "music",
-                "music_electronic",
-                52,
-                "electronic",
-                sil_thr=-25,
-            )
-
-        case "instrumental":
-            print("Downloading instrumental")
-            instrumental = load_dataset(
-                "PlutoG99001/MusicGen-Classical", split="train", streaming=True
-            )
-            assert isinstance(instrumental, IterableDataset)
-            instrumental = (
-                instrumental.shuffle(seed=RAND_SEED)
-                .select_columns("audio")
-                .cast_column(
-                    "audio", Audio(sampling_rate=sr, num_channels=1, decode=False)
-                )
-            )
-            process_dataset(
-                instrumental,
-                msd,
-                "music",
-                "music_instrumental",
-                495,
-                "instrumental",
-                sil_thr=-27,
-            )
-
-        case "vocal1":
-            print("Downloading vocal1")
-
-            vocal1 = load_dataset(
-                "ccmusic-database/acapella", split="song1", streaming=True
-            )
-            assert isinstance(vocal1, IterableDataset)
-            vocal1 = (
-                vocal1.shuffle(seed=RAND_SEED)
-                .select_columns("audio")
-                .cast_column(
-                    "audio", Audio(sampling_rate=sr, num_channels=1, decode=False)
-                )
-            )
-            process_dataset(
-                vocal1, msd, "music", "music_vocal", 22, "vocal1", sil_thr=-48
-            )
-
-        case "vocal2":
-            print("Downloading vocal2")
-
-            vocal2 = load_dataset(
-                "ccmusic-database/acapella", split="song2", streaming=True
-            )
-            assert isinstance(vocal2, IterableDataset)
-            vocal2 = (
-                vocal2.shuffle(seed=RAND_SEED)
-                .select_columns("audio")
-                .cast_column(
-                    "audio", Audio(sampling_rate=sr, num_channels=1, decode=False)
-                )
-            )
-            process_dataset(
-                vocal2, msd, "music", "music_vocal", 22, "vocal2", sil_thr=-48
-            )
-
-        case "vocal3":
-            print("Downloading vocal3")
-
-            vocal3 = load_dataset(
-                "ccmusic-database/acapella", split="song3", streaming=True
-            )
-            assert isinstance(vocal3, IterableDataset)
-            vocal3 = (
-                vocal3.shuffle(seed=RAND_SEED)
-                .select_columns("audio")
-                .cast_column(
-                    "audio", Audio(sampling_rate=sr, num_channels=1, decode=False)
-                )
-            )
-            process_dataset(
-                vocal3, msd, "music", "music_vocal", 22, "vocal3", sil_thr=-48
-            )
-
-        case "noise":
-            print("Downloading noise")
-
-            noise = load_from_disk("musan_noise_dataset")
-            assert isinstance(noise, Dataset)
-            noise = noise.to_iterable_dataset()
-            assert isinstance(noise, IterableDataset)
-            noise = (
-                noise.shuffle(seed=RAND_SEED)
-                .select_columns("audio")
-                .cast_column("audio", Audio(sampling_rate=sr, num_channels=1))
-            )
-            process_dataset(noise, sil, "noise", "noise", 169, "noise")
-
-        case "combine":
-            combine_metas()
-
-
-if __name__ == "__main__":
-    main()
-    time.sleep(1)

scripts/pyproject.toml

@@ -1,23 +0,0 @@
-[project]
-name = "dataset"
-version = "0.1.0"
-description = "Add your description here"
-readme = "README.md"
-requires-python = ">=3.12"
-dependencies = [
-    "boto3>=1.40.74",
-    "datasets>=4.4.1",
-    "dotenv>=0.9.9",
-    "jsonlines>=4.0.0",
-    "librosa>=0.11.0",
-    "numpy>=2.3.4",
-    "pyarrow>=22.0.0",
-    "pydub>=0.25.1",
-    "ruff>=0.14.4",
-    "silero-vad>=6.2.0",
-    "soundfile>=0.13.1",
-    "torchaudio>=2.9.0",
-    "tqdm>=4.67.1",
-    "ty>=0.0.1a26",
-    "webrtcvad>=2.0.10",
-]

scripts/test.py

@@ -1,35 +0,0 @@
-import sys
-import os
-import jsonlines
-from pydub import AudioSegment, silence
-
-os.makedirs("test", exist_ok=True)
-
-split = sys.argv[1]
-subclass = sys.argv[2]
-idx = int(sys.argv[3])
-file = f"data/{split}/{subclass}_{idx:04d}.wav"
-meta = f"partial/{subclass}/{split}.jsonl"
-
-with jsonlines.open(meta) as r:
-    for i, obj in enumerate(r):
-        if i == idx:
-            labels = obj["labels"]
-            break
-
-
-orig = AudioSegment.from_file(file)
-
-segments = silence.split_on_silence(
-    orig,
-    min_silence_len=260,
-    silence_thresh=int(sys.argv[4]),
-    keep_silence=False,
-)
-
-nonsilent = AudioSegment.empty()
-for seg in segments:
-    nonsilent += seg
-
-orig.export("test/orig.wav", format="wav")
-nonsilent.export("test/nonsilent.wav", format="wav")

scripts/thrs.csv

@@ -1,11 +0,0 @@
-subclass,thr
-country,-25
-electronic,-25
-folk,-33
-instrumental,-27
-jazz,-20
-pop,-22
-rock,-30
-vocal1,-48
-vocal2,-48
-vocal3,-48