sonusai 0.18.7__tar.gz → 0.18.8__tar.gz

{sonusai-0.18.7 → sonusai-0.18.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sonusai
-Version: 0.18.7
+Version: 0.18.8
 Summary: Framework for building deep neural network models for sound, speech, and voice AI
 Home-page: https://aaware.com
 License: GPL-3.0-only

{sonusai-0.18.7 → sonusai-0.18.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "sonusai"
-version = "0.18.7"
+version = "0.18.8"
 description = "Framework for building deep neural network models for sound, speech, and voice AI"
 authors = ["Chris Eddington <chris@aaware.com>", "Jason Calderwood <jason@aaware.com>"]
 maintainers = ["Chris Eddington <chris@aaware.com>", "Jason Calderwood <jason@aaware.com>"]

{sonusai-0.18.7 → sonusai-0.18.8}/sonusai/__init__.py

@@ -24,7 +24,6 @@ commands_doc = """
    mkwav                        Make WAV files from a mixture database
    onnx_predict                 Run ONNX predict on a trained model
    plot                         Plot mixture data
-   post_spenh_targetf           Run post-processing for speech enhancement targetf data
    summarize_metric_spenh       Summarize speech enhancement and analysis results
    tplot                        Plot truth data
    vars                         List custom SonusAI variables

{sonusai-0.18.7 → sonusai-0.18.8}/sonusai/mixture/helpers.py

@@ -276,7 +276,6 @@ def read_mixture_data(name: str, items: list[str] | str) -> Any:
     :return: Data (or tuple of data)
     """
     from os.path import exists
-    from typing import Any
 
     import h5py
     import numpy as np
@@ -287,7 +286,10 @@ def read_mixture_data(name: str, items: list[str] | str) -> Any:
         if d_name in file:
             data = np.array(file[d_name])
             if data.size == 1:
-                return data.item()
+                item = data.item()
+                if isinstance(item, bytes):
+                    return item.decode('utf-8')
+                return item
             return data
         return None
 

{sonusai-0.18.7 → sonusai-0.18.8}/sonusai/mixture/mixdb.py

@@ -214,6 +214,10 @@ class MixtureDatabase:
             MetricDoc('Truth Metrics', 'sedtopn', '(not implemented) N most active by largest sedavg [N, 1]'),
         ])
         for name in self.asr_configs:
+            metrics.append(MetricDoc('Target Metrics', f'tasr.{name}',
+                                     f'Target[0] ASR text using {name} ASR as defined in mixdb asr_configs parameter'))
+            metrics.append(MetricDoc('Mixture Metrics', f'mxasr.{name}',
+                                     f'ASR text using {name} ASR as defined in mixdb asr_configs parameter'))
             metrics.append(MetricDoc('Mixture Metrics', f'mxwer.{name}',
                                      f'Word error rate using {name} ASR as defined in mixdb asr_configs parameter'))
 
