import json import os import tarfile import zipfile import gzip import subprocess from os.path import join as p_join from math import ceil, floor from tqdm import tqdm from multiprocessing import Pool from typing import Optional, Dict from glob import glob import pandas as pd import soundfile as sf from datasets import Dataset, Audio, DatasetDict audio_loader = Audio() # dataset config url_metadata_dict = { "enA-jaA": "https://dl.fbaipublicfiles.com/seamless/data/seamless_align_nov2023_extension/seamless.dataset.metadata.public.enA-jaA.tsv.gz", "enA-zhA": "https://dl.fbaipublicfiles.com/seamless/data/seamless_align_nov2023_extension/seamless.dataset.metadata.public.enA-zhA.tsv.gz", "enA-viA": "https://dl.fbaipublicfiles.com/seamless/data/seamless_align_nov2023_extension/seamless.dataset.metadata.public.enA-viA.tsv.gz", } direction = os.getenv("DIRECTION", "enA-jaA") if direction not in url_metadata_dict: a, b = direction.split("-") url_metadata_dict[direction] = f"https://dl.fbaipublicfiles.com/seamless/data/seamless_align_nov2023_extension/seamless.dataset.metadata.public.{a}-{b}.tsv.gz" sides = set(direction.split("-")) cache_dir_audio = p_join("download", "audio", direction) cache_dir_feature = p_join("download", "feature", direction) os.makedirs(cache_dir_feature, exist_ok=True) for s in sides: os.makedirs(p_join(cache_dir_audio, s), exist_ok=True) # processor config n_pool = int(os.getenv("N_POOL", 1)) wget_max_retry = os.getenv("MAX_RETRY", "2") wget_timeout = os.getenv("TIMEOUT", "20") line_no_start = int(os.getenv("LINE_NO_START", 0)) line_no_end = int(os.getenv("LINE_NO_END", 10000)) dataset_id = os.getenv("DATASET_ID", 0) hf_org = os.getenv("HF_ORG", "asahi417") hf_dataset = f"seamless-align-{direction}" skip_download = bool(int(os.getenv("SKIP_DOWNLOAD", 0))) sampling_rate = 16000 # seamless-align aligns audio in 16kHz max_seq_length = 1000000 min_seq_length = 50000 def wget(url: str, output_file: Optional[str] = None): os.makedirs(os.path.dirname(output_file), exist_ok=True) try: subprocess.check_output( ["wget", url, "-O", output_file, "--tries", wget_max_retry, "--timeout", wget_timeout], stderr=subprocess.STDOUT, timeout=int(60 * 5) # seconds (if it takes more than 5 min, skip it) ) except Exception: if os.path.exists(output_file): os.remove(output_file) return False if not os.path.exists(output_file): return False if output_file.endswith('.tar.gz') or output_file.endswith('.tgz') or output_file.endswith('.tar'): if output_file.endswith('.tar'): tar = tarfile.open(output_file) else: tar = tarfile.open(output_file, "r:gz") tar.extractall(os.path.dirname(output_file)) tar.close() os.remove(output_file) elif output_file.endswith('.gz'): with gzip.open(output_file, 'rb') as f: with open(output_file.replace('.gz', ''), 'wb') as f_write: f_write.write(f.read()) os.remove(output_file) elif output_file.endswith('.zip'): with zipfile.ZipFile(output_file, 'r') as zip_ref: zip_ref.extractall() os.remove(output_file) return True def get_metadata(): url_metadata = url_metadata_dict[direction] meta_data_filename = os.path.basename(url_metadata) meta_data_path = p_join("download", "meta", meta_data_filename) if not os.path.exists(meta_data_path.replace(".gz", "")): assert wget(url_metadata, output_file=meta_data_path) df = pd.read_csv(meta_data_path.replace(".gz", ""), sep=r'[\t\s]', header=None) df = df[[0, 2, 3, 4, 9, 10, 11, 12]] df.columns = ["id", "url", "duration_start", "duration_end", "laser_score", "direction", "side", "line_no"] if direction == "enA-jpn": df = df[df["side"] == "enA"] assert len(df["direction"].unique()) == 1 df.pop("direction") return df.sort_values(by=["line_no", "side"]) def to_json_serializable(val): if "float" in str(type(val)): return float(val) if "int" in str(type(val)): return int(val) return str(val) def cleanup(features, feature_file): if os.path.exists(feature_file): os.remove(feature_file) for _side in sides: for _unrelated_audio_file in glob(p_join(cache_dir_audio, _side, f"{features['line_no']}.*")): os.remove(_unrelated_audio_file) # create a dummy so that we can skip from next run with open(feature_file, "w") as f: json.dump({"dummy": "dummy"}, f) def get_audio(dataframe: pd.DataFrame): features = {"line_no": int(dataframe.pop('line_no').values[0])} feature_file = p_join(cache_dir_feature, f'{features["line_no"]}.json') for side, df in dataframe.groupby("side"): df.pop("side") features.update({f"{side}.{k}": to_json_serializable(v) for k, v in df.iloc[0].to_dict().items()}) identifier = os.path.basename(features[f"{side}.url"]).split(".")[-1] features[f"{side}.path"] = str(p_join(cache_dir_audio, side, f"{features['line_no']}.{identifier}")) start, end = features[f"{side}.duration_start"], features[f"{side}.duration_end"] if not os.path.exists(features[f"{side}.path"]): print(f"WGET {features[f'{side}.url']}") flag = wget(features[f"{side}.url"], output_file=features[f"{side}.path"]) if not flag: print("\n#### ERROR: wget failure ####\n") cleanup(features, feature_file) return None else: try: print(f"LOAD AUDIO FROM {features[f'{side}.path']}") wav, sr = sf.read(features[f"{side}.path"]) print(f"wav shape:{wav.shape}") if wav.ndim > 1: wav = wav[:, 0] wav = wav[floor(start / sampling_rate * sr):ceil(end / sampling_rate * sr)] print(f"wav shape (after truncate):{wav.shape}") wav = wav[:int(end/sampling_rate * sr) + sr] if len(wav) < min_seq_length or len(wav) > max_seq_length: print(f"invalid wave length: {len(wav)}") cleanup(features, feature_file) return None print(f"SAVING: {features[f'{side}.path']}") sf.write(features[f"{side}.path"], wav, sr) except Exception as e: print(f"\n#### ERROR ####\n {e}") cleanup(features, feature_file) return None print(f"\n### SUCCESS! ###\n:{features['line_no']}") with open(feature_file, "w") as f: json.dump(features, f) return features["line_no"] def loader(feature: str) -> Dict: with open(feature) as f_reader: return json.load(f_reader) if __name__ == '__main__': if not skip_download: df_metadata = get_metadata() print(f"metadata: {len(df_metadata)}, {line_no_start} --> {line_no_end}") inputs = [ g for line_no, g in df_metadata.groupby("line_no") if line_no_start <= line_no < line_no_end and not os.path.exists( p_join(cache_dir_feature, f'{int(line_no)}.json') ) ] print(f"filtered unique lines: {len(inputs)}") inputs = [g for g in inputs if len(g["side"].unique()) == 2 and set(g["side"].unique()) == sides] print(f"removed side != 2: {len(inputs)}") if n_pool == 1: for g in tqdm(inputs, total=len(inputs)): line_no = get_audio(g) else: with Pool(n_pool) as pool: for line_no in pool.imap_unordered(get_audio, inputs): if line_no: print(line_no) print("UPLOADING TO HF!!!") features = [p_join(cache_dir_feature, f'{i}.json') for i in range(line_no_start, line_no_end)] print(f"- raw feature: {len(features)}") features = [i for i in features if os.path.exists(i)] print(f"- path exists: {len(features)}") features = [loader(i) for i in features] features = [i for i in features if "dummy" not in i] print(f"- dummy removed: {len(features)}") print(f"push {len(features)} records to hub") data_dict = {} for side in sides: data_dict.update({f"{side}.audio": [i.pop(f"{side}.path") for i in features]}) data_dict.update({k: [i[k] for i in features] for k in features[0].keys()}) audio_dataset = Dataset.from_dict(data_dict) for side in sides: audio_dataset = audio_dataset.cast_column(f"{side}.audio", Audio()) DatasetDict({"train": audio_dataset}).push_to_hub( f"{hf_org}/{hf_dataset}", config_name=f"subset_{dataset_id}" ) print("clear the workspace") for i in tqdm(range(line_no_start, line_no_end), total=line_no_end - line_no_start): for audio_file in glob(p_join(cache_dir_audio, "*", f"{i}.*")): os.remove(audio_file) if os.path.exists(p_join(cache_dir_feature, f"{i}.json")): os.remove(p_join(cache_dir_feature, f"{i}.json"))