sonusai 1.0.10__py3-none-any.whl → 1.0.12__py3-none-any.whl

sonusai/metrics/__init__.py

@@ -15,6 +15,7 @@ from .calc_segsnr_f import calc_segsnr_f_bin
 from .calc_speech import calc_speech
 from .calc_wer import calc_wer
 from .calc_wsdr import calc_wsdr
+from .calculate_metrics import calculate_metrics
 from .class_summary import class_summary
 from .confusion_matrix_summary import confusion_matrix_summary
 from .one_hot import one_hot

sonusai/metrics/calculate_metrics.py

@@ -0,0 +1,395 @@
+import functools
+from typing import Any
+
+import numpy as np
+from pystoi import stoi
+
+from ..constants import SAMPLE_RATE
+from ..datatypes import AudioF
+from ..datatypes import AudioStatsMetrics
+from ..datatypes import AudioT
+from ..datatypes import Segsnr
+from ..datatypes import SpeechMetrics
+from ..mixture.mixdb import MixtureDatabase
+from ..utils.asr import calc_asr
+from ..utils.db import linear_to_db
+from .calc_audio_stats import calc_audio_stats
+from .calc_pesq import calc_pesq
+from .calc_phase_distance import calc_phase_distance
+from .calc_segsnr_f import calc_segsnr_f
+from .calc_segsnr_f import calc_segsnr_f_bin
+from .calc_speech import calc_speech
+from .calc_wer import calc_wer
+from .calc_wsdr import calc_wsdr
+
+
+def calculate_metrics(mixdb: MixtureDatabase, m_id: int, metrics: list[str], force: bool = False) -> dict[str, Any]:
+    """Get metrics data for the given mixture ID
+
+    :param mixdb: Mixture database object
+    :param m_id: Zero-based mixture ID
+    :param metrics: List of metrics to get
+    :param force: Force computing data from original sources regardless of whether cached data exists
+    :return: Dictionary of metric data
+    """
+
+    # Define cached functions for expensive operations
+    @functools.lru_cache(maxsize=1)
+    def mixture_sources() -> dict[str, AudioT]:
+        return mixdb.mixture_sources(m_id)
+
+    @functools.lru_cache(maxsize=1)
+    def mixture_source() -> AudioT:
+        return mixdb.mixture_source(m_id)
+
+    @functools.lru_cache(maxsize=1)
+    def mixture_source_f() -> AudioF:
+        return mixdb.mixture_source_f(m_id)
+
+    @functools.lru_cache(maxsize=1)
+    def mixture_noise() -> AudioT:
+        return mixdb.mixture_noise(m_id)
+
+    @functools.lru_cache(maxsize=1)
+    def mixture_noise_f() -> AudioF:
+        return mixdb.mixture_noise_f(m_id)
+
+    @functools.lru_cache(maxsize=1)
+    def mixture_mixture() -> AudioT:
+        return mixdb.mixture_mixture(m_id)
+
+    @functools.lru_cache(maxsize=1)
+    def mixture_mixture_f() -> AudioF:
+        return mixdb.mixture_mixture_f(m_id)
+
+    @functools.lru_cache(maxsize=1)
+    def mixture_segsnr() -> Segsnr:
+        return mixdb.mixture_segsnr(m_id)
+
+    @functools.lru_cache(maxsize=1)
+    def calculate_pesq() -> dict[str, float]:
+        return {category: calc_pesq(mixture_mixture(), audio) for category, audio in mixture_sources().items()}
+
+    @functools.lru_cache(maxsize=1)
+    def calculate_speech() -> dict[str, SpeechMetrics]:
+        return {
+            category: calc_speech(mixture_mixture(), audio, calculate_pesq()[category])
+            for category, audio in mixture_sources().items()
+        }
+
+    @functools.lru_cache(maxsize=1)
+    def mixture_stats() -> AudioStatsMetrics:
+        return calc_audio_stats(mixture_mixture(), mixdb.fg_info.ft_config.length / SAMPLE_RATE)
+
+    @functools.lru_cache(maxsize=1)
+    def sources_stats() -> dict[str, AudioStatsMetrics]:
+        return {
+            category: calc_audio_stats(audio, mixdb.fg_info.ft_config.length / SAMPLE_RATE)
+            for category, audio in mixture_sources().items()
+        }
+
+    @functools.lru_cache(maxsize=1)
+    def source_stats() -> AudioStatsMetrics:
+        return calc_audio_stats(mixture_source(), mixdb.fg_info.ft_config.length / SAMPLE_RATE)
+
+    @functools.lru_cache(maxsize=1)
+    def noise_stats() -> AudioStatsMetrics:
+        return calc_audio_stats(mixture_noise(), mixdb.fg_info.ft_config.length / SAMPLE_RATE)
+
+    # Cache ASR configurations
+    @functools.lru_cache(maxsize=32)
+    def get_asr_config(asr_name: str) -> dict:
+        value = mixdb.asr_configs.get(asr_name, None)
+        if value is None:
+            raise ValueError(f"Unrecognized ASR name: '{asr_name}'")
+        return value
+
+    # Cache ASR results for sources, source and mixture
+    @functools.lru_cache(maxsize=16)
+    def sources_asr(asr_name: str) -> dict[str, str]:
+        return {
+            category: calc_asr(audio, **get_asr_config(asr_name)).text for category, audio in mixture_sources().items()
+        }
+
+    @functools.lru_cache(maxsize=16)
+    def source_asr(asr_name: str) -> str:
+        return calc_asr(mixture_source(), **get_asr_config(asr_name)).text
+
+    @functools.lru_cache(maxsize=16)
+    def mixture_asr(asr_name: str) -> str:
+        return calc_asr(mixture_mixture(), **get_asr_config(asr_name)).text
+
+    def get_asr_name(m: str) -> str:
+        parts = m.split(".")
+        if len(parts) != 2:
+            raise ValueError(f"Unrecognized format: '{m}'; must be of the form: '<metric>.<name>'")
+        asr_name = parts[1]
+        return asr_name
+
+    def calc(m: str) -> Any:
+        if m == "mxsnr":
+            return {category: source.snr for category, source in mixdb.mixture(m_id).all_sources.items()}
+
+        # Get cached data first, if exists
+        if not force:
+            value = mixdb.read_mixture_data(m_id, m)[m]
+            if value is not None:
+                return value
+
+        # Otherwise, generate data as needed
+        if m.startswith("mxwer"):
+            asr_name = get_asr_name(m)
+
+            if mixdb.mixture(m_id).is_noise_only:
+                # noise only, ignore/reset target asr
+                return float("nan")
+
+            if source_asr(asr_name):
+                return calc_wer(mixture_asr(asr_name), source_asr(asr_name)).wer * 100
+
+            # TODO: should this be NaN like above?
+            return float(0)
+
+        if m.startswith("basewer"):
+            asr_name = get_asr_name(m)
+
+            text = mixdb.mixture_speech_metadata(m_id, "text")
+            return {
+                category: calc_wer(source, str(text[category])).wer * 100 if isinstance(text[category], str) else 0
+                for category, source in sources_asr(asr_name).items()
+            }
+
+        if m.startswith("mxasr"):
+            return mixture_asr(get_asr_name(m))
+
+        if m == "mxssnr_avg":
+            return calc_segsnr_f(mixture_segsnr()).avg
+
+        if m == "mxssnr_std":
+            return calc_segsnr_f(mixture_segsnr()).std
+
+        if m == "mxssnr_avg_db":
+            val = calc_segsnr_f(mixture_segsnr()).avg
+            if val is not None:
+                return linear_to_db(val)
+            return None
+
+        if m == "mxssnr_std_db":
+            val = calc_segsnr_f(mixture_segsnr()).std
+            if val is not None:
+                return linear_to_db(val)
+            return None
+
+        if m == "mxssnrdb_avg":
+            return calc_segsnr_f(mixture_segsnr()).db_avg
+
+        if m == "mxssnrdb_std":
+            return calc_segsnr_f(mixture_segsnr()).db_std
+
+        if m == "mxssnrf_avg":
+            return calc_segsnr_f_bin(mixture_source_f(), mixture_noise_f()).avg
+
+        if m == "mxssnrf_std":
+            return calc_segsnr_f_bin(mixture_source_f(), mixture_noise_f()).std
+
+        if m == "mxssnrdbf_avg":
+            return calc_segsnr_f_bin(mixture_source_f(), mixture_noise_f()).db_avg
+
+        if m == "mxssnrdbf_std":
+            return calc_segsnr_f_bin(mixture_source_f(), mixture_noise_f()).db_std
+
+        if m == "mxpesq":
+            if mixdb.mixture(m_id).is_noise_only:
+                return dict.fromkeys(calculate_pesq(), 0)
+            return calculate_pesq()
+
+        if m == "mxcsig":
+            if mixdb.mixture(m_id).is_noise_only:
+                return dict.fromkeys(calculate_speech(), 0)
+            return {category: s.csig for category, s in calculate_speech().items()}
+
+        if m == "mxcbak":
+            if mixdb.mixture(m_id).is_noise_only:
+                return dict.fromkeys(calculate_speech(), 0)
+            return {category: s.cbak for category, s in calculate_speech().items()}
+
+        if m == "mxcovl":
+            if mixdb.mixture(m_id).is_noise_only:
+                return dict.fromkeys(calculate_speech(), 0)
+            return {category: s.covl for category, s in calculate_speech().items()}
+
+        if m == "mxwsdr":
+            mixture = mixture_mixture()[:, np.newaxis]
+            target = mixture_source()[:, np.newaxis]
+            noise = mixture_noise()[:, np.newaxis]
+            return calc_wsdr(
+                hypothesis=np.concatenate((mixture, noise), axis=1),
+                reference=np.concatenate((target, noise), axis=1),
+                with_log=True,
+            )[0]
+
+        if m == "mxpd":
+            return calc_phase_distance(hypothesis=mixture_mixture_f(), reference=mixture_source_f())[0]
+
+        if m == "mxstoi":
+            return stoi(
+                x=mixture_source(),
+                y=mixture_mixture(),
+                fs_sig=SAMPLE_RATE,
+                extended=False,
+            )
+
+        if m == "mxdco":
+            return mixture_stats().dco
+
+        if m == "mxmin":
+            return mixture_stats().min
+
+        if m == "mxmax":
+            return mixture_stats().max
+
+        if m == "mxpkdb":
+            return mixture_stats().pkdb
+
+        if m == "mxlrms":
+            return mixture_stats().lrms
+
+        if m == "mxpkr":
+            return mixture_stats().pkr
+
+        if m == "mxtr":
+            return mixture_stats().tr
+
+        if m == "mxcr":
+            return mixture_stats().cr
+
+        if m == "mxfl":
+            return mixture_stats().fl
+
+        if m == "mxpkc":
+            return mixture_stats().pkc
+
+        if m == "sdco":
+            return {category: s.dco for category, s in sources_stats().items()}
+
+        if m == "smin":
+            return {category: s.min for category, s in sources_stats().items()}
+
+        if m == "smax":
+            return {category: s.max for category, s in sources_stats().items()}
+
+        if m == "spkdb":
+            return {category: s.pkdb for category, s in sources_stats().items()}
+
+        if m == "slrms":
+            return {category: s.lrms for category, s in sources_stats().items()}
+
+        if m == "spkr":
+            return {category: s.pkr for category, s in sources_stats().items()}
+
+        if m == "str":
+            return {category: s.tr for category, s in sources_stats().items()}
+
+        if m == "scr":
+            return {category: s.cr for category, s in sources_stats().items()}
+
+        if m == "sfl":
+            return {category: s.fl for category, s in sources_stats().items()}
+
+        if m == "spkc":
+            return {category: s.pkc for category, s in sources_stats().items()}
+
+        if m == "mxsdco":
+            return source_stats().dco
+
+        if m == "mxsmin":
+            return source_stats().min
+
+        if m == "mxsmax":
+            return source_stats().max
+
+        if m == "mxspkdb":
+            return source_stats().pkdb
+
+        if m == "mxslrms":
+            return source_stats().lrms
+
+        if m == "mxspkr":
+            return source_stats().pkr
+
+        if m == "mxstr":
+            return source_stats().tr
+
+        if m == "mxscr":
+            return source_stats().cr
+
+        if m == "mxsfl":
+            return source_stats().fl
+
+        if m == "mxspkc":
+            return source_stats().pkc
+
+        if m.startswith("sasr"):
+            return sources_asr(get_asr_name(m))
+
+        if m.startswith("mxsasr"):
+            return source_asr(get_asr_name(m))
+
+        if m == "ndco":
+            return noise_stats().dco
+
+        if m == "nmin":
+            return noise_stats().min
+
+        if m == "nmax":
+            return noise_stats().max
+
+        if m == "npkdb":
+            return noise_stats().pkdb
+
+        if m == "nlrms":
+            return noise_stats().lrms
+
+        if m == "npkr":
+            return noise_stats().pkr
+
+        if m == "ntr":
+            return noise_stats().tr
+
+        if m == "ncr":
+            return noise_stats().cr
+
+        if m == "nfl":
+            return noise_stats().fl
+
+        if m == "npkc":
+            return noise_stats().pkc
+
+        if m == "sedavg":
+            return 0
+
+        if m == "sedcnt":
+            return 0
+
+        if m == "sedtop3":
+            return np.zeros(3, dtype=np.float32)
+
+        if m == "sedtopn":
+            return 0
+
+        if m == "ssnr":
+            return mixture_segsnr()
+
+        raise AttributeError(f"Unrecognized metric: '{m}'")
+
+    result: dict[str, Any] = {}
+    for metric in metrics:
+        result[metric] = calc(metric)
+
+        # Check for metrics dependencies and add them even if not explicitly requested.
+        if metric.startswith("mxwer"):
+            dependencies = ("mxasr." + metric[6:], "sasr." + metric[6:])
+            for dependency in dependencies:
+                result[dependency] = calc(dependency)
+
+    return result