@@ -1185,7 +1189,7 @@ class MixtureDatabase:
 
     def mixture_metrics(self, m_id: int,
                         metrics: list[str],
-                        force: bool = False) -> list[float | int | Segsnr]:
+                        force: bool = False) -> list[float | int | str | Segsnr]:
         """Get metrics data for the given mixture ID
 
         :param m_id: Zero-based mixture ID
@@ -1328,7 +1332,56 @@ class MixtureDatabase:
 
         noise_stats = create_noise_stats()
 
-        def calc(m: str) -> float | int | Segsnr:
+        def create_asr_config() -> Callable[[str], dict]:
+            state: dict[str, dict] = {}
+
+            def get(asr_name) -> dict:
+                nonlocal state
+                if asr_name not in state:
+                    state[asr_name] = self.asr_configs.get(asr_name, None)
+                    if state[asr_name] is None:
+                        raise SonusAIError(f"Unrecognized ASR name: '{asr_name}'")
+                return state[asr_name]
+
+            return get
+
+        asr_config = create_asr_config()
+
+        def create_target_asr() -> Callable[[str], str]:
+            state: dict[str, str] = {}
+
+            def get(asr_name) -> str:
+                nonlocal state
+                if asr_name not in state:
+                    state[asr_name] = calc_asr(target_audio(), **asr_config(asr_name)).text
+                return state[asr_name]
+
+            return get
+
+        target_asr = create_target_asr()
+
+        def create_mixture_asr() -> Callable[[str], str]:
+            state: dict[str, str] = {}
+
+            def get(asr_name) -> str:
+                nonlocal state
+                if asr_name not in state:
+                    state[asr_name] = calc_asr(mixture_audio(), **asr_config(asr_name)).text
+                return state[asr_name]
+
+            return get
+
+        mixture_asr = create_mixture_asr()
+
+        def get_asr_name(m: str) -> str:
+            parts = m.split('.')
+            if len(parts) != 2:
+                raise SonusAIError(
+                    f"Unrecognized format: '{m}'; must be of the form: '<metric>.<name>'")
+            asr_name = parts[1]
+            return asr_name
+
+        def calc(m: str) -> float | int | str | Segsnr:
             if m == 'mxsnr':
                 return self.mixture(m_id).snr
 
@@ -1340,31 +1393,21 @@ class MixtureDatabase:
 
             # Otherwise, generate data as needed
             if m.startswith('mxwer'):
-                parts = m.split('.')
-                if len(parts) != 2:
-                    raise SonusAIError(
-                        f"Unrecognized 'mxwer' format: '{m}'; must be of the form: 'mxwer.<name>'")
-                asr_name = parts[1]
-                asr_config = self.asr_configs.get(asr_name, None)
-                if asr_config is None:
-                    raise SonusAIError(f"Unrecognized metric: '{m}'")
+                asr_name = get_asr_name(m)
 
                 if self.mixture(m_id).snr < -96:
                     # noise only, ignore/reset target asr
                     return float('nan')
 
-                # ignore mixup
-                target_asr = self.mixture_speech_metadata(m_id, 'text')[0]
-                if target_asr is None:
-                    target_asr = calc_asr(target_audio(), **asr_config).text
-
-                if target_asr:
-                    mixture_asr = calc_asr(mixture_audio(), **asr_config).text
-                    return calc_wer(mixture_asr, target_asr).wer * 100
+                if target_asr(asr_name):
+                    return calc_wer(mixture_asr(asr_name), target_asr(asr_name)).wer * 100
 
                 # TODO: should this be NaN like above?
                 return float(0)
 
+            if m.startswith('mxasr'):
+                return mixture_asr(get_asr_name(m))
+
             if m == 'mxssnr_avg':
                 return calc_segsnr_f(segsnr_f()).avg
 
@@ -1454,6 +1497,9 @@ class MixtureDatabase:
             if m == 'tpkc':
                 return target_stats().pkc
 
+            if m.startswith('tasr'):
+                return target_asr(get_asr_name(m))
+
             if m == 'ndco':
                 return noise_stats().dco
 
@@ -1501,7 +1547,7 @@ class MixtureDatabase:
 
             raise SonusAIError(f"Unrecognized metric: '{m}'")
 
-        result: list[float | int | Segsnr] = []
+        result: list[float | int | str | Segsnr] = []
         for metric in metrics:
             result.append(calc(metric))
 

sonusai-0.18.7/sonusai/post_spenh_targetf.py

@@ -1,160 +0,0 @@
-"""sonusai post_spenh_targetf
-
-usage: post_spenh_targetf [-hv] (-m MODEL) (-w KMODEL) INPUT ...
-
-options:
-    -h, --help
-    -v, --verbose                   Be verbose.
-    -m MODEL, --model MODEL         Python model file.
-    -w KMODEL, --weights KMODEL     Keras model weights file.
-
-Run post-processing on speech enhancement targetf prediction data.
-
-Inputs:
-    MODEL       A SonusAI Python model file with build and/or hypermodel functions.
-    KMODEL      A Keras model weights file (or model file with weights).
-    INPUT       A single H5 file or a glob of H5 files
-
-Outputs the following to post_spenh_targetf-<TIMESTAMP> directory:
-    <name>.wav
-    post_spenh_targetf.log
-
-"""
-import signal
-from dataclasses import dataclass
-
-
-def signal_handler(_sig, _frame):
-    import sys
-
-    from sonusai import logger
-
-    logger.info('Canceled due to keyboard interrupt')
-    sys.exit(1)
-
-
-signal.signal(signal.SIGINT, signal_handler)
-
-
-@dataclass
-class MPGlobal:
-    N: int = None
-    R: int = None
-    bin_start: int = None
-    bin_end: int = None
-    ttype: str = None
-    output_dir: str = None
-
-
-MP_GLOBAL = MPGlobal()
-
-
-def main() -> None:
-    from docopt import docopt
-
-    import sonusai
-    from sonusai.utils import trim_docstring
-
-    args = docopt(trim_docstring(__doc__), version=sonusai.__version__, options_first=True)
-
-    verbose = args['--verbose']
-    model_name = args['--model']
-    weights_name = args['--weights']
-    input_name = args['INPUT']
-
-    import time
-    from os import makedirs
-    from os.path import isfile
-    from os.path import join
-    from os.path import splitext
-
-    from pyaaware import FeatureGenerator
-    from tqdm import tqdm
-
-    from sonusai import create_file_handler
-    from sonusai import initial_log_messages
-    from sonusai import logger
-    from sonusai import update_console_handler
-    from sonusai.utils import create_ts_name
-    from sonusai.utils import import_and_check_keras_model
-    from sonusai.utils import pp_tqdm_imap
-    from sonusai.utils import seconds_to_hms
-
-    start_time = time.monotonic()
-
-    output_dir = create_ts_name('post_spenh_targetf')
-    makedirs(output_dir, exist_ok=True)
-
-    # Setup logging file
-    create_file_handler(join(output_dir, 'post_spenh_targetf.log'))
-    update_console_handler(verbose)
-    initial_log_messages('post_spenh_targetf')
-
-    hypermodel = import_and_check_keras_model(model_name=model_name, weights_name=weights_name)
-
-    fg = FeatureGenerator(feature_mode=hypermodel.feature,
-                          num_classes=hypermodel.num_classes,
-                          truth_mutex=hypermodel.truth_mutex)
-
-    MP_GLOBAL.N = fg.itransform_N
-    MP_GLOBAL.R = fg.itransform_R
-    MP_GLOBAL.bin_start = fg.bin_start
-    MP_GLOBAL.bin_end = fg.bin_end
-    MP_GLOBAL.ttype = fg.itransform_ttype
-    MP_GLOBAL.output_dir = output_dir
-
-    if not all(isfile(file) and splitext(file)[1] == '.h5' for file in input_name):
-        logger.exception(f'Do not know how to process input from {input_name}')
-        raise SystemExit(1)
-
-    logger.info('')
-    logger.info(f'Found {len(input_name):,} files to process')
-
-    progress = tqdm(total=len(input_name))
-    pp_tqdm_imap(_process, input_name, progress=progress)
-    progress.close()
-
-    logger.info(f'Wrote {len(input_name)} mixtures to {output_dir}')
-    logger.info('')
-
-    end_time = time.monotonic()
-    logger.info(f'Completed in {seconds_to_hms(seconds=end_time - start_time)}')
-    logger.info('')
-
-
-def _process(file: str) -> None:
-    """Run extraction on predict data to generate estimation audio
-    """
-    from os.path import basename
-    from os.path import join
-    from os.path import splitext
-
-    import h5py
-    import numpy as np
-    from sonusai import InverseTransform
-
-    from sonusai import SonusAIError
-    from sonusai.mixture import get_audio_from_transform
-    from sonusai.utils import float_to_int16
-    from sonusai.utils import unstack_complex
-    from sonusai.utils import write_audio
-
-    try:
-        with h5py.File(file, 'r') as f:
-            predict = unstack_complex(np.array(f['predict']))
-    except Exception as e:
-        raise SonusAIError(f'Error reading {file}: {e}')
-
-    output_name = join(MP_GLOBAL.output_dir, splitext(basename(file))[0] + '.wav')
-    audio, _ = get_audio_from_transform(data=predict,
-                                        transform=InverseTransform(N=MP_GLOBAL.N,
-                                                                   R=MP_GLOBAL.R,
-                                                                   bin_start=MP_GLOBAL.bin_start,
-                                                                   bin_end=MP_GLOBAL.bin_end,
-                                                                   ttype=MP_GLOBAL.ttype,
-                                                                   gain=np.float32(1)))
-    write_audio(name=output_name, audio=float_to_int16(audio))
-
-
-if __name__ == '__main__':
-    main()