update

exception.py

@@ -0,0 +1,8 @@
+
+
+class ExpectedError(Exception):
+    def __init__(self, status_code, message, traceback="", detail=""):
+        self.status_code = status_code
+        self.message = message
+        self.traceback = traceback
+        self.detail = detail

log.py

@@ -0,0 +1,110 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import logging
+from logging.handlers import TimedRotatingFileHandler
+import os
+
+
+def setup(log_directory: str):
+    fmt = "%(asctime)s - %(name)s - %(levelname)s  %(filename)s:%(lineno)d >  %(message)s"
+
+    stream_handler = logging.StreamHandler()
+    stream_handler.setLevel(logging.INFO)
+    stream_handler.setFormatter(logging.Formatter(fmt))
+
+    # main
+    main_logger = logging.getLogger("main")
+    main_logger.addHandler(stream_handler)
+    main_info_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "main.log"),
+        encoding="utf-8",
+        when="midnight", 
+        interval=1, 
+        backupCount=30
+    )
+    main_info_file_handler.setLevel(logging.INFO)
+    main_info_file_handler.setFormatter(logging.Formatter(fmt))
+    main_logger.addHandler(main_info_file_handler)
+
+    # http
+    http_logger = logging.getLogger("http")
+    http_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "http.log"),
+        encoding='utf-8',
+        when="midnight",
+        interval=1,
+        backupCount=30
+    )
+    http_file_handler.setLevel(logging.DEBUG)
+    http_file_handler.setFormatter(logging.Formatter(fmt))
+    http_logger.addHandler(http_file_handler)
+
+    # api
+    api_logger = logging.getLogger("api")
+    api_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "api.log"),
+        encoding='utf-8',
+        when="midnight",
+        interval=1,
+        backupCount=30
+    )
+    api_file_handler.setLevel(logging.DEBUG)
+    api_file_handler.setFormatter(logging.Formatter(fmt))
+    api_logger.addHandler(api_file_handler)
+
+    # alarm
+    alarm_logger = logging.getLogger("alarm")
+    alarm_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "alarm.log"),
+        encoding="utf-8",
+        when="midnight",
+        interval=1,
+        backupCount=30
+    )
+    alarm_file_handler.setLevel(logging.DEBUG)
+    alarm_file_handler.setFormatter(logging.Formatter(fmt))
+    alarm_logger.addHandler(alarm_file_handler)
+
+    debug_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "debug.log"),
+        encoding="utf-8",
+        when="D",
+        interval=1,
+        backupCount=7
+    )
+    debug_file_handler.setLevel(logging.DEBUG)
+    debug_file_handler.setFormatter(logging.Formatter(fmt))
+
+    info_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "info.log"),
+        encoding="utf-8",
+        when="D",
+        interval=1,
+        backupCount=7
+    )
+    info_file_handler.setLevel(logging.INFO)
+    info_file_handler.setFormatter(logging.Formatter(fmt))
+
+    error_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "error.log"),
+        encoding="utf-8",
+        when="D",
+        interval=1,
+        backupCount=7
+    )
+    error_file_handler.setLevel(logging.ERROR)
+    error_file_handler.setFormatter(logging.Formatter(fmt))
+
+    logging.basicConfig(
+        level=logging.DEBUG,
+        datefmt="%a, %d %b %Y %H:%M:%S",
+        handlers=[
+            debug_file_handler,
+            info_file_handler,
+            error_file_handler,
+        ]
+    )
+
+
+if __name__ == "__main__":
+    pass

main.py

@@ -2,25 +2,36 @@
 # -*- coding: utf-8 -*-
 import argparse
 from collections import defaultdict
+from datetime import datetime
+import functools
+import io
+import logging
+from pathlib import Path
 import platform
+import time
+
+from project_settings import project_path, log_directory
+import log
+
+log.setup(log_directory=log_directory)
 
 import gradio as gr
+import torch
+import torchaudio
 
-from examples import examples
-from models import model_map
-from project_settings import project_path
+from toolbox.k2_sherpa.examples import examples
+from toolbox.k2_sherpa import decode, models
+from toolbox.k2_sherpa.utils import audio_convert
+
+main_logger = logging.getLogger("main")
 
 
 def get_args():
     parser = argparse.ArgumentParser()
+
     parser.add_argument(
-        "--examples_dir",
-        default=(project_path / "data/examples").as_posix(),
-        type=str
-    )
-    parser.add_argument(
-        "--trained_model_dir",
-        default=(project_path / "trained_models").as_posix(),
+        "--pretrained_model_dir",
+        default=(project_path / "pretrained_models").as_posix(),
         type=str
     )
     args = parser.parse_args()
@@ -28,10 +39,10 @@ def get_args():
 
 
 def update_model_dropdown(language: str):
