Add Music4All HF dataset build script

build_hf_dataset.py

@@ -0,0 +1,272 @@
+#!/usr/bin/env python3
+"""Convert Music4All raw files into a Hugging Face Dataset."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional
+
+from datasets import Audio, Dataset, DatasetDict, Features, Sequence, Value
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Build a Hugging Face dataset from Music4All raw files."
+    )
+    parser.add_argument(
+        "--data-dir",
+        type=Path,
+        default=Path("."),
+        help="Folder containing id_*.csv, audios/, and lyrics/.",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=Path("hf_music4all"),
+        help="Output directory for DatasetDict.save_to_disk().",
+    )
+    parser.add_argument(
+        "--val-size",
+        type=float,
+        default=0.0,
+        help="Validation split size as a fraction of total dataset, e.g. 0.05.",
+    )
+    parser.add_argument(
+        "--test-size",
+        type=float,
+        default=0.0,
+        help="Test split size as a fraction of total dataset, e.g. 0.1.",
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=42,
+        help="Random seed used for split generation.",
+    )
+    parser.add_argument(
+        "--max-rows",
+        type=int,
+        default=None,
+        help="Optional cap for quick debugging.",
+    )
+    parser.add_argument(
+        "--no-audio",
+        action="store_true",
+        help="Do not include the audio column.",
+    )
+    parser.add_argument(
+        "--no-lyrics",
+        action="store_true",
+        help="Do not include the lyrics column.",
+    )
+    parser.add_argument(
+        "--strict",
+        action="store_true",
+        help="Fail if required metadata rows are missing for an id.",
+    )
+    return parser.parse_args()
+
+
+def read_tsv_to_map(path: Path) -> Dict[str, Dict[str, str]]:
+    with path.open("r", encoding="utf-8", newline="") as f:
+        reader = csv.DictReader(f, delimiter="\t")
+        table: Dict[str, Dict[str, str]] = {}
+        for row in reader:
+            song_id = row.pop("id")
+            table[song_id] = row
+    return table
+
+
+def parse_csv_list(raw: str) -> List[str]:
+    if not raw:
+        return []
+    return [item.strip() for item in raw.split(",") if item.strip()]
+
+
+def maybe_float(raw: Optional[str]) -> Optional[float]:
+    if raw is None or raw == "":
+        return None
+    return float(raw)
+
+
+def maybe_int(raw: Optional[str]) -> Optional[int]:
+    if raw is None or raw == "":
+        return None
+    return int(float(raw))
+
+
+def read_text_if_exists(path: Path) -> Optional[str]:
+    if not path.exists():
+        return None
+    return path.read_text(encoding="utf-8")
+
+
+def iter_examples(
+    data_dir: Path,
+    include_audio: bool,
+    include_lyrics: bool,
+    strict: bool,
+    max_rows: Optional[int],
+) -> Iterable[Dict[str, object]]:
+    metadata = read_tsv_to_map(data_dir / "id_metadata.csv")
+    genres = read_tsv_to_map(data_dir / "id_genres.csv")
+    tags = read_tsv_to_map(data_dir / "id_tags.csv")
+    langs = read_tsv_to_map(data_dir / "id_lang.csv")
+
+    info_path = data_dir / "id_information.csv"
+    with info_path.open("r", encoding="utf-8", newline="") as f:
+        reader = csv.DictReader(f, delimiter="\t")
+        for idx, info in enumerate(reader):
+            if max_rows is not None and idx >= max_rows:
+                return
+
+            song_id = info["id"]
+            meta = metadata.get(song_id)
+            genre_row = genres.get(song_id)
+            tag_row = tags.get(song_id)
+            lang_row = langs.get(song_id)
+
+            if strict and (
+                meta is None or genre_row is None or tag_row is None or lang_row is None
+            ):
+                raise KeyError(f"Missing one or more metadata rows for id={song_id}")
+
+            meta = meta or {}
+            genre_row = genre_row or {}
+            tag_row = tag_row or {}
+            lang_row = lang_row or {}
+
+            row: Dict[str, object] = {
+                "id": song_id,
+                "artist": info.get("artist", ""),
+                "song": info.get("song", ""),
+                "album_name": info.get("album_name", ""),
+                "spotify_id": meta.get("spotify_id", ""),
+                "popularity": maybe_float(meta.get("popularity")),
+                "release": maybe_int(meta.get("release")),
+                "danceability": maybe_float(meta.get("danceability")),
+                "energy": maybe_float(meta.get("energy")),
+                "key": maybe_int(meta.get("key")),
+                "mode": maybe_int(meta.get("mode")),
+                "valence": maybe_float(meta.get("valence")),
+                "tempo": maybe_float(meta.get("tempo")),
+                "duration_ms": maybe_int(meta.get("duration_ms")),
+                "genres": parse_csv_list(genre_row.get("genres", "")),
+                "tags": parse_csv_list(tag_row.get("tags", "")),
+                "lang": lang_row.get("lang", ""),
+            }
+
+            if include_lyrics:
+                lyrics_path = data_dir / "lyrics" / f"{song_id}.txt"
+                row["lyrics"] = read_text_if_exists(lyrics_path)
+
+            if include_audio:
+                audio_relpath = Path("audios") / f"{song_id}.mp3"
+                audio_path = data_dir / audio_relpath
+                row["audio"] = str(audio_relpath) if audio_path.exists() else None
+
+            yield row
+
+
+def make_features(include_audio: bool, include_lyrics: bool) -> Features:
+    fields = {
+        "id": Value("string"),
+        "artist": Value("string"),
+        "song": Value("string"),
+        "album_name": Value("string"),
+        "spotify_id": Value("string"),
+        "popularity": Value("float32"),
+        "release": Value("int32"),
+        "danceability": Value("float32"),
+        "energy": Value("float32"),
+        "key": Value("int32"),
+        "mode": Value("int32"),
+        "valence": Value("float32"),
+        "tempo": Value("float32"),
+        "duration_ms": Value("int32"),
+        "genres": Sequence(Value("string")),
+        "tags": Sequence(Value("string")),
+        "lang": Value("string"),
+    }
+    if include_lyrics:
+        fields["lyrics"] = Value("string")
+    if include_audio:
+        fields["audio"] = Audio(decode=False)
+    return Features(fields)
+
+
+def make_splits(
+    dataset: Dataset, val_size: float, test_size: float, seed: int
+) -> DatasetDict:
+    if val_size < 0 or test_size < 0:
+        raise ValueError("--val-size and --test-size must be >= 0.")
+    if val_size + test_size >= 1:
+        raise ValueError("--val-size + --test-size must be < 1.")
+
+    if val_size == 0 and test_size == 0:
+        return DatasetDict({"train": dataset})
+
+    train_ds = dataset
+    splits: Dict[str, Dataset] = {}
+
+    if test_size > 0:
+        first = train_ds.train_test_split(test_size=test_size, seed=seed)
+        train_ds = first["train"]
+        splits["test"] = first["test"]
+
+    if val_size > 0:
+        val_ratio_from_remaining = val_size / (1.0 - test_size)
+        second = train_ds.train_test_split(
+            test_size=val_ratio_from_remaining, seed=seed
+        )
+        train_ds = second["train"]
+        splits["validation"] = second["test"]
+
+    splits["train"] = train_ds
+
+    ordered = {}
+    for name in ("train", "validation", "test"):
+        if name in splits:
+            ordered[name] = splits[name]
+    return DatasetDict(ordered)
+
+
+def main() -> None:
+    args = parse_args()
+    data_dir = args.data_dir.resolve()
+    output_dir = args.output_dir.resolve()
+    include_audio = not args.no_audio
+    include_lyrics = not args.no_lyrics
+
+    dataset = Dataset.from_generator(
+        iter_examples,
+        num_proc=4,
+        gen_kwargs={
+            "data_dir": data_dir,
+            "include_audio": include_audio,
+            "include_lyrics": include_lyrics,
+            "strict": args.strict,
+            "max_rows": args.max_rows,
+        },
+        features=make_features(include_audio, include_lyrics),
+    )
+
+    dataset_dict = make_splits(
+        dataset=dataset,
+        val_size=args.val_size,
+        test_size=args.test_size,
+        seed=args.seed,
+    )
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    dataset_dict.save_to_disk(str(output_dir))
+
+    print("Saved HF DatasetDict to:", output_dir)
+    for split_name, split in dataset_dict.items():
+        print(f"{split_name}: {len(split)} rows")
+
+
+if __name__ == "__main__":
+    main()