init

download_audio.py

@@ -1,234 +0,0 @@
-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-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
-
-
-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)
-
-

encodec_audio_tokenizer.py

@@ -0,0 +1,123 @@
+"""https://github.com/facebookresearch/audiocraft/blob/main/audiocraft/models/multibanddiffusion.py"""
+import logging
+from typing import Optional, List
+from math import ceil
+import torch
+import julius
+
+from tqdm import tqdm
+from audiocraft.models.encodec import CompressionModel
+from audiocraft.solvers.compression import CompressionSolver
+
+
+class BaseEncodecTokenizer:
+
+    def __init__(self,
+                 codec_model: CompressionModel,
+                 sample_per_token: int = 320,
+                 num_codebooks_encoder: Optional[int] = None) -> None:
+        """Base class for multi-band diffusion.
+        Args:
+            codec_model (CompressionModel): Underlying compression model used to obtain discrete tokens.
+            sample_per_token (int): Number of sample per token (320 for 24kHz encodec).
+            num_codebooks_encoder (int): Number of codebook to use for encoder (default full code).
+        """
+        self.codec_model = codec_model
+        self.device = next(self.codec_model.parameters()).device
+        self.sample_per_token = sample_per_token
+        self.num_codebooks_encoder = num_codebooks_encoder
+
+    @property
+    def sample_rate(self) -> int:
+        return self.codec_model.sample_rate
+
+    @torch.no_grad()
+    def wav_to_tokens(self,
+                      wav: torch.Tensor,
+                      sample_rate: List[int],
+                      cpu_offload: bool = True,
+                      chunk_length: Optional[int] = None,
+                      stride: Optional[int] = None,
+                      concat_strategy: str = "first") -> torch.Tensor:
+        """Get audio tokens from waveform in batch. Note that Encodec generates 75 tokens per second of audio at 24 kHz
+        meaning 320 samples (13.333 msec) per tokens.
+        Args:
+            wav (torch.Tensor): The audio that we want to extract the conditioning from (batch, channel, wav).
+            sample_rate (int): Sample rate of the audio.
+            cpu_offload (bool): Move the output tokens to cpu on the fly to save cuda memory.
+            chunk_length (int): Chunk length to split a long audio (sample size, must be divisible by sample_per_token).
+            stride (int): Stride over chunked audio (sample size, must be divisible by sample_per_token).
+            concat_strategy (str): "first" or "last" to indicate which chunk to use when consolidating the overlap.
+        """
+        # sanity check
+        if wav.ndim != 3:
+            raise ValueError(f"wav should be (batch, channel, time): {wav.ndim} dims")
+        original_device = wav.device
+        # sampling audio
+        assert len(sample_rate) == len(wav)
+        new_wav = []
+        for sr, single_wav in zip(sample_rate, wav):
+            if sr != self.sample_rate:
+                single_wav = julius.resample_frac(single_wav, sr, self.sample_rate)
+            new_wav.append(single_wav)
+        wav = torch.concat(new_wav)
+        batch_size, channels, input_length = wav.shape
+        if channels > 1:
+            logging.warning("Audio has more than one channel but encoder takes the first channel only.")
+        # validate chunk length and stride (if None, do one-shot process)
+        if chunk_length:
+            if chunk_length % self.sample_per_token != 0:
+                raise ValueError(f"chunk_length must be divisible by {self.sample_per_token}: {chunk_length}")
+        else:
+            chunk_length = input_length
+        chunk_length_latent = ceil(chunk_length / self.sample_per_token)
+        if stride:
+            if stride % self.sample_per_token != 0:
+                raise ValueError(f"stride must be divisible by {self.sample_per_token}: {stride}")
+        else:
+            stride = chunk_length
+        stride_latent = ceil(stride / self.sample_per_token)
+        # initialize the token tensor
+        num_tokens = ceil(input_length / self.sample_per_token)
+        num_filters = self.codec_model.model.config.num_filters
+        if self.num_codebooks_encoder is not None:
+            if self.num_codebooks_encoder > num_filters:
+                raise ValueError(f"num_codebooks_encoder must be smaller than {num_filters}")
+            num_filters = self.num_codebooks_encoder
+        tokens = torch.zeros(
+            (batch_size, num_filters, num_tokens),
+            device="cpu" if cpu_offload else original_device,
+            dtype=torch.int64
+        )
+        # tokenize by chunk in a sequential manner
+        for offset in tqdm(list(range(0, input_length - chunk_length + stride, stride))):
+            frame = wav[:, :1, offset: offset + chunk_length]
+            tmp_tokens, _ = self.codec_model.encode(frame.to(self.device))
+            offset_latent = int(offset / self.sample_per_token)
+            tmp_tokens = tmp_tokens.to("cpu") if cpu_offload else tmp_tokens.to(original_device)
+            if concat_strategy == "last" or offset == 0:
+                tokens[:, :, offset_latent: offset_latent + chunk_length_latent] = tmp_tokens[:, :num_filters, :]
+            else:
+                overlap_token = chunk_length_latent - stride_latent
+                tokens[:, :, offset_latent + overlap_token: offset_latent + chunk_length_latent] \
+                    = tmp_tokens[:, :num_filters, overlap_token:]
+        return tokens
+
+
+class EncodecTokenizer:
+
+    @staticmethod
+    def from_pretrained(num_codebooks_encoder: Optional[int] = None) -> BaseEncodecTokenizer:
+        """Get the pretrained Models for MultiBandDiffusion.
+        Args:
+            num_codebooks_encoder (int): Number of codebook to use for encoder (default full code).
+        """
+        device = 'cuda' if torch.cuda.is_available() else 'cpu'
+        codec_model = CompressionSolver.model_from_checkpoint(
+            '//pretrained/facebook/encodec_24khz', device=device
+        )
+        codec_model = codec_model.to(device)
+        return BaseEncodecTokenizer(
+            codec_model=codec_model,
+            num_codebooks_encoder=num_codebooks_encoder
+        )