-    if language not in model_map.keys():
+    if language not in models.model_map.keys():
         raise ValueError(f"Unsupported language: {language}")
 
-    choices = model_map[language]
+    choices = models.model_map[language]
     choices = [c["repo_id"] for c in choices]
     return gr.Dropdown(
         choices=choices,
@@ -50,14 +61,109 @@ def build_html_output(s: str, style: str = "result_item_success"):
     """
 
 
+@torch.no_grad()
+def process(
+    language: str,
+    repo_id: str,
+    decoding_method: str,
+    num_active_paths: int,
+    add_punctuation: str,
+    in_filename: str,
+    pretrained_model_dir: Path,
+):
+    main_logger.info("language: {}".format(language))
+    main_logger.info("repo_id: {}".format(repo_id))
+    main_logger.info("decoding_method: {}".format(decoding_method))
+    main_logger.info("num_active_paths: {}".format(num_active_paths))
+    main_logger.info("in_filename: {}".format(in_filename))
+
+    m_list = models.model_map.get(language)
+    if m_list is None:
+        raise AssertionError("language invalid: {}".format(language))
+
+    m_dict = None
+    for m in m_list:
+        if m["repo_id"] == repo_id:
+            m_dict = m
+    if m_dict is None:
+        raise AssertionError("repo_id invalid: {}".format(repo_id))
+
+    local_model_dir = pretrained_model_dir / "huggingface" / repo_id
+
+    out_filename = io.BytesIO()
+    audio_convert(in_filename, out_filename)
+
+    recognizer = models.load_recognizer(
+        repo_id=m_dict["repo_id"],
+        nn_model_file=m_dict["nn_model_file"],
+        tokens_file=m_dict["tokens_file"],
+        sub_folder=m_dict["sub_folder"],
+        local_model_dir=local_model_dir,
+        recognizer_type=m_dict["recognizer_type"],
+        decoding_method=decoding_method,
+        num_active_paths=num_active_paths,
+    )
+
+    now = datetime.now()
+    date_time = now.strftime("%Y-%m-%d %H:%M:%S.%f")
+    logging.info(f"Started at {date_time}")
+    start = time.time()
+
+    text = decode.decode_by_recognizer(recognizer=recognizer,
+                                       filename=out_filename,
+                                       )
+
+    date_time = now.strftime("%Y-%m-%d %H:%M:%S.%f")
+    end = time.time()
+
+    metadata = torchaudio.info(out_filename)
+    duration = metadata.num_frames / 16000
+    rtf = (end - start) / duration
+
+    main_logger.info(f"Finished at {date_time} s. Elapsed: {end - start: .3f} s")
+
+    info = f"""
+    Wave duration  : {duration: .3f} s <br/>
+    Processing time: {end - start: .3f} s <br/>
+    RTF: {end - start: .3f}/{duration: .3f} = {rtf:.3f} <br/>
+    """
+
+    main_logger.info(info)
+    main_logger.info(f"\nrepo_id: {repo_id}\nhyp: {text}")
+
+    return text, build_html_output(info)
+
+
 def process_uploaded_file(language: str,
                           repo_id: str,
                           decoding_method: str,
                           num_active_paths: int,
                           add_punctuation: str,
                           in_filename: str,
+                          pretrained_model_dir: Path,
                           ):
-    return "Dummy", build_html_output("Dummy")
+    if in_filename is None or in_filename == "":
+        return "", build_html_output(
+            "Please first upload a file and then click "
+            'the button "submit for recognition"',
+            "result_item_error",
+        )
+    main_logger.info(f"Processing uploaded file: {in_filename}")
+
+    try:
+        return process(
+            in_filename=in_filename,
+            language=language,
+            repo_id=repo_id,
+            decoding_method=decoding_method,
+            num_active_paths=num_active_paths,
+            add_punctuation=add_punctuation,
+            pretrained_model_dir=pretrained_model_dir,
+        )
+    except Exception as e:
+        msg = "transcribe error: {}".format(str(e))
+        main_logger.info(msg)
+        return "", build_html_output(msg, "result_item_error")
 
 
 # css style is copied from
@@ -71,12 +177,22 @@ css = """
 
 
 def main():
+    args = get_args()
+
+    pretrained_model_dir = Path(args.pretrained_model_dir)
+    pretrained_model_dir.mkdir(exist_ok=True)
+
+    process_uploaded_file_ = functools.partial(
+        process_uploaded_file,
+        pretrained_model_dir=pretrained_model_dir,
+    )
+
     title = "# Automatic Speech Recognition with Next-gen Kaldi"
 
-    language_choices = list(model_map.keys())
+    language_choices = list(models.model_map.keys())
 
     language_to_models = defaultdict(list)
-    for k, v in model_map.items():
+    for k, v in models.model_map.items():
         for m in v:
             repo_id = m["repo_id"]
             language_to_models[k].append(repo_id)
@@ -134,11 +250,11 @@ def main():
                         uploaded_file,
                     ],
                     outputs=[uploaded_output, uploaded_html_info],