sonusai/mixture/__init__.py

@@ -28,4 +28,4 @@ from .helpers import inverse_transform
 from .helpers import write_mixture_metadata
 from .log_duration_and_sizes import log_duration_and_sizes
 from .mixdb import MixtureDatabase
-from .db_file import db_file
+from .db import db_file

sonusai/mixture/db.py

@@ -2,12 +2,21 @@ import contextlib
 import sqlite3
 from os import remove
 from os.path import exists
+from os.path import join
+from os.path import normpath
 from sqlite3 import Connection
 from sqlite3 import Cursor
 from typing import Any
 
-from .. import logger_db
-from .db_file import db_file
+from sonusai import logger_db
+
+
+def db_file(location: str, test: bool = False) -> str:
+    from .constants import MIXDB_NAME
+    from .constants import TEST_MIXDB_NAME
+
+    name = TEST_MIXDB_NAME if test else MIXDB_NAME
+    return normpath(join(location, name))
 
 
 class SQLiteDatabase:
@@ -15,9 +24,6 @@ class SQLiteDatabase:
 
     # Constants for database configuration
     READONLY_MODE = "?mode=ro"
-    WRITE_OPTIMIZED_PRAGMAS = (
-        "?_journal_mode=OFF&_synchronous=OFF&_cache_size=10000&_temp_store=MEMORY&_locking_mode=EXCLUSIVE"
-    )
     CONNECTION_TIMEOUT = 20
 
     def __init__(
@@ -39,7 +45,7 @@ class SQLiteDatabase:
         """
         self.location = location
         self.create = create
-        self.readonly = readonly
+        self.readonly = readonly and not create
         self.test = test
         self.verbose = verbose
         self.con: Connection | None = None
@@ -61,6 +67,7 @@ class SQLiteDatabase:
             raise
 
         if self.cur:
+            self.cur.execute("BEGIN TRANSACTION")
             return self.cur
         raise sqlite3.Error("Failed to connect to database")
 
@@ -78,9 +85,13 @@ class SQLiteDatabase:
             exc_tb: The exception traceback, if any.
         """
         if self.con:
-            if exc_type is None and not self.readonly:
-                # Commit only on successful exit if not readonly
-                self.con.commit()
+            if not self.readonly:
+                if exc_type is None:
+                    # Commit only on successful exit
+                    self.con.commit()
+                else:
+                    # Rollback on exception
+                    self.con.rollback()
             self._close_resources()
 
     def _close_resources(self) -> None:
@@ -107,9 +118,21 @@ class SQLiteDatabase:
         uri = self._build_connection_uri(db_path)
 
         try:
-            self.con = sqlite3.connect(f"file:{uri}", uri=True, timeout=self.CONNECTION_TIMEOUT)
+            self.con = sqlite3.connect(
+                f"file:{uri}",
+                uri=True,
+                timeout=self.CONNECTION_TIMEOUT,
+                isolation_level=None,
+            )
             if self.verbose and self.con:
                 self.con.set_trace_callback(logger_db.debug)
+            if self.create or not self.readonly:
+                self.con.execute("PRAGMA journal_mode=wal")
+                self.con.execute("PRAGMA synchronous=0")  # off
+                self.con.execute("PRAGMA cache_size=10000")
+                self.con.execute("PRAGMA temp_store=2")  # memory
+                self.con.execute("PRAGMA locking_mode=exclusive")
+                self.con.commit()
         except sqlite3.Error as e:
             raise sqlite3.Error(f"Failed to connect to database: {e}") from e
 
@@ -153,11 +176,4 @@ class SQLiteDatabase:
         if not self.create and self.readonly:
             uri += self.READONLY_MODE
 
-        # Add optimized pragmas for write mode
-        if not self.readonly:
-            if "?" in uri:
-                uri = uri.replace("?", f"{self.WRITE_OPTIMIZED_PRAGMAS}&")
-            else:
-                uri += self.WRITE_OPTIMIZED_PRAGMAS
-
         return uri

sonusai/mixture/mixdb.py

@@ -30,7 +30,7 @@ from ..datatypes import TruthsConfigs
 from ..datatypes import TruthsDict
 from ..datatypes import UniversalSNR
 from .db import SQLiteDatabase
-from .db_file import db_file
+from .db import db_file
 
 
 class MixtureDatabase:
@@ -215,16 +215,6 @@ class MixtureDatabase:
                 MetricDoc("Mixture Metrics", "mxcr", "Mixture Crest factor"),
                 MetricDoc("Mixture Metrics", "mxfl", "Mixture Flat factor"),
                 MetricDoc("Mixture Metrics", "mxpkc", "Mixture Pk count"),
-                MetricDoc("Mixture Metrics", "mxtdco", "Mixture source DC offset"),
-                MetricDoc("Mixture Metrics", "mxtmin", "Mixture source min level"),
-                MetricDoc("Mixture Metrics", "mxtmax", "Mixture source max levl"),
-                MetricDoc("Mixture Metrics", "mxtpkdb", "Mixture source Pk lev dB"),
-                MetricDoc("Mixture Metrics", "mxtlrms", "Mixture source RMS lev dB"),
-                MetricDoc("Mixture Metrics", "mxtpkr", "Mixture source RMS Pk dB"),
-                MetricDoc("Mixture Metrics", "mxttr", "Mixture source RMS Tr dB"),
-                MetricDoc("Mixture Metrics", "mxtcr", "Mixture source Crest factor"),
-                MetricDoc("Mixture Metrics", "mxtfl", "Mixture source Flat factor"),
-                MetricDoc("Mixture Metrics", "mxtpkc", "Mixture source Pk count"),
                 MetricDoc("Sources Metrics", "sdco", "Sources DC offset"),
                 MetricDoc("Sources Metrics", "smin", "Sources min level"),
                 MetricDoc("Sources Metrics", "smax", "Sources max levl"),
@@ -235,6 +225,16 @@ class MixtureDatabase:
                 MetricDoc("Sources Metrics", "scr", "Sources Crest factor"),
                 MetricDoc("Sources Metrics", "sfl", "Sources Flat factor"),
                 MetricDoc("Sources Metrics", "spkc", "Sources Pk count"),
+                MetricDoc("Source Metrics", "mxsdco", "Source DC offset"),
+                MetricDoc("Source Metrics", "mxsmin", "Source min level"),
+                MetricDoc("Source Metrics", "mxsmax", "Source max levl"),
+                MetricDoc("Source Metrics", "mxspkdb", "Source Pk lev dB"),
+                MetricDoc("Source Metrics", "mxslrms", "Source RMS lev dB"),
+                MetricDoc("Source Metrics", "mxspkr", "Source RMS Pk dB"),
+                MetricDoc("Source Metrics", "mxstr", "Source RMS Tr dB"),
+                MetricDoc("Source Metrics", "mxscr", "Source Crest factor"),
+                MetricDoc("Source Metrics", "mxsfl", "Source Flat factor"),
+                MetricDoc("Source Metrics", "mxspkc", "Source Pk count"),
                 MetricDoc("Noise Metrics", "ndco", "Noise DC offset"),
                 MetricDoc("Noise Metrics", "nmin", "Noise min level"),
                 MetricDoc("Noise Metrics", "nmax", "Noise max levl"),
@@ -277,7 +277,7 @@ class MixtureDatabase:
             )
             metrics.append(
                 MetricDoc(
-                    "Source Metrics",
+                    "Sources Metrics",
                     f"sasr.{name}",
                     f"Sources ASR text using {name} ASR as defined in mixdb asr_configs parameter",
                 )
@@ -291,7 +291,7 @@ class MixtureDatabase:
             )
             metrics.append(
                 MetricDoc(
-                    "Source Metrics",
+                    "Sources Metrics",
                     f"basewer.{name}",
                     f"Word error rate of sasr.{name} vs. speech text metadata for the source",
                 )
@@ -1296,17 +1296,15 @@ class MixtureDatabase:
         fg = FeatureGenerator(self.fg_config.feature_mode, self.fg_config.truth_parameters)
 
         feature, truth_f = fg.execute_all(mixture_f, truth_t)
-        if truth_f is not None:
-            truth_configs = self.mixture_truth_configs(m_id)
-            for category, configs in truth_configs.items():
-                for name, config in configs.items():
-                    if self.truth_parameters[category][name] is not None:
-                        truth_f[category][name] = truth_stride_reduction(
-                            truth_f[category][name], config.stride_reduction
-                        )
-        else:
+        if truth_f is None:
             raise TypeError("Unexpected truth of None from feature generator")
 
+        truth_configs = self.mixture_truth_configs(m_id)
+        for category, configs in truth_configs.items():
+            for name, config in configs.items():
+                if self.truth_parameters[category][name] is not None:
+                    truth_f[category][name] = truth_stride_reduction(truth_f[category][name], config.stride_reduction)
+
         if cache:
             write_cached_data(
                 location=self.location,
@@ -1598,536 +1596,9 @@ class MixtureDatabase:
         :param force: Force computing data from original sources regardless of whether cached data exists
         :return: Dictionary of metric data
         """
-        from collections.abc import Callable
-
-        import numpy as np
-        from pystoi import stoi
-
-        from ..constants import SAMPLE_RATE
-        from ..datatypes import AudioStatsMetrics
-        from ..datatypes import SpeechMetrics
-        from ..metrics.calc_audio_stats import calc_audio_stats
-        from ..metrics.calc_pesq import calc_pesq
-        from ..metrics.calc_phase_distance import calc_phase_distance
-        from ..metrics.calc_segsnr_f import calc_segsnr_f
-        from ..metrics.calc_segsnr_f import calc_segsnr_f_bin
-        from ..metrics.calc_speech import calc_speech
-        from ..metrics.calc_wer import calc_wer
-        from ..metrics.calc_wsdr import calc_wsdr
-        from ..utils.asr import calc_asr
-        from ..utils.db import linear_to_db
-
-        def create_sources_audio() -> Callable[[], dict[str, AudioT]]:
-            state: dict[str, AudioT] | None = None
-
-            def get() -> dict[str, AudioT]:
-                nonlocal state
-                if state is None:
-                    state = self.mixture_sources(m_id)
-                return state
-
-            return get
-
-        sources_audio = create_sources_audio()
-
-        def create_source_audio() -> Callable[[], AudioT]:
-            state: AudioT | None = None
-
-            def get() -> AudioT:
-                nonlocal state
-                if state is None:
-                    state = self.mixture_source(m_id)
-                return state
-
-            return get
-
-        source_audio = create_source_audio()
-
-        def create_source_f() -> Callable[[], AudioF]:
-            state: AudioF | None = None
-
-            def get() -> AudioF:
-                nonlocal state
-                if state is None:
-                    state = self.mixture_source_f(m_id)
-                return state
-
-            return get
-
-        source_f = create_source_f()
-
-        def create_noise_audio() -> Callable[[], AudioT]:
-            state: AudioT | None = None
-
-            def get() -> AudioT:
-                nonlocal state
-                if state is None:
-                    state = self.mixture_noise(m_id)
-                return state
-
-            return get
-
-        noise_audio = create_noise_audio()
-
-        def create_noise_f() -> Callable[[], AudioF]:
-            state: AudioF | None = None
-
-            def get() -> AudioF:
-                nonlocal state
-                if state is None:
-                    state = self.mixture_noise_f(m_id)
-                return state
-
-            return get
-
-        noise_f = create_noise_f()
-
-        def create_mixture_audio() -> Callable[[], AudioT]:
-            state: AudioT | None = None
-
-            def get() -> AudioT:
-                nonlocal state
-                if state is None:
-                    state = self.mixture_mixture(m_id)
-                return state
-
-            return get
-
-        mixture_audio = create_mixture_audio()
-
-        def create_segsnr_f() -> Callable[[], Segsnr]:
-            state: Segsnr | None = None
-
-            def get() -> Segsnr:
-                nonlocal state
-                if state is None:
-                    state = self.mixture_segsnr(m_id)
-                return state
-
-            return get
-
-        segsnr_f = create_segsnr_f()
-
-        def create_pesq() -> Callable[[], dict[str, float]]:
-            state: dict[str, float] | None = None
-
-            def get() -> dict[str, float]:
-                nonlocal state
-                if state is None:
-                    state = {category: calc_pesq(mixture_audio(), audio) for category, audio in sources_audio().items()}
-                return state
-
-            return get
-
-        pesq = create_pesq()
-
-        def create_speech() -> Callable[[], dict[str, SpeechMetrics]]:
-            state: dict[str, SpeechMetrics] | None = None
-
-            def get() -> dict[str, SpeechMetrics]:
-                nonlocal state
-                if state is None:
-                    state = {
-                        category: calc_speech(mixture_audio(), audio, pesq()[category])
-                        for category, audio in sources_audio().items()
-                    }
-                return state
-
-            return get
-
-        speech = create_speech()
-
-        def create_mixture_stats() -> Callable[[], AudioStatsMetrics]:
-            state: AudioStatsMetrics | None = None
-
-            def get() -> AudioStatsMetrics:
-                nonlocal state
-                if state is None:
-                    state = calc_audio_stats(mixture_audio(), self.fg_info.ft_config.length / SAMPLE_RATE)
-                return state
-
-            return get
-
-        mixture_stats = create_mixture_stats()
-
-        def create_sources_stats() -> Callable[[], dict[str, AudioStatsMetrics]]:
-            state: dict[str, AudioStatsMetrics] | None = None
-
-            def get() -> dict[str, AudioStatsMetrics]:
-                nonlocal state
-                if state is None:
-                    state = {
-                        category: calc_audio_stats(audio, self.fg_info.ft_config.length / SAMPLE_RATE)
-                        for category, audio in sources_audio().items()
-                    }
-                return state
-
-            return get
-
-        sources_stats = create_sources_stats()
-
-        def create_source_stats() -> Callable[[], AudioStatsMetrics]:
-            state: AudioStatsMetrics | None = None
-
-            def get() -> AudioStatsMetrics:
-                nonlocal state
-                if state is None:
-                    state = calc_audio_stats(source_audio(), self.fg_info.ft_config.length / SAMPLE_RATE)
-                return state
-
-            return get
-
-        source_stats = create_source_stats()
-
-        def create_noise_stats() -> Callable[[], AudioStatsMetrics]:
-            state: AudioStatsMetrics | None = None
-
-            def get() -> AudioStatsMetrics:
-                nonlocal state
-                if state is None:
-                    state = calc_audio_stats(noise_audio(), self.fg_info.ft_config.length / SAMPLE_RATE)
-                return state
-
-            return get
-
-        noise_stats = create_noise_stats()
-
-        def create_asr_config() -> Callable[[str], dict]:
-            state: dict[str, dict] = {}
-
-            def get(asr_name) -> dict:
-                nonlocal state
-                if asr_name not in state:
-                    value = self.asr_configs.get(asr_name, None)
-                    if value is None:
-                        raise ValueError(f"Unrecognized ASR name: '{asr_name}'")
-                    state[asr_name] = value
-                return state[asr_name]
-
-            return get
-
-        asr_config = create_asr_config()
-
-        def create_sources_asr() -> Callable[[str], dict[str, str]]:
-            state: dict[str, dict[str, str]] = {}
-
-            def get(asr_name) -> dict[str, str]:
-                nonlocal state
-                if asr_name not in state:
-                    state[asr_name] = {
-                        category: calc_asr(audio, **asr_config(asr_name)).text
-                        for category, audio in sources_audio().items()
-                    }
-                return state[asr_name]
-
-            return get
-
-        sources_asr = create_sources_asr()
-
-        def create_source_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(source_audio(), **asr_config(asr_name)).text
-                return state[asr_name]
-
-            return get
-
-        source_asr = create_source_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 ValueError(f"Unrecognized format: '{m}'; must be of the form: '<metric>.<name>'")
-            asr_name = parts[1]
-            return asr_name
-
-        def calc(m: str) -> Any:
-            if m == "mxsnr":
-                return {category: source.snr for category, source in self.mixture(m_id).all_sources.items()}
-
-            # Get cached data first, if exists
-            if not force:
-                value = self.read_mixture_data(m_id, m)[m]
-                if value is not None:
-                    return value
-
-            # Otherwise, generate data as needed
-            if m.startswith("mxwer"):
-                asr_name = get_asr_name(m)
-
-                if self.mixture(m_id).is_noise_only:
-                    # noise only, ignore/reset target asr
-                    return float("nan")
-
-                if source_asr(asr_name):
-                    return calc_wer(mixture_asr(asr_name), source_asr(asr_name)).wer * 100
-
-                # TODO: should this be NaN like above?
-                return float(0)
-
-            if m.startswith("basewer"):
-                asr_name = get_asr_name(m)
-
-                text = self.mixture_speech_metadata(m_id, "text")
-                base_wer: dict[str, float] = {}
-                for category, source in sources_asr(asr_name).items():
-                    if isinstance(text[category], str):
-                        base_wer[category] = calc_wer(source, str(text[category])).wer * 100
-                    else:
-                        base_wer[category] = 0
-                return base_wer
-
-            if m.startswith("mxasr"):
-                return mixture_asr(get_asr_name(m))
-
-            if m == "mxssnr_avg":
-                return calc_segsnr_f(segsnr_f()).avg
-
-            if m == "mxssnr_std":
-                return calc_segsnr_f(segsnr_f()).std
-
-            if m == "mxssnr_avg_db":
-                val = calc_segsnr_f(segsnr_f()).avg
-                if val is not None:
-                    return linear_to_db(val)
-                return None
-
-            if m == "mxssnr_std_db":
-                val = calc_segsnr_f(segsnr_f()).std
-                if val is not None:
-                    return linear_to_db(val)
-                return None
-
-            if m == "mxssnrdb_avg":
-                return calc_segsnr_f(segsnr_f()).db_avg
-
-            if m == "mxssnrdb_std":
-                return calc_segsnr_f(segsnr_f()).db_std
-
-            if m == "mxssnrf_avg":
-                return calc_segsnr_f_bin(source_f(), noise_f()).avg
-
-            if m == "mxssnrf_std":
-                return calc_segsnr_f_bin(source_f(), noise_f()).std
-
-            if m == "mxssnrdbf_avg":
-                return calc_segsnr_f_bin(source_f(), noise_f()).db_avg
-
-            if m == "mxssnrdbf_std":
-                return calc_segsnr_f_bin(source_f(), noise_f()).db_std
-
-            if m == "mxpesq":
-                if self.mixture(m_id).is_noise_only:
-                    return dict.fromkeys(pesq(), 0)
-                return pesq()
-
-            if m == "mxcsig":
-                if self.mixture(m_id).is_noise_only:
-                    return dict.fromkeys(speech(), 0)
-                return {category: s.csig for category, s in speech().items()}
-
-            if m == "mxcbak":
-                if self.mixture(m_id).is_noise_only:
-                    return dict.fromkeys(speech(), 0)
-                return {category: s.cbak for category, s in speech().items()}
-
-            if m == "mxcovl":
-                if self.mixture(m_id).is_noise_only:
-                    return dict.fromkeys(speech(), 0)
-                return {category: s.covl for category, s in speech().items()}
-
-            if m == "mxwsdr":
-                mixture = mixture_audio()[:, np.newaxis]
-                target = source_audio()[:, np.newaxis]
-                noise = noise_audio()[:, np.newaxis]
-                return calc_wsdr(
-                    hypothesis=np.concatenate((mixture, noise), axis=1),
-                    reference=np.concatenate((target, noise), axis=1),
-                    with_log=True,
-                )[0]
-
-            if m == "mxpd":
-                mixture_f = self.mixture_mixture_f(m_id)
-                return calc_phase_distance(hypothesis=mixture_f, reference=source_f())[0]
-
-            if m == "mxstoi":
-                return stoi(
-                    x=source_audio(),
-                    y=mixture_audio(),
-                    fs_sig=SAMPLE_RATE,
-                    extended=False,
-                )
-
-            if m == "mxdco":
-                return mixture_stats().dco
-
-            if m == "mxmin":
-                return mixture_stats().min
-
-            if m == "mxmax":
-                return mixture_stats().max
-
-            if m == "mxpkdb":
-                return mixture_stats().pkdb
-
-            if m == "mxlrms":
-                return mixture_stats().lrms
-
-            if m == "mxpkr":
-                return mixture_stats().pkr
-
-            if m == "mxtr":
-                return mixture_stats().tr
-
-            if m == "mxcr":
-                return mixture_stats().cr
-
-            if m == "mxfl":
-                return mixture_stats().fl
-
-            if m == "mxpkc":
-                return mixture_stats().pkc
-
-            if m == "mxtdco":
-                return source_stats().dco
-
-            if m == "mxtmin":
-                return source_stats().min
-
-            if m == "mxtmax":
-                return source_stats().max
-
-            if m == "mxtpkdb":
-                return source_stats().pkdb
-
-            if m == "mxtlrms":
-                return source_stats().lrms
-
-            if m == "mxtpkr":
-                return source_stats().pkr
-
-            if m == "mxttr":
-                return source_stats().tr
-
-            if m == "mxtcr":
-                return source_stats().cr
-
-            if m == "mxtfl":
-                return source_stats().fl
-
-            if m == "mxtpkc":
-                return source_stats().pkc
-
-            if m == "sdco":
-                return {category: s.dco for category, s in sources_stats().items()}
-
-            if m == "smin":
-                return {category: s.min for category, s in sources_stats().items()}
-
-            if m == "smax":
-                return {category: s.max for category, s in sources_stats().items()}
-
-            if m == "spkdb":
-                return {category: s.pkdb for category, s in sources_stats().items()}
-
-            if m == "slrms":
-                return {category: s.lrms for category, s in sources_stats().items()}
-
-            if m == "spkr":
-                return {category: s.pkr for category, s in sources_stats().items()}
-
-            if m == "str":
-                return {category: s.tr for category, s in sources_stats().items()}
-
-            if m == "scr":
-                return {category: s.cr for category, s in sources_stats().items()}
-
-            if m == "sfl":
-                return {category: s.fl for category, s in sources_stats().items()}
-
-            if m == "spkc":
-                return {category: s.pkc for category, s in sources_stats().items()}
-
-            if m.startswith("sasr"):
-                return sources_asr(get_asr_name(m))
-
-            if m.startswith("mxsasr"):
-                return source_asr(get_asr_name(m))
-
-            if m == "ndco":
-                return noise_stats().dco
-
-            if m == "nmin":
-                return noise_stats().min
-
-            if m == "nmax":
-                return noise_stats().max
-
-            if m == "npkdb":
-                return noise_stats().pkdb
-
-            if m == "nlrms":
-                return noise_stats().lrms
-
-            if m == "npkr":
-                return noise_stats().pkr
-
-            if m == "ntr":
-                return noise_stats().tr
-
-            if m == "ncr":
-                return noise_stats().cr
-
-            if m == "nfl":
-                return noise_stats().fl
-
-            if m == "npkc":
-                return noise_stats().pkc
-
-            if m == "sedavg":
-                return 0
-
-            if m == "sedcnt":
-                return 0
-
-            if m == "sedtop3":
-                return np.zeros(3, dtype=np.float32)
-
-            if m == "sedtopn":
-                return 0
-
-            if m == "ssnr":
-                return segsnr_f()
-
-            raise AttributeError(f"Unrecognized metric: '{m}'")
-
-        result: dict[str, Any] = {}
-        for metric in metrics:
-            result[metric] = calc(metric)
-
-            # Check for metrics dependencies and add them even if not explicitly requested.
-            if metric.startswith("mxwer"):
-                dependencies = ("mxasr." + metric[6:], "sasr." + metric[6:])
-                for dependency in dependencies:
-                    result[dependency] = calc(dependency)
+        from ..metrics import calculate_metrics
 
-        return result
+        return calculate_metrics(self, m_id, metrics, force)
 
 
 def _spectral_mask(db: partial, sm_id: int, use_cache: bool = True) -> SpectralMask:

{sonusai-1.0.10.dist-info → sonusai-1.0.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sonusai
-Version: 1.0.10
+Version: 1.0.12
 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-1.0.10.dist-info → sonusai-1.0.12.dist-info}/RECORD

@@ -27,7 +27,7 @@ sonusai/genmixdb.py,sha256=VDQMF6JHcHc-yJAZ1Se3CM3ac8fFKIgnaxv4e5jdE1I,11281
 sonusai/ir_metric.py,sha256=nxS_mARPSZG5Y0G3L8HysOnkPj4v-RGxAxAVBYe-gJI,19600
 sonusai/lsdb.py,sha256=-Fhwd7YuL-OIymFqaNcBHtOq8l_8LxzoEE6ztduQCpY,5059
 sonusai/main.py,sha256=72feJv5XEVJE_CQatmNIL1VD9ca-Mo0QNDbXxLrHrbQ,2619
-sonusai/metrics/__init__.py,sha256=ssV6JEK_oklRSocsp6HMcG-GtJvV8IkRQtdKhHHmwU8,878
+sonusai/metrics/__init__.py,sha256=0Y0xFHiO3TrH4DRt-htCXEXsc8TLGNRWfD16q16yWEs,927
 sonusai/metrics/calc_audio_stats.py,sha256=tIfTa40UdYCkj999kUghWafwnFBqFtJxB5yZhVp1YpA,1244
 sonusai/metrics/calc_class_weights.py,sha256=uF1jeFz73l5nSk6SQ-xkBGbrgvAvX_MKUA_Det2KAEM,3609
 sonusai/metrics/calc_optimal_thresholds.py,sha256=1bKPoqUYyHpq7lrx7hPnVXrJ5xWIewQjNG632GzKNNU,3502
@@ -40,20 +40,20 @@ sonusai/metrics/calc_segsnr_f.py,sha256=yLqUt--8osVgCNAkopbDZsldlVJ6a5AZEggarN8d
 sonusai/metrics/calc_speech.py,sha256=bFiWtKz_Fuu4F1kdWGmZ3qZ_LdoSI3pj0ziXZKxXE3U,14828
 sonusai/metrics/calc_wer.py,sha256=1MQYMx8ldHeodtJEtGibvDKhvSaGe6DBmZV4L8qOMgg,2362
 sonusai/metrics/calc_wsdr.py,sha256=vcALY-zuhyThRa1QMz2qW8L9kSBc2v32gV9u8bV7VaM,2556
+sonusai/metrics/calculate_metrics.py,sha256=jcAyEV6loenu4fU_EvwEkpKxOrP8-K9O3rwQGlE48IU,12475
 sonusai/metrics/class_summary.py,sha256=mQbMxQ8EtFIN7S2h7A4Dk0X4XF_CIxKk3W8zZMmpfcw,2801
 sonusai/metrics/confusion_matrix_summary.py,sha256=lhd8TyHVMC03khX85h_D75XElmawx56KkqpX3X2O2gQ,3133
 sonusai/metrics/one_hot.py,sha256=aKc-xYd4zWIjbmoQikIcQ6BJB1k-68XKTg8eJCacHTU,13906
 sonusai/metrics/snr_summary.py,sha256=qKHctpmvGeu2cmjTG7iQPX1lvVUEtEnCIKwUGu6VrEQ,5773
 sonusai/metrics_summary.py,sha256=jtSwHomw23qwTYfzjFo_JmqzrkZcts1CMFFzTmJCmWk,12189
-sonusai/mixture/__init__.py,sha256=l4CgJN0gH4Z19jcQvXJbR8KSZ5f_ysnoAGi93LQaTjM,1260
+sonusai/mixture/__init__.py,sha256=GGx8WG0pZwKmlXiWVBrtQXVY0dKW4yqDxSBgv7BI2Xc,1255
 sonusai/mixture/audio.py,sha256=JyrVtVPLH3aTXFgyl446f5uVHxlFRa4aBaSPYaMdg80,5814
 sonusai/mixture/class_balancing.py,sha256=lubicVCzxs4TMh2dZSsuIffkLkk1gmwjmwtrtQ27BVQ,3638
 sonusai/mixture/config.py,sha256=2_hEndyRXxyBpGzyBFaDT9REYGoK9Q7HQy8vDqPozus,23320
 sonusai/mixture/constants.py,sha256=Kklzhf5DL30yb3TpqRbvRUhcFrEXJ4s2S3D_nw4ARxM,1498
 sonusai/mixture/data_io.py,sha256=DV48sFcP2Qp3NBzvcnlptQOXU3aUEcAeLuh3XOtC5jI,5341
-sonusai/mixture/db.py,sha256=yd0bCiihuUAw3IgRlLqcshXB2QHep837O3TwjPyo-LM,5132
+sonusai/mixture/db.py,sha256=zZnMFdW30leMCT1nX1Ml57ByLkqYEcm4VlekELvCFyc,5678
 sonusai/mixture/db_datatypes.py,sha256=VvNtbOgt5WSeSnBoVcNGC5gs_7hX_38pDUPjy5KRbG4,1471
-sonusai/mixture/db_file.py,sha256=P48TWYNyqchycENIqBu1QqhfsRDP6WK2VanPgxN1Imk,278
 sonusai/mixture/effects.py,sha256=zIb6ir0WSdKQJo7uJ3QQnV52RA6lJaqgQqvQh-s0dhc,11038
 sonusai/mixture/feature.py,sha256=7GJvFhfqeqerfjy9Vq9aKt-cecgYblK0IypNNo5hgwY,2285
 sonusai/mixture/generation.py,sha256=_vGTyqo0ocyOK84rTj_1QXciq1Tmxxl5XhwaXPWIEL0,33105
@@ -61,7 +61,7 @@ sonusai/mixture/helpers.py,sha256=dmyHwf1C5dZjYOd11kVV16KI33CaM-dU_fyaxOrrKt8,11
 sonusai/mixture/ir_delay.py,sha256=aiC23HMWQ08-v5wORgMx1_DOJSdh4kunULqiQ-SGuMo,2026
 sonusai/mixture/ir_effects.py,sha256=PqiqD4PS42-7kD6ESnsZi2a3tnKCFa4E0xqUujRBvGg,2152
 sonusai/mixture/log_duration_and_sizes.py,sha256=3ekS27IMKlnxIkQAmprzmBnzHOpRjZh3d7maL2VqWQU,927
-sonusai/mixture/mixdb.py,sha256=5YI0zKisFw_B-jKpB-Y1EYlJ8pHQDvOQLs9LEe0gT1w,84905
+sonusai/mixture/mixdb.py,sha256=0smihhsBjENymN5iuNoaj5FIXSfSzMkpXN29QuAhIiE,67882
 sonusai/mixture/pad_audio.py,sha256=KNxVQAejA0hblLOnMJgLS6lFaeE0n3tWQ5rclaHBnIY,1015
 sonusai/mixture/parse.py,sha256=nqhjuR-J7_3wlGhVitYFvQwLJ1sclU8WZrVF0SyW2Cw,3700
 sonusai/mixture/resample.py,sha256=jXqH6FrZ0mlhQ07XqPx88TT9elu3HHVLw7Q0a7Lh5M4,221
@@ -134,7 +134,7 @@ sonusai/utils/tokenized_shell_vars.py,sha256=EDrrAgz5lJ0RBAjLcTJt1MeyjhbNZiqXkym
 sonusai/utils/write_audio.py,sha256=IHzrJoFtFcea_J6wo6QSiojRkgnNOzAEcg-z0rFV7nU,810
 sonusai/utils/yes_or_no.py,sha256=0h1okjXmDNbJp7rZJFR2V-HFU1GJDm3YFTUVmYExkOU,263
 sonusai/vars.py,sha256=m8pdgfR4A6A9TCGf_rok6jPAT5BgrEsYXTSISIh1nrI,1163
-sonusai-1.0.10.dist-info/METADATA,sha256=kliBuHLQIEAUTsv9Hav0VWo1IGQxpTao5bl233yOnaQ,2695
-sonusai-1.0.10.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
-sonusai-1.0.10.dist-info/entry_points.txt,sha256=zMNjEphEPO6B3cD1GNpit7z-yA9tUU5-j3W2v-UWstU,92
-sonusai-1.0.10.dist-info/RECORD,,
+sonusai-1.0.12.dist-info/METADATA,sha256=8GtmHLwVNnw6fFJLJrzqXFjpLW3eMABQK4aN_R0j0Is,2695
+sonusai-1.0.12.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
+sonusai-1.0.12.dist-info/entry_points.txt,sha256=zMNjEphEPO6B3cD1GNpit7z-yA9tUU5-j3W2v-UWstU,92
+sonusai-1.0.12.dist-info/RECORD,,

sonusai/mixture/db_file.py

@@ -1,10 +0,0 @@
-from os.path import join
-from os.path import normpath
-
-from .constants import MIXDB_NAME
-from .constants import TEST_MIXDB_NAME
-
-
-def db_file(location: str, test: bool = False) -> str:
-    name = TEST_MIXDB_NAME if test else MIXDB_NAME
-    return normpath(join(location, name))