main_s2s.sh

@@ -19,16 +19,6 @@ do
   python fetch_dataset_s2s.py
 done
 
-######################
-# enA-zhA: 1_289_192 #
-######################
-# test
-export DATASET_ID=test
-export DIRECTION="enA-zhA"
-export LINE_NO_START=0
-export LINE_NO_END=10
-python fetch_dataset_s2s.py
-
 ####################
 # enA-viA: 740_598 #
 ####################
@@ -49,6 +39,16 @@ do
   echo ${LINE_NO_START}
   python fetch_dataset_s2s.py
 done
+for i in $(seq 41 80);
+do
+  export N_POOL=15
+  export DATASET_ID=${i}
+  export DIRECTION="enA-viA"
+  export LINE_NO_START=$(((DATASET_ID-1) * 2500))
+  export LINE_NO_END=$((DATASET_ID * 2500))
+  echo ${LINE_NO_START}
+  python fetch_dataset_s2s.py
+done
 
 ####################
 # enA-koA: 511_358 #
@@ -59,6 +59,27 @@ export DIRECTION="enA-koA"
 export LINE_NO_START=0
 export LINE_NO_END=10
 python fetch_dataset_s2s.py
+# main
+for i in $(seq 1 50);
+do
+  export N_POOL=15
+  export DATASET_ID=${i}
+  export DIRECTION="enA-koA"
+  export LINE_NO_START=$(((DATASET_ID-1) * 2500))
+  export LINE_NO_END=$((DATASET_ID * 2500))
+  echo ${LINE_NO_START}
+  python fetch_dataset_s2s.py
+done
+for i in $(seq 51 100);
+do
+  export N_POOL=15
+  export DATASET_ID=${i}
+  export DIRECTION="enA-koA"
+  export LINE_NO_START=$(((DATASET_ID-1) * 2500))
+  export LINE_NO_END=$((DATASET_ID * 2500))
+  echo ${LINE_NO_START}
+  python fetch_dataset_s2s.py
+done
 
 ####################
 # enA-hiA: 454_942 #
@@ -69,6 +90,48 @@ export DIRECTION="enA-hiA"
 export LINE_NO_START=0
 export LINE_NO_END=10
 python fetch_dataset_s2s.py