-                    fn=process_uploaded_file,
+                    fn=process_uploaded_file_,
                 )
 
             upload_button.click(
-                process_uploaded_file,
+                process_uploaded_file_,
                 inputs=[
                     language_radio,
                     model_dropdown,

project_settings.py

@@ -7,6 +7,9 @@ from pathlib import Path
 project_path = os.path.abspath(os.path.dirname(__file__))
 project_path = Path(project_path)
 
+log_directory = project_path / "log"
+log_directory.mkdir(parents=True, exist_ok=True)
+
 temp_directory = project_path / "temp"
 temp_directory.mkdir(parents=True, exist_ok=True)
 

toolbox/__init__.py

@@ -0,0 +1,5 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+if __name__ == "__main__":
+    pass

toolbox/k2_sherpa/__init__.py

@@ -0,0 +1,5 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+if __name__ == "__main__":
+    pass

models.py → toolbox/k2_sherpa/models.py

@@ -24,35 +24,36 @@ model_map = {
     "Chinese": [
         {
             "repo_id": "csukuangfj/wenet-chinese-model",
-            "model_file": "final.zip",
+            "nn_model_file": "final.zip",
             "tokens_file": "units.txt",
             "subfolder": ".",
+            "recognizer_type": EnumRecognizerType.sherpa_offline_recognizer.value,
         }
     ]
 }
 
 
 def download_model(repo_id: str,
-                   nn_model_filename: str,
-                   tokens_filename: str,
+                   nn_model_file: str,
+                   tokens_file: str,
                    sub_folder: str,
                    local_model_dir: str,
                    ):
 
-    nn_model_filename = huggingface_hub.hf_hub_download(
+    nn_model_file = huggingface_hub.hf_hub_download(
         repo_id=repo_id,
-        filename=nn_model_filename,
+        filename=nn_model_file,
         subfolder=sub_folder,
         local_dir=local_model_dir,
     )
 
-    tokens_filename = huggingface_hub.hf_hub_download(
+    tokens_file = huggingface_hub.hf_hub_download(
         repo_id=repo_id,
-        filename=tokens_filename,
+        filename=tokens_file,
         subfolder=sub_folder,
         local_dir=local_model_dir,
     )
-    return nn_model_filename, tokens_filename
+    return nn_model_file, tokens_file
 
 
 @lru_cache(maxsize=10)
@@ -82,25 +83,34 @@ def load_sherpa_offline_recognizer(nn_model_file: str,
     return recognizer
 
 
-def load_recognizer(
-                    repo_id: str,
-                    nn_model_filename: str,
-                    tokens_filename: str,
+def load_recognizer(repo_id: str,
+                    nn_model_file: str,
+                    tokens_file: str,
                     sub_folder: str,
                     local_model_dir: str,
-                    recognizer_type: EnumRecognizerType,
+                    recognizer_type: str,
                     decoding_method: EnumDecodingMethod = EnumDecodingMethod.greedy_search,
+                    num_active_paths: int = 4,
                     ):
     if not os.path.exists(local_model_dir):
         download_model(
             repo_id=repo_id,
-            nn_model_filename=nn_model_filename,
-            tokens_filename=tokens_filename,
+            nn_model_file=nn_model_file,
+            tokens_file=tokens_file,
             sub_folder=sub_folder,
             local_model_dir=local_model_dir,
         )
 
-    return
+    if recognizer_type == EnumRecognizerType.sherpa_offline_recognizer.value:
+        recognizer = load_sherpa_offline_recognizer(
+            nn_model_file=nn_model_file,
+            tokens_file=tokens_file,
+            decoding_method=decoding_method,
+            num_active_paths=num_active_paths,
+        )
+    else:
+        raise NotImplementedError("recognizer_type not support: {}".format(recognizer_type.value))
+    return recognizer
 
 
 if __name__ == "__main__":

toolbox/k2_sherpa/utils.py

@@ -0,0 +1,24 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import librosa
+import numpy as np
+from scipy.io import wavfile
+
+
+def audio_convert(in_filename: str,
+                  out_filename: str,
+                  sample_rate: int = 16000):
+    signal, _ = librosa.load(in_filename, sr=sample_rate)
+    signal *= 32768.0
+    signal = np.array(signal, dtype=np.int16)
+
+    wavfile.write(
+        out_filename,
+        rate=sample_rate,
+        data=signal
+    )
+    return out_filename
+
+
+if __name__ == "__main__":
+    pass