Upload 14 files

Dockerfile

@@ -0,0 +1,27 @@
+FROM pytorch/pytorch:2.1.0-cuda12.1-cudnn8-runtime
+
+ENV NUMBA_CACHE_DIR=/tmp
+
+RUN apt update && apt install -y ffmpeg
+RUN apt-get install -y curl git gcc libxml2-dev libxslt1-dev zlib1g-dev g++ 
+
+RUN useradd -m -u 1000 user
+USER user
+
+WORKDIR /code
+
+RUN chmod 777 /code
+
+COPY . /code
+
+RUN pip install -U pip;
+RUN pip install wheel setuptools;
+RUN pip install -r /code/requirements.txt
+
+RUN git clone https://github.com/espnet/espnet.git
+RUN pip install -U -e /code/espnet
+
+EXPOSE 7860
+ENV GRADIO_SERVER_NAME="0.0.0.0"
+
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,268 @@
+import glob
+import os
+import shutil
+import sys
+import re
+import tempfile
+import zipfile
+from pathlib import Path
+
+import gradio as gr
+
+from finetune import finetune_model, baseline_model
+
+from language import languages
+from task import tasks
+import matplotlib.pyplot as plt
+
+
+os.environ['TEMP_DIR'] = tempfile.mkdtemp()
+
+def load_markdown():
+    with open("intro.md", "r") as f:
+        return f.read()
+
+
+def read_logs():
+    try:
+        with open(f"output.log", "r") as f:
+            return f.read()
+    except:
+        return None
+
+
+def plot_loss_acc(temp_dir, log_every):
+    sys.stdout.flush()
+    lines = []
+    with open("output.log", "r") as f:
+        for line in f.readlines():
+            if re.match(r"^\[\d+\] - loss: \d+\.\d+ - acc: \d+\.\d+$", line):
+                lines.append(line)
+    
+    losses = []
+    acces = []
+    if len(lines) == 0:
+        return None, None
+    
+    for line in lines:
+        _, loss, acc = line.split(" - ")
+        losses.append(float(loss.split(":")[1].strip()))
+        acces.append(float(acc.split(":")[1].strip()))
+    
+    x = [i * log_every for i in range(1, len(losses) + 1)]
+    
+    plt.plot(x, losses, label="loss")
+    plt.xlim(log_every // 2, x[-1] + log_every // 2)
+    plt.savefig(f"{temp_dir}/loss.png")
+    plt.clf()
+    plt.plot(x, acces, label="acc")
+    plt.xlim(log_every // 2, x[-1] + log_every // 2)
+    plt.savefig(f"{temp_dir}/acc.png")
+    plt.clf()
+    return f"{temp_dir}/acc.png", f"{temp_dir}/loss.png"
+
+
+def upload_file(fileobj, temp_dir):
+    """
+    Upload a file and check the uploaded zip file.
+    """
+    # First check if a file is a zip file.
+    if not zipfile.is_zipfile(fileobj.name):
+        raise gr.Error("Please upload a zip file.")
+
+    # Then unzip file
+    shutil.unpack_archive(fileobj.name, temp_dir)
+
+    # check zip file
+    if not os.path.exists(os.path.join(temp_dir, "text")):
+        raise gr.Error("Please upload a valid zip file.")
+
+    if not os.path.exists(os.path.join(temp_dir, "text_ctc")):
+        raise gr.Error("Please upload a valid zip file.")
+
+    if not os.path.exists(os.path.join(temp_dir, "audio")):
+        raise gr.Error("Please upload a valid zip file.")
+
+    # check if all texts and audio matches
+    audio_ids = []
+    with open(os.path.join(temp_dir, "text"), "r") as f:
+        for line in f.readlines():
+            audio_ids.append(line.split(maxsplit=1)[0])
+
+    with open(os.path.join(temp_dir, "text_ctc"), "r") as f:
+        ctc_audio_ids = []
+        for line in f.readlines():
+            ctc_audio_ids.append(line.split(maxsplit=1)[0])
+
+        if len(audio_ids) != len(ctc_audio_ids):
+            raise gr.Error(
+                f"Length of `text` ({len(audio_ids)}) and `text_ctc` ({len(ctc_audio_ids)}) is different."
+            )
+
+        if set(audio_ids) != set(ctc_audio_ids):
+            raise gr.Error(f"`text` and `text_ctc` have different audio ids.")
+
+    for audio_id in glob.glob(os.path.join(temp_dir, "audio", "*")):
+        if not Path(audio_id).stem in audio_ids:
+            raise gr.Error(f"Audio id {audio_id} is not in `text` or `text_ctc`.")
+
+    gr.Info("Successfully uploaded and validated zip file.")
+
+    return [fileobj]
+
+
+with gr.Blocks(title="OWSM-finetune") as demo:
+    tempdir_path = gr.State(os.environ['TEMP_DIR'])
+    gr.Markdown(
+        """# OWSM finetune demo!
+
+Finetune `owsm_v3.1_ebf_base` with your own dataset!
+Due to resource limitation, you can only train 50 epochs on maximum.
+
+## Upload dataset and define settings
+"""
+    )
+
+    # main contents
+    with gr.Row():
+        with gr.Column():
+            file_output = gr.File()
+            upload_button = gr.UploadButton("Click to Upload a File", file_count="single")
+            upload_button.upload(
+                upload_file, [upload_button, tempdir_path], [file_output]
+            )
+
+        with gr.Column():
+            lang = gr.Dropdown(
+                languages["espnet/owsm_v3.1_ebf_base"],
+                label="Language",
+                info="Choose language!",
+                value="jpn",
+                interactive=True,
+            )
+            task = gr.Dropdown(
+                tasks["espnet/owsm_v3.1_ebf_base"],
+                label="Task",
+                info="Choose task!",
+                value="asr",
+                interactive=True,
+            )
+
+    gr.Markdown("## Set training settings")
+
+    with gr.Row():
+        with gr.Column():
+            log_every = gr.Number(value=10, label="log_every", interactive=True)
+            max_epoch = gr.Slider(1, 10, step=1, label="max_epoch", interactive=True)
+            scheduler = gr.Dropdown(
+                ["warmuplr"], label="warmup", value="warmuplr", interactive=True
+            )
+            warmup_steps = gr.Number(
+                value=100, label="warmup_steps", interactive=True
+            )
+
+        with gr.Column():
+            optimizer = gr.Dropdown(
+                ["adam", "adamw", "sgd", "adadelta", "adagrad", "adamax", "asgd", "rmsprop"],
+                label="optimizer",
+                value="adam",
+                interactive=True
+            )
+            learning_rate = gr.Number(
+                value=1e-4, label="learning_rate", interactive=True
+            )
+            weight_decay = gr.Number(
+                value=0.000001, label="weight_decay", interactive=True
+            )
+
+    gr.Markdown("## Logs and plots")
+
+    with gr.Row():
+        with gr.Column():
+            log_output = gr.Textbox(
+                show_label=False,
+                interactive=False,
+                max_lines=23,
+                lines=23,
+            )
+            demo.load(read_logs, None, log_output, every=2)
+
+        with gr.Column():
+            log_acc = gr.Image(label="Accuracy", show_label=True, interactive=False)
+            log_loss = gr.Image(label="Loss", show_label=True, interactive=False)
+            demo.load(plot_loss_acc, [tempdir_path, log_every], [log_acc, log_loss], every=10)
+
+    with gr.Row():
+        with gr.Column():
+            ref_text = gr.Textbox(
+                label="Reference text",
+                show_label=True,
+                interactive=False,
+                max_lines=10,
+                lines=10,
+            )
+        with gr.Column():
+            base_text = gr.Textbox(
+                label="Baseline text",
+                show_label=True,
+                interactive=False,
+                max_lines=10,
+                lines=10,
+            )
+
+    with gr.Row():
+        with gr.Column():
+            hyp_text = gr.Textbox(
+                label="Hypothesis text",
+                show_label=True,
+                interactive=False,
+                max_lines=10,
+                lines=10,
+            )
+        with gr.Column():
+            trained_model = gr.File(
+                label="Trained model",
+                interactive=False,
+            )
+        
+    with gr.Row():
+        with gr.Column():
+            baseline_btn = gr.Button("Run Baseline", variant="secondary")
+            baseline_btn.click(
+                baseline_model,
+                [
+                    lang,
+                    task,
+                    tempdir_path,
+                ],
+                [ref_text, base_text]
+            )
+        with gr.Column():
+            finetune_btn = gr.Button("Finetune Model", variant="primary")
+            finetune_btn.click(
+                finetune_model,
+                [
+                    lang,
+                    task,
+                    tempdir_path,
+                    log_every,
+                    max_epoch,
+                    scheduler,
+                    warmup_steps,
+                    optimizer,
+                    learning_rate,
+                    weight_decay,
+                ],
+                [trained_model, hyp_text]
+            )
+
+    gr.Markdown(load_markdown())
+
+if __name__ == "__main__":
+    try:
+        demo.queue().launch()
+    except:
+        print("Unexpected error:", sys.exc_info()[0])
+        raise
+    finally:
+        shutil.rmtree(os.environ['TEMP_DIR'])

assets/owsm_ebf_v3.1_base/bpe.model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5d6327da127e870bcb8c737dceb3bd47ccbce63da74ddb094f64afe313d68c8c
+size 1041297

assets/owsm_ebf_v3.1_base/owsm_finetune_base.yaml

@@ -0,0 +1,40 @@
+
+seed: 2022
+num_workers: 4
+batch_type: numel
+batch_bins: 1600000
+accum_grad: 2
+max_epoch: 10
+patience: none
+init: none
+best_model_criterion:
+-   - valid
+    - acc
+    - max
+keep_nbest_models: 3
+use_amp: true
+
+optim: adam
+optim_conf:
+    lr: 0.0001
+    weight_decay: 0.000001
+scheduler: warmuplr
+scheduler_conf:
+    warmup_steps: 100
+
+specaug: specaug
+specaug_conf:
+    apply_time_warp: true
+    time_warp_window: 5
+    time_warp_mode: bicubic
+    apply_freq_mask: true
+    freq_mask_width_range:
+    - 0
+    - 27
+    num_freq_mask: 2
+    apply_time_mask: true
+    time_mask_width_ratio_range:
+    - 0.
+    - 0.05
+    num_time_mask: 5
+

assets/owsm_ebf_v3.1_base/owsm_v3.1_base.trained.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:99e5de1865e2c98308b41ce6f28b7f658bec7b274da60f37b219a99279d43f3a
+size 404971245

docker-compose.yaml

@@ -0,0 +1,5 @@
+services:
+  python_310:
+    build: .
+    ports:
+      - "7860:7860"

exp/s2t_stats_raw_bpe50000/train/feats_stats.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ef4b5e465110edf32eec024cf2427eedd677f5733bb87d6b2131e6984a6e13f
+size 1402

finetune.py

@@ -0,0 +1,290 @@
+import glob
+import sys
+from pathlib import Path
+import shutil
+
+from espnet2.tasks.s2t import S2TTask
+from espnet2.text.sentencepiece_tokenizer import SentencepiecesTokenizer
+from espnet2.text.token_id_converter import TokenIDConverter
+from espnet2.s2t.espnet_model import ESPnetS2TModel
+from espnet2.bin.s2t_inference import Speech2Text
+import espnetez as ez
+
+import torch
+import numpy as np
+import logging
+import gradio as gr
+import librosa
+
+
+class Logger:
+    def __init__(self, filename):
+        self.terminal = sys.stdout
+        self.log = open(filename, "w")
+
+    def write(self, message):
+        self.terminal.write(message)
+        self.log.write(message)
+
+    def flush(self):
+        self.terminal.flush()
+        self.log.flush()
+
+    def isatty(self):
+        return False
+
+
+sys.stdout = Logger("output.log")
+
+
+def count_parameters(model):
+    return sum(p.numel() for p in model.parameters() if p.requires_grad)
+
+
+def get_dataset(data_path, data_info, test_count=10):
+    # load data
+    data = {}
+    keys = []
+    with open(f"{data_path}/text", "r", encoding="utf-8") as f:
+        for line in f.readlines():
+            audio_id, text = line.split(maxsplit=1)
+            data[audio_id.strip()] = {"text": text.strip()}
+            keys.append(audio_id.strip())
+
+    # load text_ctc data
+    with open(f"{data_path}/text_ctc", "r", encoding="utf-8") as f:
+        for line in f.readlines():
+            audio_id, text = line.split(maxsplit=1)
+            data[audio_id.strip()]["text_ctc"] = text.strip()
+
+    # load audio path
+    for audio_path in glob.glob(f"{data_path}/audio/*"):
+        audio_id = Path(audio_path).stem
+        data[audio_id]["audio_path"] = audio_path
+    
+    # Convert to list
+    data = [{
+        'id': audio_id,
+        'text': data[audio_id]['text'],
+        'text_ctc': data[audio_id]['text_ctc'],
+        'audio_path': data[audio_id]['audio_path'],
+    } for audio_id in keys]
+
+    return ez.dataset.ESPnetEZDataset(data[test_count:], data_info), ez.dataset.ESPnetEZDataset(data[:test_count], data_info), data[:test_count]
+
+
+class CustomFinetuneModel(ESPnetS2TModel):
+    def __init__(self, model, log_every=500):
+        super().__init__(
+            vocab_size=model.vocab_size,
+            token_list=model.token_list,
+            frontend=model.frontend,
+            specaug=model.specaug,
+            normalize=model.normalize,
+            preencoder=model.preencoder,
+            encoder=model.encoder,
+            postencoder=model.postencoder,
+            decoder=model.decoder,
+            ctc=model.ctc,
+            ctc_weight=model.ctc_weight,
+            interctc_weight=model.interctc_weight,
+            ignore_id=model.ignore_id,
+            lsm_weight=0.0,
+            length_normalized_loss=False,
+            report_cer=False,
+            report_wer=False,
+            sym_space="<space>",
+            sym_blank="<blank>",
+            sym_sos = "<sos>",
+            sym_eos = "<eos>",
+            sym_sop = "<sop>",  # start of prev
+            sym_na = "<na>",  # not available
+            extract_feats_in_collect_stats=model.extract_feats_in_collect_stats,
+        )
+        self.iter_count = 0
+        self.log_every = log_every
+        self.log_stats = {
+            'loss': 0.0,
+            'acc': 0.0
+        }
+    
+    def forward(self, *args, **kwargs):
+        out = super().forward(*args, **kwargs)
+        self.log_stats['loss'] += out[1]['loss'].item()
+        self.log_stats['acc'] += out[1]['acc'].item()
+
+        self.iter_count += 1
+        if self.iter_count % self.log_every == 0:
+            loss = self.log_stats['loss'] / self.log_every
+            acc = self.log_stats['acc'] / self.log_every
+            print(f"[{self.iter_count}] - loss: {loss:.3f} - acc: {acc:.3f}")
+            self.log_stats['loss'] = 0.0
+            self.log_stats['acc'] = 0.0
+
+        return out
+
+
+def finetune_model(lang, task, tempdir_path, log_every, max_epoch, scheduler, warmup_steps, optimizer, learning_rate, weight_decay):
+    """Main function for finetuning the model."""
+    print("Start loading dataset...")
+    if len(tempdir_path) == 0:
+        raise gr.Error("Please upload a zip file first.")
+
+    # define tokenizer
+    tokenizer = SentencepiecesTokenizer("assets/owsm_ebf_v3.1_base/bpe.model")
+    converter = TokenIDConverter("assets/owsm_ebf_v3.1_base/tokens.txt")
+
+    def tokenize(text):
+        return np.array(converter.tokens2ids(tokenizer.text2tokens(text)))
+
+    data_info = {
+        "speech": lambda d: librosa.load(d["audio_path"], sr=16000)[0],
+        "text": lambda d: tokenize(f"<{lang}><{task}><notimestamps> {d['text']}"),
+        "text_ctc": lambda d: tokenize(d["text_ctc"]),
+        "text_prev": lambda d: tokenize("<na>"),
+    }
+
+    # load dataset and define data_info
+    train_dataset, test_dataset, test_list = get_dataset(tempdir_path, data_info)
+    print("Loaded dataset.")
+    gr.Info("Loaded dataset.")
+
+    # load and update configuration
+    print("Setting up the training configuration...")
+    pretrain_config = ez.config.from_yaml(
+        "s2t",
+        "assets/owsm_ebf_v3.1_base/config.yaml",
+    )
+    finetune_config = ez.config.update_finetune_config(
+        "s2t", pretrain_config, "assets/owsm_ebf_v3.1_base/owsm_finetune_base.yaml"
+    )
+    finetune_config['max_epoch'] = max_epoch
+    finetune_config['optim'] = optimizer
+    finetune_config['optim_conf']['lr'] = learning_rate
+    finetune_config['optim_conf']['weight_decay'] = weight_decay
+    finetune_config['scheduler'] = scheduler
+    finetune_config['scheduler_conf']['warmup_steps'] = warmup_steps
+    finetune_config['multiple_iterator'] = False
+    finetune_config['num_iters_per_epoch'] = None
+
+    def build_model_fn(args):
+        model, _ = S2TTask.build_model_from_file(
+            "assets/owsm_ebf_v3.1_base/config.yaml",
+            "assets/owsm_ebf_v3.1_base/owsm_v3.1_base.trained.pth",
+            device="cuda" if torch.cuda.is_available() else "cpu",
+        )
+        model.train()
+        print(f'Trainable parameters: {count_parameters(model)}')
+        model = CustomFinetuneModel(model, log_every=log_every)
+        return model
+
+    trainer = ez.Trainer(
+        task='s2t',
+        train_config=finetune_config,
+        train_dataset=train_dataset,
+        valid_dataset=test_dataset,
+        build_model_fn=build_model_fn, # provide the pre-trained model
+        data_info=data_info,
+        output_dir=f"{tempdir_path}/exp/finetune",
+        stats_dir=f"{tempdir_path}/exp/stats",
+        ngpu=1
+    )
+    gr.Info("start collect stats")
+    print("Start collect stats process...")
+    trainer.collect_stats()
+    gr.Info("Finished collect stats, starting training.")
+    print("Finished collect stats process. Start training.")
+    trainer.train()
+    gr.Info("Finished Fine-tuning! Archiving experiment files...")
+    print("Finished fine-tuning.")
+    print("Start archiving experiment files...")
+    print("Create zip file for the following files into `finetune.zip`:")
+    for f in glob.glob(f"{tempdir_path}/exp/finetune/*"):
+        print(f.replace(tempdir_path, ""))
+
+    shutil.make_archive(f"{tempdir_path}/finetune", 'zip', f"{tempdir_path}/exp/finetune")
+    gr.Info("Finished generating result file in zip!")
+    print("Finished archiving experiment files.")
+
+    print("Start generating test result...")
+    gr.Info("Start generating output for test set!")
+
+    del trainer
+    model = Speech2Text(
+        "assets/owsm_ebf_v3.1_base/config.yaml",
+        "assets/owsm_ebf_v3.1_base/owsm_v3.1_base.trained.pth",
+        device="cuda" if torch.cuda.is_available() else "cpu",
+        token_type="bpe",
+        bpemodel="assets/owsm_ebf_v3.1_base/bpe.model",
+        beam_size=5,
+        ctc_weight=0.3,
+        lang_sym=f"<{lang}>",
+        task_sym=f"<{task}>",
+    )
+    model.s2t_model.eval()
+    d = torch.load(f"{tempdir_path}/exp/finetune/valid.acc.ave.pth")
+    model.s2t_model.load_state_dict(d)
+    
+    hyp = ""
+    with open(f"{tempdir_path}/hyp.txt", "w") as f_hyp:
+        for i in range(len(test_list)):
+            data = test_list[i]
+            out = model(librosa.load(data['audio_path'], sr=16000)[0])[0][3]
+            f_hyp.write(out + '\n')
+            hyp += out + '\n'
+
+    return [f"{tempdir_path}/finetune.zip", f"{tempdir_path}/ref.txt", f"{tempdir_path}/base.txt", f"{tempdir_path}/hyp.txt"], hyp
+
+
+def baseline_model(lang, task, tempdir_path):
+    print("Start loading dataset...")
+    if len(tempdir_path) == 0:
+        raise gr.Error("Please upload a zip file first.")
+
+    # define tokenizer
+    tokenizer = SentencepiecesTokenizer("assets/owsm_ebf_v3.1_base/bpe.model")
+    converter = TokenIDConverter("assets/owsm_ebf_v3.1_base/tokens.txt")
+
+    def tokenize(text):
+        return np.array(converter.tokens2ids(tokenizer.text2tokens(text)))
+
+    data_info = {
+        "speech": lambda d: librosa.load(d["audio_path"], sr=16000)[0],
+        "text": lambda d: tokenize(f"<{lang}><{task}><notimestamps> {d['text']}"),
+        "text_ctc": lambda d: tokenize(d["text_ctc"]),
+        "text_prev": lambda d: tokenize("<na>"),
+    }
+
+    # load dataset and define data_info
+    train_dataset, test_dataset, test_list = get_dataset(tempdir_path, data_info)
+    print("Loaded dataset.")
+    gr.Info("Loaded dataset.")
+
+    print("Loading pretrained model...")
+    gr.Info("Loading pretrained model...")
+
+    model = Speech2Text(
+        "assets/owsm_ebf_v3.1_base/config.yaml",
+        "assets/owsm_ebf_v3.1_base/owsm_v3.1_base.trained.pth",
+        device="cuda" if torch.cuda.is_available() else "cpu",
+        token_type="bpe",
+        bpemodel="assets/owsm_ebf_v3.1_base/bpe.model",
+        beam_size=5,
+        ctc_weight=0.3,
+        lang_sym=f"<{lang}>",
+        task_sym=f"<{task}>",
+    )
+    model.s2t_model.eval()
+    
+    base = ""
+    ref = ""
+    with open(f"{tempdir_path}/base.txt", "w") as f_base, open(f"{tempdir_path}/ref.txt", "w") as f_ref:
+        for i in range(len(test_list)):
+            data = test_list[i]
+            f_ref.write(data['text'] + '\n')
+            out = model(librosa.load(data['audio_path'], sr=16000)[0])[0][3]
+            f_base.write(out + '\n')
+            ref += data['text'] + '\n'
+            base += out + '\n'
+
+    return ref, base

intro.md

@@ -0,0 +1,29 @@
+
+Please create the zip file in the following structure:
+
+```
+train.zip
+    - audio
+        - audio_id_1.wav
+        - audio_id_2.wav
+        - ...
+  
+    - text
+    - text_ctc
+```
+
+`text_ctc` should contain the transcription in the following format:
+
+```
+audio_id_1 transcription
+audio_id_2 transcription
+...
+```
+
+`text` should contain the text output in the following format:
+
+```
+audio_id_1 transcription or translated text
+audio_id_2 transcription or translated text
+...
+```

language.py

@@ -0,0 +1,155 @@
+languages = {
+    "espnet/owsm_v3.1_ebf_base": [
+        "abk",
+        "afr",
+        "amh",
+        "ara",
+        "asm",
+        "ast",
+        "aze",
+        "bak",
+        "bas",
+        "bel",
+        "ben",
+        "bos",
+        "bre",
+        "bul",
+        "cat",
+        "ceb",
+        "ces",
+        "chv",
+        "ckb",
+        "cmn",
+        "cnh",
+        "cym",
+        "dan",
+        "deu",
+        "dgd",
+        "div",
+        "ell",
+        "eng",
+        "epo",
+        "est",
+        "eus",
+        "fas",
+        "fil",
+        "fin",
+        "fra",
+        "frr",
+        "ful",
+        "gle",
+        "glg",
+        "grn",
+        "guj",
+        "hat",
+        "hau",
+        "heb",
+        "hin",
+        "hrv",
+        "hsb",
+        "hun",
+        "hye",
+        "ibo",
+        "ina",
+        "ind",
+        "isl",
+        "ita",
+        "jav",
+        "jpn",
+        "kab",
+        "kam",
+        "kan",
+        "kat",
+        "kaz",
+        "kea",
+        "khm",
+        "kin",
+        "kir",
+        "kmr",
+        "kor",
+        "lao",
+        "lav",
+        "lga",
+        "lin",
+        "lit",
+        "ltz",
+        "lug",
+        "luo",
+        "mal",
+        "mar",
+        "mas",
+        "mdf",
+        "mhr",
+        "mkd",
+        "mlt",
+        "mon",
+        "mri",
+        "mrj",
+        "mya",
+        "myv",
+        "nan",
+        "nep",
+        "nld",
+        "nno",
+        "nob",
+        "npi",
+        "nso",
+        "nya",
+        "oci",
+        "ori",
+        "orm",
+        "ory",
+        "pan",
+        "pol",
+        "por",
+        "pus",
+        "quy",
+        "roh",
+        "ron",
+        "rus",
+        "sah",
+        "sat",
+        "sin",
+        "skr",
+        "slk",
+        "slv",
+        "sna",
+        "snd",
+        "som",
+        "sot",
+        "spa",
+        "srd",
+        "srp",
+        "sun",
+        "swa",
+        "swe",
+        "swh",
+        "tam",
+        "tat",
+        "tel",
+        "tgk",
+        "tgl",
+        "tha",
+        "tig",
+        "tir",
+        "tok",
+        "tpi",
+        "tsn",
+        "tuk",
+        "tur",
+        "twi",
+        "uig",
+        "ukr",
+        "umb",
+        "urd",
+        "uzb",
+        "vie",
+        "vot",
+        "wol",
+        "xho",
+        "yor",
+        "yue",
+        "zho",
+        "zul",
+    ]
+}

requirements.txt

@@ -0,0 +1,2 @@
+gradio
+torchaudio

task.py

@@ -0,0 +1,30 @@
+tasks = {
+    "espnet/owsm_v3.1_ebf_base": [
+        "asr",
+        "st_ara",
+        "st_cat",
+        "st_ces",
+        "st_cym",
+        "st_deu",
+        "st_eng",
+        "st_est",
+        "st_fas",
+        "st_fra",
+        "st_ind",
+        "st_ita",
+        "st_jpn",
+        "st_lav",
+        "st_mon",
+        "st_nld",
+        "st_por",
+        "st_ron",
+        "st_rus",
+        "st_slv",
+        "st_spa",
+        "st_swe",
+        "st_tam",
+        "st_tur",
+        "st_vie",
+        "st_zho",
+    ]
+}