File size: 2,775 Bytes
c96a100 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 |
"""Chunked tokenization experiment."""
import os
from os.path import join as p_join
from datasets import load_dataset
import torch
import pandas as pd
from multibanddiffusion import MultiBandDiffusion
# configure experiment
cache_dir = p_join("experiment", "chunk_encoder")
os.makedirs(cache_dir, exist_ok=True)
num_codes = 3
mbd_model = MultiBandDiffusion.from_pretrained(num_codebooks_decoder=num_codes, num_codebooks_encoder=num_codes)
configs = [
[32000, 32000], # 1.3 sec chunk, 1.3 sec stride
[32000, 28800], # 1.3 sec chunk, 1.15 sec stride (32000 - 320 * 10)
[32000, 25600], # 1.3 sec chunk, 1 sec stride (32000 - 320 * 20)
[64000, 64000], # 2.6 sec chunk, 2.6 sec stride
[64000, 60800], # 2.6 sec chunk, 2.45 sec stride (64000 - 320 * 10)
[64000, 57600], # 2.6 sec chunk, 2.3 sec stride (64000 - 320 * 20)
]
def test_hf(hf_dataset: str, sample_size: int = 128, batch_size: int = 32):
dataset = load_dataset(hf_dataset, split="test")
dataset = dataset.select(range(sample_size))
dataset = dataset.map(
lambda batch: {k: [v] for k, v in batch.items()},
batched=True,
batch_size=batch_size
)
full_accuracy_table = []
for data in dataset:
sr_list = [d["sampling_rate"] for d in data["audio"]]
assert len(set(sr_list)) == 1, sr_list
sr = sr_list[0]
array = [d["array"] for d in data["audio"]]
max_length = max([len(a) for a in array])
array = [a + [0] * (max_length - len(a)) for a in array]
wav = torch.as_tensor(array, dtype=torch.float32).unsqueeze_(1)
tokens_original = mbd_model.wav_to_tokens(wav, sr)
total_vars = tokens_original.shape.numel()
accuracy_table = {}
for chunk, stride in configs:
tokens = mbd_model.wav_to_tokens(wav, sr, chunk_length=chunk, stride=stride)
assert tokens_original.shape == tokens.shape, f"{tokens_original.shape} != {tokens.shape}"
accuracy = {"full": (tokens_original == tokens).sum().item() / total_vars * 100}
accuracy.update({f"code_{c + 1}": (tokens_original[0, c, :] == tokens[0, c, :]).sum().item() / tokens_original.shape[2] * 100 for c in range(num_codes)})
accuracy_table[f"chunk_{chunk}.stride_{stride}"] = accuracy
full_accuracy_table.append(accuracy_table)
df_accuracy = sum(pd.DataFrame(accuracy_table) for accuracy_table in full_accuracy_table)/len(full_accuracy_table)
df_accuracy.to_csv(p_join(cache_dir, f"token_accuracy.{os.path.basename(hf_dataset)}.{num_codes}codes.csv"))
if __name__ == '__main__':
test_hf("japanese-asr/ja_asr.reazonspeech_test", sample_size=64, batch_size=16)
test_hf("japanese-asr/ja_asr.jsut_basic5000", sample_size=64, batch_size=16)
|