| 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() |
| |
| url_metadata_dict = { |
| "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 = f"{direction_speech}-{direction_text}" |
| if direction not in url_metadata_dict: |
| url_metadata_dict[direction] = f"https://dl.fbaipublicfiles.com/seamless/data/seamless.dataset.metadata.public.{direction}.withduration.tsv.gz" |
| cache_dir_feature = p_join("download", "feature", direction) |
| cache_dir_audio = p_join("download", "audio", direction) |
| os.makedirs(cache_dir_feature, exist_ok=True) |
| os.makedirs(p_join(cache_dir_audio, direction_speech), exist_ok=True) |
| |
| 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 |
|
|
| text_corpus = p_join("text_corpus", f"text.{direction_speech}-{direction_text}.json") |
| assert os.path.exists(text_corpus) |
| with open(text_corpus) as f: |
| line_no_to_text = json.load(f) |
|
|
|
|
| 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"] |
| 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 _unrelated_audio_file in glob(p_join(cache_dir_audio, direction_speech, f"{features['line_no']}.*")): |
| os.remove(_unrelated_audio_file) |
| |
| with open(feature_file, "w") as f: |
| json.dump({"dummy": "dummy"}, f) |
|
|
|
|
| def get_audio(dataframe: pd.DataFrame): |
| dataframe.pop("side") |
| features = {"line_no": int(dataframe.pop('line_no').values[0])} |
| if str(features["line_no"]) not in line_no_to_text: |
| return None |
| features[f"{direction_text}.text"] = line_no_to_text[str(features["line_no"])] |
| feature_file = p_join(cache_dir_feature, f'{features["line_no"]}.json') |
| features.update({f"{direction_speech}.{k}": to_json_serializable(v) for k, v in dataframe.iloc[0].to_dict().items()}) |
| identifier = os.path.basename(features[f"{direction_speech}.url"]).split(".")[-1] |
| features[f"{direction_speech}.path"] = p_join( |
| cache_dir_audio, direction_speech, f"{features['line_no']}.{identifier}" |
| ) |
| start, end = features[f"{direction_speech}.duration_start"], features[f"{direction_speech}.duration_end"] |
| if not os.path.exists(features[f"{direction_speech}.path"]): |
| print(f"WGET {features[f'{direction_speech}.url']}") |
| flag = wget(features[f"{direction_speech}.url"], output_file=features[f"{direction_speech}.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'{direction_speech}.path']}") |
| wav, sr = sf.read(features[f"{direction_speech}.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'{direction_speech}.path']}") |
| sf.write(features[f"{direction_speech}.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) == 1] |
| 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 = {} |
| data_dict.update({f"{direction_speech}.audio": [i.pop(f"{direction_speech}.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) |
| audio_dataset = audio_dataset.cast_column(f"{direction_speech}.audio", Audio()) |
| DatasetDict({"train": audio_dataset}).push_to_hub( |
| f"{hf_org}/{hf_dataset}", |
| config_name=f"subset_{dataset_id}" |
| ) |
|
|
