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_speech = os.getenv("DIRECTION_SPEECH", "enA") direction_text = os.getenv("DIRECTION_TEXT", "jpn") direction = os.getenv("DIRECTION", "enA-jpn") 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] print(f"SAVING: {features[f'{side}.path']}") sf.write(features[f"{side}.path"], wav, sr) # if sr != sampling_rate: # print(f"RESAMPLING: {wav.shape} length audio") # wav = librosa.resample(wav, orig_sr=sr, target_sr=sampling_rate) # sf.write(features[f"{side}.path"], wav[start:end], sampling_rate) 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)}") 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) 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)