+# main
+for i in $(seq 1 50);
+do
+  export N_POOL=15
+  export DATASET_ID=${i}
+  export DIRECTION="enA-hiA"
+  export LINE_NO_START=$(((DATASET_ID-1) * 2500))
+  export LINE_NO_END=$((DATASET_ID * 2500))
+  echo ${LINE_NO_START}
+  python fetch_dataset_s2s.py
+done
+for i in $(seq 51 91);
+do
+  export N_POOL=15
+  export DATASET_ID=${i}
+  export DIRECTION="enA-hiA"
+  export LINE_NO_START=$(((DATASET_ID-1) * 2500))
+  export LINE_NO_END=$((DATASET_ID * 2500))
+  echo ${LINE_NO_START}
+  python fetch_dataset_s2s.py
+done
+
+######################
+# enA-zhA: 1_289_192 #
+######################
+# test
+export DATASET_ID=test
+export DIRECTION="enA-zhA"
+export LINE_NO_START=0
+export LINE_NO_END=10
+python fetch_dataset_s2s.py
+# main
+for i in $(seq 1 100);
+do
+  export N_POOL=15
+  export DATASET_ID=${i}
+  export DIRECTION="enA-viA"
+  export LINE_NO_START=$(((DATASET_ID-1) * 2500))
+  export LINE_NO_END=$((DATASET_ID * 2500))
+  echo ${LINE_NO_START}
+  python fetch_dataset_s2s.py
+done
 
 ######################
 # enA-frA: 3_054_258 #
@@ -79,6 +142,17 @@ export DIRECTION="enA-frA"
 export LINE_NO_START=0
 export LINE_NO_END=10
 python fetch_dataset_s2s.py
+# main
+for i in $(seq 1 100);
+do
+  export N_POOL=15
+  export DATASET_ID=${i}
+  export DIRECTION="enA-viA"
+  export LINE_NO_START=$(((DATASET_ID-1) * 2500))
+  export LINE_NO_END=$((DATASET_ID * 2500))
+  echo ${LINE_NO_START}
+  python fetch_dataset_s2s.py
+done
 
 ######################
 # enA-esA: 2_658_022 #

main_s2t.sh

@@ -53,7 +53,7 @@ for i in $(seq 1 ${CHUNK_SIZE});
 do
   cat seamless.dataset.metadata.public.${DIRECTION_SPEECH}-${DIRECTION_TEXT}.withduration.reordered.batch_${i}.tsv | egrep ^crawl-data | tr '\t' ' ' | wet_lines | tee metadata.${DIRECTION_SPEECH}-${DIRECTION_TEXT}.batch_1.tsv &
 done
-python format_text.py
+#python format_text.py
 
 ########
 # NLLB #

requirements.txt

@@ -1,6 +0,0 @@
-datasets
-soundfile
-librosa
-requests
-pandas
-julius

tokenize_dataset_s2s.py

@@ -0,0 +1,38 @@
+import os
+
+import torch
+from datasets import load_dataset, DatasetDict
+from encodec_audio_tokenizer import EncodecTokenizer
+
+
+direction = os.getenv("DIRECTION", "enA-jaA")
+sides = set(direction.split("-"))
+dataset_id = os.getenv("DATASET_ID", 0)
+batch_size = int(os.getenv("BATCH_SIZE", 64))
+num_proc = int(os.getenv("NUM_PROC", 1))
+hf_org = os.getenv("HF_ORG", "asahi417")
+hf_dataset = f"seamless-align-{direction}"
+dataset = load_dataset(f"{hf_org}/{hf_dataset}", config_name=f"subset_{dataset_id}", split="train")
+tokenizer = EncodecTokenizer.from_pretrained()
+
+
+def tokenize(batch):
+    for side in sides:
+        wav = torch.concat([i["array"] for i in batch[f"{side}.audio"]])
+        sr = [i["sampling_rate"] for i in batch[f"{side}.audio"]]
+        batch[f"{side}.audio.tokens"] = tokenizer.wav_to_tokens(wav=wav, sample_rate=sr).numpy().tolist()
+    return batch
+
+
+dataset = dataset.map(
+    function=tokenize,
+    remove_columns=[f"{s}.audio" for s in sides] + [f"{s}.url" for s in sides] + [f"{s}.duration_start" for s in sides] + [f"{s}.duration_end" for s in sides],
+    batched=True,
+    batch_size=batch_size,
+    num_proc=num_proc,
+    desc="tokenize dataset"
+)
+DatasetDict({"train": dataset}).push_to_hub(
+        f"{hf_org}/{hf_dataset}.tokenized",
+        config_name=f"subset_{dataset_id}"
+    )