Datasets:

turnmaster
/

TurnMaster

@@ -1,809 +0,0 @@
-import json
-import math
-import os
-import csv
-import random
-from pathlib import Path
-import re
-import argparse
-import soundfile as sf
-import numpy as np
-import torch
-import torchaudio
-from tqdm import tqdm
-import pandas as pd
-from whisper_normalizer.english import EnglishTextNormalizer
-import re
-# -------------------------
-# Helpers
-# -------------------------
-def load_mono_resampled(path, sr):
-    wav_np, fs = sf.read(path, always_2d=True)   # [T, C]
-    wav = torch.from_numpy(wav_np).float().T     # [C, T]
-    if wav.shape[0] > 1:
-        wav = wav.mean(dim=0, keepdim=True)
-    else:
-        wav = wav[:1]
-    if fs != sr:
-        wav = torchaudio.functional.resample(wav, fs, sr)
-    # Remove DC offsets
-    wav = torchaudio.functional.highpass_biquad(wav, sample_rate=sr, cutoff_freq=20.0)
-    peak = wav.abs().max(dim=1, keepdim=True).values.clamp_min(1e-8)
-    wav = 0.95 * wav / peak                    # peak normalize to [-0.95, 0.95]
-    return wav  # [1, T]
-pattern = re.compile(r"\$(\d+(?:\.\d+)?)")
-def transform_money(text: str) -> str:
-    def repl(match):
-        value = float(match.group(1))
-        doubled = value * 2
-        # Remove trailing .0 for integers
-        if doubled.is_integer():
-            doubled = int(doubled)
-        return f"{doubled} dollars"
-    return pattern.sub(repl, text)
-def normalize_punct(text, english_normalizer):
-    parts = re.split(r'\.{3}|[.!?;]', text)
-    parts = [p.strip() for p in parts if p.strip()]
-    normalized_text = ""
-    for part in parts:
-        norm_part = english_normalizer(part)
-        normalized_text += norm_part + " , "
-    normalized_text += " . "
-    normalized_text = normalized_text.replace(" ,  . ", " . ")
-    return normalized_text
-def process_manifest(manifest_dir, wav_root, samples, args):
-    manifest_csv = pd.read_csv(manifest_dir)
-    wav_dirs = manifest_csv["audio_path"].values
-    audio_id = manifest_csv["audio_id"].values
-    texts = manifest_csv["synthetic_text"].values
-    conversation_ids = manifest_csv["conversation_id"].values
-    utterance_indexes = manifest_csv["utterance_index"].values
-    role = manifest_csv["speaker"].values
-    split = manifest_csv["split"].values
-    english_normalizer = EnglishTextNormalizer()
-    for entry_idx in range(len(wav_dirs)):
-        if role[entry_idx] == "user":
-            result = {
-                "wav_dir": f'{wav_root}/{wav_dirs[entry_idx]}',
-                "text": texts[entry_idx],
-                "dialog_id": conversation_ids[entry_idx],
-                "turn_id": utterance_indexes[entry_idx],
-                "split": split[entry_idx],
-                "audio_id": audio_id[entry_idx]
-            }
-            if args.normalize_text:
-                if args.keep_punct:
-                    result['text'] = normalize_punct(result['text'], english_normalizer) #english_normalizer(result['text'])
-                else:
-                    result['text'] = english_normalizer(result['text'])
-            if args.custom_dollar_normalisation:
-                result['text'] = transform_money(result['text'])
-            samples.append(result)
-    return samples
-def rms(x, eps=1e-12):
-    return torch.sqrt(torch.mean(x**2) + eps)
-def fit_noise_length(noise, target_len):
-    n = noise.shape[1]
-    if n == target_len:
-        return noise
-    elif n > target_len:
-        start = random.randint(0, n - target_len)
-        return noise[:, start:start + target_len]
-    else:
-        repeat = (target_len + n - 1) // n
-        noise_rep = noise.repeat(1, repeat)
-        return noise_rep[:, :target_len]
-def mix_with_snr(clean, noise, snr_db):
-    clean_rms = rms(clean)
-    noise_rms = rms(noise)
-    noise_rms_target = clean_rms / (10 ** (snr_db / 20))
-    scale = noise_rms_target / (noise_rms + 1e-12)
-    noisy = clean + scale * noise
-    return torch.clamp(noisy, -1.0, 1.0)
-def vad_labels_from_interval(
-    num_samples: int,
-    sr: int,
-    speech_start: float,
-    speech_end: float,
-    intermediate_silences: list,
-    frame_hop_s: float = 0.01,
-    frame_len_s: float = 0.025,
-) -> torch.Tensor:
-    total_dur = num_samples / sr
-    num_frames = int(math.ceil(total_dur / frame_hop_s))
-    labels = torch.zeros(num_frames, dtype=torch.float32)
-    for i in range(num_frames):
-        center_t = i * frame_hop_s + 0.5 * frame_len_s
-        is_intermediate_silence = False
-        for silence in intermediate_silences:
-            if silence[0] <= center_t < silence[1]:
-                if silence[0] - speech_start - 0.032 < 0.001:
-                    if labels[i] != 0.0:
-                        labels[i] = 0.0
-                    if labels[i-1] != 0.0:
-                        labels[i-1] = 0.0
-                    if labels[i-2] != 0.0:
-                        labels[i-2] = 0.0
-                    is_intermediate_silence = True
-                    break
-                else:
-                    if i+1 < num_frames:
-                        labels[i+1] = 3.0
-                    labels[i] = 3.0
-                    is_intermediate_silence = True
-                    break
-        if not is_intermediate_silence:
-            if speech_start <= center_t < speech_end:
-                labels[i] = 1.0
-            elif center_t > speech_end:
-                labels[i] = 2.0
-    # Change intermediate silences followed by endpoint to endpoint
-    for i in range(num_frames-2, -1, -1):
-        if labels[i+1] == 0.0:
-            labels[i] = 2.0
-        if labels[i+1] == 2.0 and labels[i] == 3.0:
-            labels[i] = 2.0
-        elif labels[i] == 1.0:
-            break
-    # Remove speech less than 100ms before between intermediate silence E.P.
-    labels = fix_prev_values(labels)
-    # Change intermediate silences followed by endpoint to E.P. again
-    for i in range(num_frames-2, -1, -1):
-        if labels[i+1] == 0.0:
-            labels[i] = 2.0
-        if labels[i+1] == 2.0 and labels[i] == 3.0:
-            labels[i] = 2.0
-        elif labels[i] == 1.0:
-            break
-    labels = torch.cat((torch.zeros(1,), labels))
-    labels = labels[:-1]
-    eot_idx = torch.where(labels == 2.0)[0]
-    start_eot_idx = eot_idx[0].item()
-    return labels, start_eot_idx
-# -------------------------
-# Argparse
-# -------------------------
-def parse_args():
-    parser = argparse.ArgumentParser(description="Augment Taskmaster with start / end silences and optional noise.")
-    parser.add_argument("--target-sr", type=int, default=16000)
-    parser.add_argument("--silence-min-start", type=float, default=0.0, help="Minimum silence duration (seconds) for start and end silences")
-    parser.add_argument("--silence-max-start", type=float, default=0.0, help="Maximum silence duration (seconds) for start and end silences")
-    parser.add_argument("--silence-min-end", type=float, default=0.0, help="Minimum silence duration (seconds) for start and end silences")
-    parser.add_argument("--silence-max-end", type=float, default=3.0, help="Maximum silence duration (seconds) for start and end silences")
-    parser.add_argument("--silence-insertion-min-s", type=float, default=0.05, help="Minimum silence duration (seconds) for silence insertions")
-    parser.add_argument("--silence-insertion-max-s", type=float, default=2.0, help="Maximum silence duration (seconds) for silence insertions")
-    parser.add_argument("--pause-per-second-ratio", type=float, default=0.7, help="Maximum ratio of silence per audio duration allowed. Ex if audio duration = 10s and --pause-per-second-ratio 0.5 the maximum of number of silences to be inserted is 5.")
-    parser.add_argument("--lam", type=float, default=0.003, help="Lam for exponential silence duration sampling")
-    parser.add_argument("--max-initial-silence-duration", type=float, default=1.5, help="Maximum silence duration (seconds) for silence insertions")
-    parser.add_argument("--snr-min-db", type=float, default=10)
-    parser.add_argument("--snr-max-db", type=float, default=21)
-    parser.add_argument("--frame-hop-s", type=float, default=0.01 * 4)
-    parser.add_argument("--frame-len-s", type=float, default=0.032 * 4)
-    parser.add_argument("--normalize-text", action="store_true")
-    parser.add_argument("--keep-punct", action="store_true")
-    parser.add_argument("--custom-dollar-normalisation", action="store_true", help="replace $10 to 10 dollars")
-    parser.add_argument("--silence-insertion", action="store_true")
-    parser.add_argument("--VAD-hop-length", type=int, default=256, help="Hop length used by the energy based VAD for speech segmentation before silence insertion.")
-    parser.add_argument("--VAD-frame-length", type=int, default=512, help="Frame length used by the energy based VAD for speech segmentation before silence insertion.")
-    parser.add_argument("--VAD-energy-threshold", type=float, default=0.01, help="Energy threshold used by the energy based VAD for speech segmentation before silence insertion.")
-    parser.add_argument("--VAD-min-silence-frames", type=int, default=3, help="Min silence frame used by the energy based VAD for speech segmentation before silence insertion.")
-    parser.add_argument("--taskmaster-root-dir", type=str, default="/opt/marcel-c3/workdir/clws3842/datasets/Taskmaster/original_clean", help="The root leading to the manifest.csv and the audios")
-    parser.add_argument("--aug-dataset-save-dir", type=str, required=True)
-    parser.add_argument("--add-white-noise", action="store_true", help="Required only if SNR args are provided.")
-    parser.add_argument("--add-bg-noise", action="store_true", help="Required only if SNR args are provided.")
-    parser.add_argument("--input-noise-dir", type=str, default="/opt/marcel-c3/workdir/clws3842/datasets/musan/musan", help="Required only if SNR args are provided.")
-    parser.add_argument(
-        "--splits",
-        nargs="+",
-        default=["train", "dev", "test"],
-        choices=["train", "dev", "test"],
-        help="Which splits to process"
-    )
-    parser.add_argument("--seed", type=int, default=3265)
-    return parser.parse_args()
-def save_args_json(args, path="args.json"):
-    path = Path(path)
-    path.parent.mkdir(parents=True, exist_ok=True)
-    with open(path, "w", encoding="utf-8") as f:
-        json.dump(vars(args), f, indent=2, ensure_ascii=False)
-def detect_silence_segments(
-    waveform,
-    frame_length=1024,
-    hop_length=512,
-    energy_threshold=0.01,
-    min_silence_frames=3
-):
-    """
-    Detect silence regions in an audio waveform using short-time energy.
-    Args:
-        waveform (np.ndarray): 1D audio signal, or 2D with shape (channels, samples) / (samples, channels).
-        frame_length (int): Number of samples per frame.
-        hop_length (int): Step size between frames.
-        energy_threshold (float): Frames with RMS energy below this are considered silent.
-        min_silence_frames (int): Minimum consecutive silent frames to keep.
-    Returns:
-        List[Tuple[int, int]]: List of (start_frame, end_frame) silence intervals (inclusive).
-    """
-    waveform = np.asarray(waveform)
-    # Robustly convert to 1D mono
-    if waveform.ndim == 2:
-        # If (channels, samples), average over channels
-        if waveform.shape[0] <= waveform.shape[1]:
-            waveform = waveform.mean(axis=0)
-        else:
-            # If (samples, channels), average over channels
-            waveform = waveform.mean(axis=1)
-    elif waveform.ndim != 1:
-        raise ValueError("waveform must be 1D or 2D")
-    waveform = waveform.astype(np.float32, copy=False)
-    n_samples = len(waveform)
-    if n_samples < frame_length:
-        return []
-    # Number of complete frames
-    n_frames = 1 + (n_samples - frame_length) // hop_length
-    # Frame-wise RMS energy
-    energies = np.empty(n_frames, dtype=np.float32)
-    for i in range(n_frames):
-        start = i * hop_length
-        frame = waveform[start:start + frame_length]
-        energies[i] = np.sqrt(np.mean(frame * frame) + 1e-12)
-    # Silent mask
-    silent = energies < energy_threshold
-    # Group consecutive silent frames
-    silence_segments = []
-    in_segment = False
-    seg_start = 0
-    for i, is_silent in enumerate(silent):
-        if is_silent and not in_segment:
-            in_segment = True
-            seg_start = i
-        elif not is_silent and in_segment:
-            seg_end = i - 1
-            if (seg_end - seg_start + 1) >= min_silence_frames:
-                silence_segments.append((seg_start, seg_end))
-            in_segment = False
-    # If segment reaches last frame
-    if in_segment:
-        seg_end = n_frames - 1
-        if (seg_end - seg_start + 1) >= min_silence_frames:
-            silence_segments.append((seg_start, seg_end))
-    return silence_segments
-def fix_prev_values(x: torch.Tensor, n: int = 3) -> torch.Tensor:
-    """
-    x: 1D tensor with values in [0, 3]
-    n: number of values before first '2' to check
-    Finds first index i where x[i] == 2.
-    Checks slice x[max(0, i-n):i].
-    If all are 1 -> keep unchanged.
-    Otherwise sets that whole slice to 2.
-    """
-    x = x.clone()  # avoid modifying original tensor
-    # Find first index where value == 2
-    idx = torch.where(x == 2.0)[0]
-    if idx.numel() == 0:
-        return x  # no '2' found, nothing to do
-    i = idx[0].item()
-    start = max(0, i - n)
-    prev_slice = x[start:i]
-    if prev_slice.numel() > 0 and not torch.all(prev_slice == 1):
-        x[start:i] = 2.0
-    return x
-def sample_truncated_exponential(
-    lower=500,
-    upper=1500,
-    decay_rate=0.005
-):
-    """
-    Return one sample from a truncated exponential distribution
-    between lower and upper.
-    """
-    if lower >= upper:
-        raise ValueError("lower must be less than upper")
-    if decay_rate < 0:
-        raise ValueError("decay_rate must be non-negative")
-    if decay_rate == 0:
-        return random.uniform(lower, upper)
-    u = random.random()
-    return lower - math.log(
-        1 - u * (1 - math.exp(-decay_rate * (upper - lower)))
-    ) / decay_rate
-def add_silence(waveform, sr, args):
-    """
-    Insert random silent chunks at detected silence starts.
-    Args:
-        waveform (np.ndarray): 1D waveform (or 2D, will be converted to mono).
-        sr (int): Sample rate used for insertion duration and timestamps.
-        args: object with at least `target_sr` (optional; if missing, `sr` is used).
-    Returns:
-        waveform_torch (torch.Tensor): shape (1, num_samples)
-        silence_infos (str): "start_sec|end_sec;..." for all detected silences
-        intermediate_silences (list): List of [start_sec, end_sec] for all silences
-    """
-    # Ensure 1D mono float32
-    waveform = np.asarray(waveform)
-    if waveform.ndim == 2:
-        if waveform.shape[0] <= waveform.shape[1]:
-            waveform = waveform.mean(axis=0)
-        else:
-            waveform = waveform.mean(axis=1)
-    elif waveform.ndim != 1:
-        raise ValueError("waveform must be 1D or 2D")
-    waveform = waveform.astype(np.float32, copy=False)
-    frame_length = args.VAD_frame_length
-    hop_length = args.VAD_hop_length
-    silences = detect_silence_segments(
-        waveform,
-        frame_length=frame_length,
-        hop_length=hop_length,
-        energy_threshold=args.VAD_energy_threshold,
-        min_silence_frames=args.VAD_min_silence_frames
-    )
-    num_frames_waveform = len(waveform)
-    # Exclude segments touching first/last frame (correct unit: frames)
-    if silences:
-        n_frames = 1 + (num_frames_waveform - frame_length) // hop_length if num_frames_waveform >= frame_length else 0
-    used_sr = getattr(args, "target_sr", sr)
-    silence_infos = "["
-    intermediate_silences = []
-    if len(silences) > 0:
-        silences_idx_correct = [x for x in range(len(silences)) if (silences[x][1] * hop_length / sr) - (silences[x][0] * hop_length / sr) < args.max_initial_silence_duration]
-        max_sil_insertion = max(1, int(num_frames_waveform / sr * args.pause_per_second_ratio))
-        rand_num_silence = np.random.randint(0, min(max_sil_insertion, len(silences_idx_correct) + 1))
-        elongate_indices = set()
-        if rand_num_silence > 0 and args.silence_insertion == True:
-            idx = np.random.choice(len(silences_idx_correct), replace=False, size=rand_num_silence)
-            elongate_indices = set(idx)
-        silences_to_elongate = [(i, silences[i]) for i in elongate_indices
-                                if silences[i][0] != 0 and silences[i][1] != (n_frames - 1)]
-        silences_to_elongate = sorted(silences_to_elongate, key=lambda x: x[1][0], reverse=False)
-        added_duration = 0
-        elongated_map = {}
-        for silence_idx, silence in silences_to_elongate:
-            # Calculate the original silence boundaries in samples
-            silence_start_sample = silence[0] * hop_length
-            silence_end_sample = (silence[1] + 1) * hop_length
-            sample_silence_duration = silence_end_sample - silence_start_sample
-            # Calculate insertion point: end of silence - 2 frames
-            insert_sample = silence_end_sample - (2 * hop_length) + added_duration
-            if args.lam > 0:
-                # Generate exp random silence duration
-                silence_duration = sample_truncated_exponential(
-                    int(args.silence_insertion_min_s * 1000),
-                    int(args.silence_insertion_max_s * 1000),
-                    args.lam
-                )
-                silence_duration = int(silence_duration / 1000 * sr)
-            else:
-                # Generate uniform random silence duration
-                silence_duration = int(np.random.randint(
-                    sr * args.silence_insertion_min_s,
-                    sr * args.silence_insertion_max_s)
-                )
-            silence_insert = np.zeros((silence_duration,), dtype=waveform.dtype)
-            # Insert at end - 2 frames of the silence
-            waveform = np.insert(waveform, insert_sample, silence_insert)
-            # ═══════════════════════════════════════════════════════════════
-            # FIX: Store the original start sample for correct timestamp calculation
-            # ═══════════════════════════════════════════════════════════════
-            elongated_map[silence_idx] = (added_duration, silence_duration, sample_silence_duration, silence_start_sample)
-            added_duration += silence_duration
-        cumulative_added = 0
-        for silence_idx in range(len(silences)):
-            silence = silences[silence_idx]
-            if silence_idx in elongated_map:
-                # ═══════════════════════════════════════════════════════════════
-                # FIX: Calculate timestamps correctly for elongated silences
-                # ═══════════════════════════════════════════════════════════════
-                # The silence now spans from its original start to its original end + inserted duration
-                added_at_this_point, silence_duration, sample_silence_duration, silence_start_sample = elongated_map[silence_idx]
-                # Start remains at the original silence start (adjusted for previous insertions)
-                start_sample = silence_start_sample + added_at_this_point
-                # End is original end + inserted silence duration (adjusted for previous insertions)
-                end_sample = start_sample + sample_silence_duration + silence_duration
-                start_t = start_sample / used_sr
-                end_t = end_sample / used_sr
-                silence_infos += f"{start_t:.4f}|{end_t:.4f};"
-                intermediate_silences.append([start_t, end_t])
-                cumulative_added = added_at_this_point + silence_duration
-            else:
-                # Non-elongated silences
-                start_sample = silence[0] * hop_length + cumulative_added
-                end_sample = (silence[1] + 1) * hop_length + cumulative_added
-                start_t = start_sample / used_sr
-                end_t = end_sample / used_sr
-                silence_infos += f"{start_t:.4f}|{end_t:.4f};"
-                intermediate_silences.append([start_t, end_t])
-    silence_infos += "]"
-    waveform = torch.from_numpy(waveform.astype(np.float32, copy=False)).unsqueeze(0)
-    return waveform, silence_infos, intermediate_silences
-def add_silence_deprecated(waveform, sr, args):
-    """
-    Insert random silent chunks at detected silence starts.
-    Args:
-        waveform (np.ndarray): 1D waveform (or 2D, will be converted to mono).
-        sr (int): Sample rate used for insertion duration and timestamps.
-        args: object with at least `target_sr` (optional; if missing, `sr` is used).
-    Returns:
-        waveform_torch (torch.Tensor): shape (1, num_samples)
-        silence_infos (str): "start_sec-end_sec$..." for inserted chunks
-    """
-    # Ensure 1D mono float32
-    waveform = np.asarray(waveform)
-    if waveform.ndim == 2:
-        if waveform.shape[0] <= waveform.shape[1]:
-            waveform = waveform.mean(axis=0)
-        else:
-            waveform = waveform.mean(axis=1)
-    elif waveform.ndim != 1:
-        raise ValueError("waveform must be 1D or 2D")
-    waveform = waveform.astype(np.float32, copy=False)
-    frame_length = args.VAD_frame_length
-    hop_length = args.VAD_hop_length
-    silences = detect_silence_segments(
-        waveform,
-        frame_length=frame_length,
-        hop_length=hop_length,
-        energy_threshold=args.VAD_energy_threshold,
-        min_silence_frames=args.VAD_min_silence_frames
-    )
-    # Exclude segments touching first/last frame (correct unit: frames)
-    num_frames_waveform = len(waveform)
-    if silences:
-        n_frames = 1 + (num_frames_waveform - frame_length) // hop_length if num_frames_waveform >= frame_length else 0
-    used_sr = getattr(args, "target_sr", sr)
-    print(len(silences))
-    silence_infos = "["
-    intermediate_silences = []
-    if len(silences) > 0:
-        pause_per_second_ration = 0.75
-        max_sil_insertion = max(1, int(num_frames_waveform / sr * pause_per_second_ration))
-        print(max_sil_insertion, num_frames_waveform / sr)
-        rand_num_silence = np.random.randint(0, min(max_sil_insertion, len(silences) + 1))
-        if rand_num_silence > 0 and args.silence_insertion == True:
-            idx = np.random.choice(len(silences), replace=False, size=rand_num_silence)
-            random_silences = [silences[i] for i in idx]
-            # descending so earlier insertions don't shift later indices
-            random_silences = sorted(random_silences, key=lambda x: x[0], reverse=True)
-            added_duration = 0
-            for silence_idx in range(len(silences)):
-                if silence_idx in idx and silences[silence_idx][0] != 0 and silences[silence_idx][1] != (n_frames - 1):
-                    # Convert frame index -> sample index
-                    silence = silences[silence_idx]
-                    insert_sample = (silence[0] + 2) * hop_length + added_duration # +2 to account for frame length
-                    sample_silence_duration = (silence[1] + 1) * hop_length - silence[0] * hop_length # +1 to account for strict exclusion
-                    silence_duration = int(np.random.randint(sr * args.silence_insertion_min_s, sr * args.silence_insertion_max_s))
-                    silence_insert = np.zeros((silence_duration,), dtype=waveform.dtype)
-                    waveform = np.insert(waveform, insert_sample, silence_insert)
-                    start_t = insert_sample / used_sr
-                    end_t = (insert_sample + silence_duration) / used_sr
-                    silence_infos += f"{start_t:.6f}|{end_t:.6f};"
-                    intermediate_silences.append([insert_sample, (insert_sample + silence_duration + sample_silence_duration)])
-                    added_duration += silence_duration
-                else:
-                    start_t, end_t = (silences[silence_idx][0] + 2) * hop_length + added_duration, (silences[silence_idx][1] + 2) * hop_length + added_duration
-                    intermediate_silences.append([start_t, end_t])
-        else:
-            for silence_idx in range(len(silences)):
-                start_t, end_t = (silences[silence_idx][0] + 2) * hop_length, (silences[silence_idx][1] + 2) * hop_length
-                intermediate_silences.append([start_t, end_t])
-    intermediate_silences = [[x[0] / used_sr, x[1] / used_sr] for x in intermediate_silences]
-    silence_infos += "]"
-    waveform = torch.from_numpy(waveform.astype(np.float32, copy=False)).unsqueeze(0)
-    return waveform, silence_infos, intermediate_silences
-def is_sample_in_split(split, sample_split):
-    if split == "train":
-        if sample_split == "train":
-            return True
-        else:
-            False
-    elif split == "dev":
-        if sample_split == "dev":
-            return True
-        else:
-            False
-    elif split == "test":
-        if sample_split == "test":
-            return True
-        else:
-            False
-    else:
-        raise(f"{split} does not exist in the list of dataset splits to process")
-def main():
-    print("Starting dataset augmentation.")
-    args = parse_args()
-    save_args_json(args, f'{args.aug_dataset_save_dir}/run_config.json')
-    os.makedirs(f'{args.aug_dataset_save_dir}/figs', exist_ok=True)
-    if args.seed is not None:
-        random.seed(args.seed)
-        np.random.seed(args.seed)
-        torch.manual_seed(args.seed)
-    if (args.snr_min_db is None) ^ (args.snr_max_db is None):
-        raise ValueError("Provide both --snr-min-db and --snr-max-db, or neither.")
-    for split in args.splits:
-        out_audio_dir_tts = f'{args.aug_dataset_save_dir}/{split}/wav'
-        out_vad_dir_tts = f'{args.aug_dataset_save_dir}/{split}/vad_labels'
-        out_csv_path = f'{args.aug_dataset_save_dir}/{split}.csv'
-        os.makedirs(out_audio_dir_tts, exist_ok=True)
-        os.makedirs(out_vad_dir_tts, exist_ok=True)
-        os.makedirs(Path(out_csv_path).parent, exist_ok=True)
-        noise_files = []
-        use_noise = args.add_bg_noise
-        if use_noise:
-            noise_files = sorted([
-                str(p) for p in Path(args.input_noise_dir).glob("**/*")
-                if p.suffix.lower() in [".wav", ".flac", ".mp3", ".ogg"]
-                and "speech" not in str(p)
-            ])
-            if len(noise_files) == 0:
-                raise RuntimeError("No noise files found.")
-        speech_files = []
-        manifest_dir = f'{args.taskmaster_root_dir}/manifest_filtered_1_18_02.csv'
-        speech_files = process_manifest(manifest_dir, args.taskmaster_root_dir, speech_files, args)
-        rows = []
-        for i, speech_sample in enumerate(tqdm(speech_files, desc=f"Processing {split}", unit="file")):
-            if is_sample_in_split(split, speech_sample["split"]):
-                speech_path = speech_sample["wav_dir"]
-                base = Path(speech_path).stem
-                out_audio_path = os.path.join(out_audio_dir_tts, f"{i:06d}_aug_{base}.wav")
-                if os.path.exists(out_audio_path):
-                    print("already exist")
-                    continue
-                speech = load_mono_resampled(speech_path, args.target_sr)
-                speech, silence_infos, intermediate_silences = add_silence(speech, args.target_sr, args)
-                T_speech = speech.shape[1]
-                start_sil_s = random.uniform(args.silence_min_start, args.silence_max_start)
-                end_sil_s = random.uniform(args.silence_min_end, args.silence_max_end)
-                intermediate_silences = [[intermediate_silences[x][0] + start_sil_s, intermediate_silences[x][1] + start_sil_s] for x in range(len(intermediate_silences))]
-                T_start = int(round(start_sil_s * args.target_sr))
-                T_end = int(round(end_sil_s * args.target_sr))
-                start_sil = torch.zeros((1, T_start), dtype=speech.dtype)
-                end_sil = torch.zeros((1, T_end), dtype=speech.dtype)
-                clean_aug = torch.cat([start_sil, speech, end_sil], dim=1)
-                T_total = clean_aug.shape[1]
-                vad_label, start_eot_idx = vad_labels_from_interval(
-                    num_samples=T_total,
-                    sr=args.target_sr,
-                    speech_start=T_start / args.target_sr,
-                    speech_end=(T_start + T_speech) / args.target_sr,
-                    frame_hop_s=args.frame_hop_s,
-                    frame_len_s=args.frame_len_s,
-                    intermediate_silences=intermediate_silences,
-                )
-                is_syntethic = 1 if "tts" in speech_path or "train" in speech_path else 0
-                base = Path(speech_path).stem
-                out_audio_path = os.path.join(out_audio_dir_tts, f"aug_{i:06d}_{base}.wav")
-                out_audio_noise_path = os.path.join(out_audio_dir_tts, f"aug_{i:06d}_{base}_noise.wav")
-                out_vad_path = os.path.join(out_vad_dir_tts, f"aug_{i:06d}_{base}_vad.pt")
-                noisy_aug = clean_aug.clone()
-                noise_path = None
-                if args.add_bg_noise and split != "train":
-                    noise_path = random.choice(noise_files)
-                    noise = load_mono_resampled(noise_path, args.target_sr)
-                    noise = fit_noise_length(noise, T_total)
-                    snr_db = random.uniform(args.snr_min_db, args.snr_max_db)
-                    noisy_aug = mix_with_snr(noisy_aug, noise, snr_db)
-                if args.add_white_noise and split != "train":
-                    snr_db = random.uniform(args.snr_min_db, args.snr_max_db)
-                    white = torch.randn_like(clean_aug)
-                    noisy_aug = mix_with_snr(clean_aug, white, snr_db)
-                if args.add_white_noise or args.add_bg_noise:
-                    if split != "train":
-                        noisy_np = noisy_aug.squeeze(0).cpu().numpy().astype(np.float32)
-                        sf.write(out_audio_noise_path, noisy_np, args.target_sr)
-                        rows.append({
-                            "ID": f"aug_{i:06d}_{base}_noise",
-                            "orig_speech_path": speech_path,
-                            "noise_path": noise_path,
-                            "wav": out_audio_noise_path,
-                            "vad": out_vad_path,
-                            "sample_rate": args.target_sr,
-                            "speech_num_samples": T_speech,
-                            "start_eot": start_eot_idx,
-                            "start_eot_time": start_eot_idx * 0.04,
-                            "start_silence_s": start_sil_s,
-                            "end_silence_s": end_sil_s,
-                            "start_silence_samples": T_start,
-                            "end_silence_samples": T_end,
-                            "total_num_samples": T_total,
-                            "duration": T_total / args.target_sr,
-                            "snr_db": snr_db,
-                            "speech_start_sample": T_start,
-                            "speech_end_sample_exclusive": T_start + T_speech,
-                            "wrd": speech_sample["text"],
-                            "dialog_id": speech_sample["dialog_id"],
-                            "turn_id": speech_sample["turn_id"],
-                            "split": speech_sample["split"],
-                            "audio_id": speech_sample["audio_id"],
-                            "is_syntethic": is_syntethic,
-                            "silence_infos": silence_infos,
-                            "white_noise": args.add_white_noise,
-                            "bg_noise": args.add_bg_noise
-                        })
-                noise_path = None
-                snr_db = None
-                clean_aug_np = clean_aug.squeeze(0).cpu().numpy().astype(np.float32)
-                sf.write(out_audio_path, clean_aug_np, args.target_sr)
-                rows.append({
-                    "ID": f"aug_{i:06d}_{base}",
-                    "orig_speech_path": speech_path,
-                    "noise_path": noise_path,
-                    "wav": out_audio_path,
-                    "vad": out_vad_path,
-                    "sample_rate": args.target_sr,
-                    "speech_num_samples": T_speech,
-                    "start_eot": start_eot_idx,
-                    "start_eot_time": start_eot_idx * 0.04,
-                    "start_silence_s": start_sil_s,
-                    "end_silence_s": end_sil_s,
-                    "start_silence_samples": T_start,
-                    "end_silence_samples": T_end,
-                    "total_num_samples": T_total,
-                    "duration": T_total / args.target_sr,
-                    "snr_db": None,
-                    "speech_start_sample": T_start,
-                    "speech_end_sample_exclusive": T_start + T_speech,
-                    "wrd": speech_sample["text"],
-                    "dialog_id": speech_sample["dialog_id"],
-                    "turn_id": speech_sample["turn_id"],
-                    "split": speech_sample["split"],
-                    "audio_id": speech_sample["audio_id"],
-                    "is_syntethic": is_syntethic,
-                    "silence_infos": silence_infos,
-                    "white_noise": False,
-                    "bg_noise": False
-                })
-                torch.save(vad_label, out_vad_path)
-        fieldnames = list(rows[0].keys()) if rows else []
-        with open(out_csv_path, "w", newline="", encoding="utf-8") as f:
-            writer = csv.DictWriter(f, fieldnames=fieldnames)
-            writer.writeheader()
-            writer.writerows(rows)
-        print(f"[{split}] Done. Processed {len(rows)} files.")
-        print(f"[{split}] Metadata CSV: {out_csv_path}")
-if __name__ == "__main__":
-    main()