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 librosa 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-jpn": "https://dl.fbaipublicfiles.com/seamless/data/seamless.dataset.metadata.public.enA-jpn.withduration.tsv.gz" } direction = os.getenv("DIRECTION", "enA-jaA") 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 def wget(url: str, output_file: Optional[str] = None): os.makedirs(os.path.dirname(output_file), exist_ok=True) subprocess.run(["wget", url, "-O", output_file, "--tries", wget_max_retry, "--timeout", wget_timeout]) 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): resampler = {} 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 sr != sampling_rate: # print(f"RESAMPLING: {wav.shape} length audio") # wav = librosa.resample(wav, orig_sr=sr, target_sr=sr) print(f"SAVING: {features[f'{side}.path']}") sf.write(features[f"{side}.path"], wav[start:end], 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"] 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)}") if direction == "enA-jaA": 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) def loader(feature: str) -> Dict: with open(feature) as f_reader: return json.load(f_reader) 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}" ) # DatasetDict({"train": audio_dataset.select(list(range(1000)))}).push_to_hub( # f"{hf_org}/{hf_dataset}", # config_name=f"subset_{dataset_id}" # ) # # 2 panel # dataset_id = 75 # DatasetDict({"train": audio_dataset.select(list(range(3000, len(audio_dataset))))}).push_to_hub( # f"{hf_org}/{hf_dataset}", # config_name=f"subset_{dataset_id}" # ) # # # audio_dataset = audio_dataset.select(list(range(2500))) # dataset_to_push = DatasetDict({"train": audio_dataset}) # repo_name = f"{hf_org}/{hf_dataset}" # dataset_to_push.push_to_hub(repo_name, config_name=f"subset_{dataset_id}") # dataset_to_push.push_to_hub(repo_name, config_name=f"subset_{dataset_id}", max_shard_size="2GiB") # dataset_to_push.push_to_hub(repo_name, config_name=f"subset_{dataset_id}", num_shards={"train": 1}) # while True: # try: # dataset_to_push.push_to_hub(repo_name, config_name=f"subset_{dataset_id}") # break # except Exception: # print(f"FAILED: push_to_hub on {repo_name} failed. wait 60 sec and retry soon...") # time.sleep(60)