create_dataset.py

"""Create a Hugging Face dataset from the JamendoLyrics dataset in its original layout."""

# %%
import json
import logging
from pathlib import Path
import shutil

import datasets
import numpy as np
from scipy.sparse import csr_array
from scipy.sparse.csgraph import connected_components as scipy_connected_components
import soundfile as sf

# %%
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
logger.setLevel(logging.DEBUG)

# %%
dataset_src = datasets.load_dataset(
    "jamendolyrics/jam-alt", revision="v1.4.0", split="test"
)

# %%
language_fixes = (
    [json.loads(li) for li in Path("language_fixes.jsonl").read_text().splitlines()]
    if Path("language_fixes.jsonl").exists()
    else []
)

# %%
OVERLAP_SOFT_THRESHOLD = 0.1
OVERLAP_HARD_THRESHOLD = 0.2
PADDING = 0.5
MAX_DURATION = 20.0

SUBSETS_DIR = Path(".")
SUBSETS = ["pure", "groups"]

# %%
features = datasets.Features(
    {
        "song_name": datasets.Value("string"),
        "file_name": datasets.Value("string"),
        "text": datasets.Value("string"),
        "language": datasets.Value("string"),
        "song_language": datasets.Value("string"),
        "line_indices": [datasets.Value("int64")],
        "start": datasets.Value("float64"),
        "end": datasets.Value("float64"),
        "merged": datasets.Value("bool"),
        "artist": datasets.Value("string"),
        "title": datasets.Value("string"),
        "genre": datasets.Value("string"),
        "license_type": datasets.Value("string"),
    }
)


# %%
def find_connected_components(matrix: np.ndarray) -> list[list[int]]:
    num_components, labels = scipy_connected_components(
        csgraph=csr_array(matrix), directed=False, return_labels=True
    )
    components = [np.where(labels == i)[0].tolist() for i in range(num_components)]
    return sorted(components)


# $$
for subset in SUBSETS:
    if (SUBSETS_DIR / subset).exists():
        shutil.rmtree(SUBSETS_DIR / subset)


# %%
records = []
stats = []

for item in dataset_src:
    name = item["name"]
    song_language = item["language"]
    lines = item["lines"]
    audio = item["audio"]["array"]
    sr = item["audio"]["sampling_rate"]
    audio_duration = len(audio) / sr

    starts = np.array([line["start"] for line in lines], dtype=float)
    ends = np.array([line["end"] for line in lines], dtype=float)
    texts = [line["text"] for line in lines]

    # Compute pairwise overlaps
    overlap_ends = np.minimum(ends[:, None], ends)
    overlap_starts = np.maximum(starts[:, None], starts)
    overlaps = np.maximum(0.0, overlap_ends - overlap_starts)

    overlap_groups = find_connected_components(overlaps > OVERLAP_HARD_THRESHOLD)

    for indices in overlap_groups:
        group = [lines[i] for i in indices]
        group_name = (
            f"{min(indices):03d}-{max(indices):03d}"
            if len(indices) > 1
            else f"{indices[0]:03d}"
        )

        text = "\n".join(line["text"] for line in group)

        group_starts = [line["start"] for line in group]
        group_ends = [line["end"] for line in group]
        start, end = min(group_starts), max(group_ends)

        # Handle soft overlaps
        _, small_overlap_indices = np.where(
            (overlaps[indices] > 0) & (overlaps[indices] <= OVERLAP_HARD_THRESHOLD)
        )
        for i in small_overlap_indices:
            line = lines[i]
            if line["start"] < end and line["end"] >= end:
                msg = f"{name}: Group {group_name} has {overlaps[small_overlap_indices][:, indices].max():.2f} s overlap with line {i:03d}."
                if end - line["start"] < OVERLAP_SOFT_THRESHOLD:
                    msg += " Ignoring"
                else:
                    new_end = line["start"] + OVERLAP_SOFT_THRESHOLD
                    msg += f"\n    Adjusting end from {end:.2f} to {new_end:.2f} ({new_end - end:.2f} s)"
                    end = new_end
                logger.debug(msg)

        # Pad segment without exceeding duration and causing overlaps
        non_group_indices = [i for i in range(len(lines)) if i not in indices]
        l_limit = max(
            [0.0] + [ends[i] + 0.1 for i in non_group_indices if ends[i] < end]
        )
        r_limit = min(
            [audio_duration]
            + [starts[i] - 0.1 for i in non_group_indices if starts[i] > start]
        )

        max_total_pad = max(0.0, MAX_DURATION - (end - start))
        l_pad = min(max(0.0, start - l_limit), PADDING)
        r_pad = min(max(0.0, r_limit - end), PADDING)

        if l_pad + r_pad > max_total_pad:
            l_pad = r_pad = min(l_pad, r_pad, max_total_pad / 2)
            extra = max(0.0, max_total_pad - (l_pad + r_pad)) - 1e-3
            l_pad += extra / 2
            r_pad += extra / 2
            assert l_pad + r_pad < max_total_pad

        start, end = start - l_pad, end + r_pad
        duration = end - start

        stats.append(
            {
                "name": name,
                "group_name": group_name,
                "duration": duration,
                "group_size": len(indices),
                "excluded": False,
            }
        )

        if duration > MAX_DURATION:
            logger.info(f"Excluding segment {name}.{group_name} of duration {duration}")
            stats[-1]["excluded"] = True
            continue

        start_frame, end_frame = round(start * sr), round(end * sr)
        line_audio = audio[start_frame:end_frame]

        file_name = f"{name}.{group_name}.flac"

        language = song_language
        for fix in language_fixes:
            if fix["file_name"] == file_name:
                assert fix["text"] == text, (
                    f"Text mismatch for {file_name}: {fix['text']} != {text}"
                )
                language = fix["language"]
                logger.debug(
                    f"{name}: Fixing language of group {group_name} to {language}"
                )

        if len(group) > 1:
            subset_dir = SUBSETS_DIR / "groups" / language
        else:
            subset_dir = SUBSETS_DIR / "pure" / language
        out_audio_path = subset_dir / "audio" / file_name
        out_audio_path.parent.mkdir(parents=True, exist_ok=True)
        sf.write(out_audio_path, line_audio, sr)

        records.append(
            {
                "song_name": name,
                "file_name": str(out_audio_path.relative_to(subset_dir)),
                "text": "\n".join(line["text"] for line in group),
                "language": language,
                "song_language": song_language,
                "line_indices": indices,
                "start": start,
                "end": end,
                "merged": len(group) > 1,
                **{k: item[k] for k in ["artist", "title", "genre", "license_type"]},
            }
        )

dataset_out = datasets.Dataset.from_list(records, features=features, split="test")


# %%
for config_name in ["pure", "groups"]:
    for subset_language in ["en", "es", "de", "fr"]:
        subset_dir = SUBSETS_DIR / config_name / subset_language
        subset_dir.mkdir(exist_ok=True)

        subset = dataset_out.filter(lambda x: x["language"] == subset_language)
        if config_name == "pure":
            subset = subset.filter(lambda x: not x["merged"])
        elif config_name == "groups":
            subset = subset.filter(lambda x: x["merged"])

        subset.to_json(subset_dir / "metadata.jsonl")