sonusai 0.18.9__py3-none-any.whl → 0.19.6__py3-none-any.whl

sonusai/metrics/one_hot.py

@@ -4,44 +4,46 @@ from sonusai.mixture.datatypes import Predict
 from sonusai.mixture.datatypes import Truth
 
 
-def one_hot(truth: Truth,
-            predict: Predict,
-            predict_thr: float | np.ndarray = 0,
-            truth_thr: float = 0.5,
-            timesteps: int = -1) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
-    """ Calculates metrics from one-hot prediction and truth data (numpy float arrays) where
-        both are one-hot probabilities (or quantized decisions) for each class
-        with size [frames, num_classes] or [frames, timesteps, num_classes].
-        For metrics that require it, truth and pred decisions will be made using threshold >= predict_thr.
-        Some metrics like AP and AUC do not depend on predict_thr for predict, but still use truth >= predict_thr
-
-        predict_thr sets the decision threshold(s) applied to predict data for some metrics, thus allowing
-        the input to be continuous probabilities, for AUC-type metrics and root-mean-square error (rmse).
-        1. Default = 0 (multiclass or binary) which infers:
-           binary (num_classes = 1)         use >= 0.5 for truth and pred (same as argmax() for binary)
-           multi-class/single-label    if truth_mutex= = true, use argmax() used on both truth and pred
-           note multilabel metrics are disabled for predict_thr = 0, must set predict_thr > 0
-
-        2. predict_thr > 0 (multilabel or binary) scalar or a vector [num_classes, 1] then use
-           predict_thr as a binary decision threshold in each class:
-           binary (num_classes = 1)         use >= predict_thr[0] for pred and predict_thr[num_classes+1] for truth
-                                       if it exists, else use >= 0.5 for truth
-           multilabel                  use >= predict_thr for pred if scalar, or predict_thr[class_idx] if vector
-                                       use >= predict_thr[num_classes+1] for truth if exists, else 0.5
-           note multi-class/single-label inputs are meaningless in this mode, use predict_thr = 0 argmax mode
-
-        num_classes is inferred from 1D, 2D, or 3D truth inputs by default (default timesteps = -1 which implies None).
-        Only set timesteps > 0 in case of ambiguous binary 2D case where input [frames, timesteps],
-        then it must set to the number of timesteps (which will be > 0).
-        It is safe to always set timesteps <= 0 for binary inputs, and if truth.shape[2] exists
-
-        returns metrics over all frames + timesteps:
-        mcm     [num_classes, 2, 2]            multiclass confusion matrix count ove
-        metrics [num_classes, 14]              [ACC, TPR, PPV, TNR, FPR, HITFA, F1, MCC, NT, PT, TP, FP, AP, AUC]
-        cm      [num_classes, num_classes]     confusion matrix
-        cmn     [num_classes, num_classes]     normalized confusion matrix
-        rmse    [num_classes, 1]               RMS error over all frames + timesteps, before threshold decision
-        mavg    [3, 8] averages                macro, micro, weighted [PPV, TPR, F1, FPR, ACC, mAP, mAUC, TPSUM]
+def one_hot(
+    truth: Truth,
+    predict: Predict,
+    predict_thr: float | np.ndarray = 0,
+    truth_thr: float = 0.5,
+    timesteps: int = -1,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    """Calculates metrics from one-hot prediction and truth data (numpy float arrays) where
+    both are one-hot probabilities (or quantized decisions) for each class
+    with size [frames, num_classes] or [frames, timesteps, num_classes].
+    For metrics that require it, truth and pred decisions will be made using threshold >= predict_thr.
+    Some metrics like AP and AUC do not depend on predict_thr for predict, but still use truth >= predict_thr
+
+    predict_thr sets the decision threshold(s) applied to predict data for some metrics, thus allowing
+    the input to be continuous probabilities, for AUC-type metrics and root-mean-square error (rmse).
+    1. Default = 0 (multiclass or binary) which infers:
+       binary (num_classes = 1)         use >= 0.5 for truth and pred (same as argmax() for binary)
+       multi-class/single-label    if truth_mutex= = true, use argmax() used on both truth and pred
+       note multilabel metrics are disabled for predict_thr = 0, must set predict_thr > 0
+
+    2. predict_thr > 0 (multilabel or binary) scalar or a vector [num_classes, 1] then use
+       predict_thr as a binary decision threshold in each class:
+       binary (num_classes = 1)         use >= predict_thr[0] for pred and predict_thr[num_classes+1] for truth
+                                   if it exists, else use >= 0.5 for truth
+       multilabel                  use >= predict_thr for pred if scalar, or predict_thr[class_idx] if vector
+                                   use >= predict_thr[num_classes+1] for truth if exists, else 0.5
+       note multi-class/single-label inputs are meaningless in this mode, use predict_thr = 0 argmax mode
+
+    num_classes is inferred from 1D, 2D, or 3D truth inputs by default (default timesteps = -1 which implies None).
+    Only set timesteps > 0 in case of ambiguous binary 2D case where input [frames, timesteps],
+    then it must set to the number of timesteps (which will be > 0).
+    It is safe to always set timesteps <= 0 for binary inputs, and if truth.shape[2] exists
+
+    returns metrics over all frames + timesteps:
+    mcm     [num_classes, 2, 2]            multiclass confusion matrix count ove
+    metrics [num_classes, 14]              [ACC, TPR, PPV, TNR, FPR, HITFA, F1, MCC, NT, PT, TP, FP, AP, AUC]
+    cm      [num_classes, num_classes]     confusion matrix
+    cmn     [num_classes, num_classes]     normalized confusion matrix
+    rmse    [num_classes, 1]               RMS error over all frames + timesteps, before threshold decision
+    mavg    [3, 8] averages                macro, micro, weighted [PPV, TPR, F1, FPR, ACC, mAP, mAUC, TPSUM]
     """
     import warnings
 
@@ -51,14 +53,13 @@ def one_hot(truth: Truth,
     from sklearn.metrics import precision_recall_fscore_support
     from sklearn.metrics import roc_auc_score
 
-    from sonusai import SonusAIError
     from sonusai.utils import get_num_classes_from_predict
     from sonusai.utils import reshape_outputs
 
     if truth.shape != predict.shape:
-        raise SonusAIError('truth and predict are not the same shape')
+        raise ValueError("truth and predict are not the same shape")
 
-    predict, truth = reshape_outputs(predict=predict, truth=truth, timesteps=timesteps)
+    predict, truth = reshape_outputs(predict=predict, truth=truth, timesteps=timesteps)  # type: ignore[assignment]
     num_classes = get_num_classes_from_predict(predict=predict, timesteps=timesteps)
 
     # Regression metric root-mean-square-error always works
@@ -79,7 +80,8 @@ def one_hot(truth: Truth,
     else:
         if predict_thr.ndim > 1:
             # multilabel with custom thr vector
-            assert predict_thr.shape[0] == num_classes
+            if predict_thr.shape[0] != num_classes:
+                raise ValueError("predict_thr has wrong shape")
         else:
             if predict_thr == 0:
                 # binary or multilabel scalar default
@@ -89,18 +91,18 @@ def one_hot(truth: Truth,
                 predict_thr = np.atleast_1d(predict_thr)
 
     if not isinstance(predict_thr, np.ndarray):
-        raise SonusAIError(f'predict_thr is invalid type: {type(predict_thr)}')
+        raise TypeError(f"predict_thr is invalid type: {type(predict_thr)}")
 
     # Convert continuous probabilities to binary via argmax() or threshold comparison
     # and create labels of int encoded (0:num_classes-1), and then equivalent one-hot
     if num_classes == 1:  # If binary
-        labels = ([i for i in range(0, 2)])  # int encoded 0,1
+        labels = list(range(0, 2))  # int encoded 0,1
         plabel = np.int8(predict >= predict_thr)  # [frames, 1], default 0.5 is equiv. to argmax()
         tlabel = np.int8(truth >= truth_thr)  # [frames, 1]
         predb = np.array(plabel)
         truthb = np.array(tlabel)
     else:
-        labels = ([i for i in range(0, num_classes)])  # int encoded 0,...,num_classes-1
+        labels = list(range(0, num_classes))  # int encoded 0,...,num_classes-1
         if predict_thr[0] == 0:  # multiclass single-label (mutex), use argmax
             plabel = np.argmax(predict, axis=-1)  # [frames, 1] labels
             tlabel = np.argmax(truth, axis=-1)  # [frames, 1] labels
@@ -134,7 +136,7 @@ def one_hot(truth: Truth,
         mcm = mcm[1:]  # remove dim 0 if binary
 
     # Create [num_classes, num_classes] normalized confusion matrix
-    cmn = confusion_matrix(tlabel, plabel, labels=labels, normalize='true')
+    cmn = confusion_matrix(tlabel, plabel, labels=labels, normalize="true")
 
     # Create [num_classes, num_classes] confusion matrix
     cm = confusion_matrix(tlabel, plabel, labels=labels)
@@ -194,7 +196,22 @@ def one_hot(truth: Truth,
             # ix = np.argmax(fscore)  # index of largest f1 score
             # threshold_optpr[nci] = thresholds[ix]
 
-        metrics[nci, :] = [ACC, TPR, PPV, TNR, FPR, HITFA, F1, MCC, NT, PT, TP, FP, AP, AUC]
+        metrics[nci, :] = [
+            ACC,
+            TPR,
+            PPV,
+            TNR,
+            FPR,
+            HITFA,
+            F1,
+            MCC,
+            NT,
+            PT,
+            TP,
+            FP,
+            AP,
+            AUC,
+        ]
 
     # Calculate averages into single array, 3 types for now Macro, Micro, Weighted
     mavg = np.zeros((3, 8), dtype=np.float32)
@@ -202,9 +219,17 @@ def one_hot(truth: Truth,
 
     # macro average [PPV, TPR, F1, FPR, ACC, mAP, mAUC, TPSUM]
     with warnings.catch_warnings():
-        warnings.filterwarnings(action='ignore', message='Mean of empty slice')
-        mavg[0, :] = [np.mean(metrics[:, 2]), np.mean(metrics[:, 1]), np.mean(metrics[:, 6]), np.mean(metrics[:, 4]),
-                      np.mean(metrics[:, 0]), np.nanmean(metrics[:, 12]), np.nanmean(metrics[:, 13]), s]
+        warnings.filterwarnings(action="ignore", message="Mean of empty slice")
+        mavg[0, :] = [
+            np.mean(metrics[:, 2]),
+            np.mean(metrics[:, 1]),
+            np.mean(metrics[:, 6]),
+            np.mean(metrics[:, 4]),
+            np.mean(metrics[:, 0]),
+            np.nanmean(metrics[:, 12]),
+            np.nanmean(metrics[:, 13]),
+            s,
+        ]
 
     # micro average, micro-F1 = micro-precision = micro-recall = accuracy
     if num_classes > 1:
@@ -218,25 +243,34 @@ def one_hot(truth: Truth,
         tn_sum = sum(mcm[:, 0, 0])
         accm = (tp_sum + tn_sum) / (tp_sum + tn_sum + fp_sum + fn_sum + eps)
         with warnings.catch_warnings():
-            warnings.filterwarnings(action='ignore', message='invalid value encountered in true_divide')
-            miap = average_precision_score(truthb, predict, average='micro')
+            warnings.filterwarnings(action="ignore", message="invalid value encountered in true_divide")
+            miap = average_precision_score(truthb, predict, average="micro")
         if np.sum(truthb):  # no activity over all classes
-            miauc = roc_auc_score(truthb, predict, average='micro')
+            miauc = roc_auc_score(truthb, predict, average="micro")
         else:
             miauc = np.NaN
 
         # [miPPV, miTPR, miF1, miFPR, miACC, miAP, miAUC, TPSUM]
-        mavg[1, :] = [pm, rm, f1m, fpm, accm, miap, miauc, s]  # specific format, last 3 are unique
+        mavg[1, :] = [
+            pm,
+            rm,
+            f1m,
+            fpm,
+            accm,
+            miap,
+            miauc,
+            s,
+        ]  # specific format, last 3 are unique
 
         # weighted average TBD
-        wp, wr, wf1, _ = precision_recall_fscore_support(truthb, predb, average='weighted', zero_division=0)
+        wp, wr, wf1, _ = precision_recall_fscore_support(truthb, predb, average="weighted", zero_division=0)
         if np.sum(truthb):
             taidx = np.sum(truthb, axis=0) > 0
-            wap = average_precision_score(truthb[:, taidx], predict[:, taidx], average='weighted')
+            wap = average_precision_score(truthb[:, taidx], predict[:, taidx], average="weighted")
             if len(np.unique(truthb[:, taidx])) < 2:
                 wauc = np.NaN
             else:
-                wauc = roc_auc_score(truthb[:, taidx], predict[:, taidx], average='weighted')
+                wauc = roc_auc_score(truthb[:, taidx], predict[:, taidx], average="weighted")
         else:
             wap = np.NaN
             wauc = np.NaN

sonusai/metrics/snr_summary.py

@@ -1,3 +1,4 @@
+# ruff: noqa: F821
 import numpy as np
 import pandas as pd
 
@@ -8,32 +9,34 @@ from sonusai.mixture import Segsnr
 from sonusai.mixture import Truth
 
 
-def snr_summary(mixdb: MixtureDatabase,
-                mixid: GeneralizedIDs,
-                truth_f: Truth,
-                predict: Predict,
-                segsnr: Segsnr = None,
-                predict_thr: float | np.ndarray = 0,
-                truth_thr: float = 0.5,
-                timesteps: int = 0) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame, dict]:
+def snr_summary(
+    mixdb: MixtureDatabase,
+    mixid: GeneralizedIDs,
+    truth_f: Truth,
+    predict: Predict,
+    segsnr: Segsnr | None = None,
+    predict_thr: float | np.ndarray = 0,
+    truth_thr: float = 0.5,
+    timesteps: int = 0,
+) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame, dict]:
     """Calculate average-over-class metrics per SNR over specified mixture list.
-       Inputs:
-         mixdb        Mixture database
-         mixid
-         truth_f      Truth/labels [features, num_classes]
-         predict      Prediction data / neural net model one-hot out [features, num_classes]
-         segsnr       Segmental SNR from SonusAI genft  [transform_frames, 1]
-         predict_thr  Decision threshold(s) applied to predict data, allowing predict to be
-                      continuous probabilities or decisions
-         truth_thr    Decision threshold(s) applied to truth data, allowing truth to be
-                      continuous probabilities or decisions
-         timesteps
-
-       Default predict_thr=0 will infer 0.5 for multi-label mode (truth_mutex = False), or
-       if single-label mode (truth_mutex == True) then ignore and use argmax mode, and
-       the confusion matrix is calculated for all classes.
-
-       Returns pandas dataframe (snrdf) of metrics per SNR.
+    Inputs:
+      mixdb        Mixture database
+      mixid
+      truth_f      Truth/labels [features, num_classes]
+      predict      Prediction data / neural net model one-hot out [features, num_classes]
+      segsnr       Segmental SNR from SonusAI genft  [transform_frames, 1]
+      predict_thr  Decision threshold(s) applied to predict data, allowing predict to be
+                   continuous probabilities or decisions
+      truth_thr    Decision threshold(s) applied to truth data, allowing truth to be
+                   continuous probabilities or decisions
+      timesteps
+
+    Default predict_thr=0 will infer 0.5 for multi-label mode (truth_mutex = False), or
+    if single-label mode (truth_mutex == True) then ignore and use argmax mode, and
+    the confusion matrix is calculated for all classes.
+
+    Returns pandas dataframe (snrdf) of metrics per SNR.
     """
     import warnings
 
@@ -53,14 +56,13 @@ def snr_summary(mixdb: MixtureDatabase,
             else:
                 predict_thr = np.atleast_1d(predict_thr)
         else:
-            if predict_thr.ndim == 1:
-                if len(predict_thr) == 1:
-                    if predict_thr[0] == 0:
-                        # multi-label predict_thr array scalar 0 force to 0.5 default
-                        predict_thr = np.atleast_1d(0.5)
-                    else:
-                        # multi-label predict_thr array set to scalar = array[0]
-                        predict_thr = predict_thr[0]
+            if predict_thr.ndim == 1 and len(predict_thr) == 1:
+                if predict_thr[0] == 0:
+                    # multi-label predict_thr array scalar 0 force to 0.5 default
+                    predict_thr = np.atleast_1d(0.5)
+                else:
+                    # multi-label predict_thr array set to scalar = array[0]
+                    predict_thr = predict_thr[0]
 
     macro_avg = np.zeros((len(snr_mixids), 7), dtype=np.float32)
     micro_avg = np.zeros((len(snr_mixids), 7), dtype=np.float32)
@@ -72,13 +74,16 @@ def snr_summary(mixdb: MixtureDatabase,
         # prep segsnr if provided, transform frames to feature frames via mean()
         # expected to always be an integer
         feature_frames = int(segsnr.shape[0] / truth_f.shape[0])
-        segsnr_f = np.mean(np.reshape(segsnr, (truth_f.shape[0], feature_frames)), axis=1, keepdims=True)
+        segsnr_f = np.mean(
+            np.reshape(segsnr, (truth_f.shape[0], feature_frames)),
+            axis=1,
+            keepdims=True,
+        )
         ssnr_stats = np.zeros((len(snr_mixids), 3), dtype=np.float32)
 
-    ii = 0
-    for snr in snr_mixids:
+    for ii, snr in enumerate(snr_mixids):
         # TODO: re-work for modern mixdb API
-        y_truth, y_predict = get_mixids_data(mixdb, snr_mixids[snr], truth_f, predict)  # type: ignore
+        y_truth, y_predict = get_mixids_data(mixdb, snr_mixids[snr], truth_f, predict)  # type: ignore[name-defined]
         _, metrics, _, _, _, mavg = one_hot(y_truth, y_predict, predict_thr, truth_thr, timesteps)
 
         # mavg macro, micro, weighted: [PPV, TPR, F1, FPR, ACC, mAP, mAUC, TPSUM]
@@ -87,20 +92,18 @@ def snr_summary(mixdb: MixtureDatabase,
         wghtd_avg[ii, :] = mavg[2, 0:7]
         if segsnr is not None:
             # TODO: re-work for modern mixdb API
-            y_truth, y_segsnr = get_mixids_data(mixdb, snr_mixids[snr], truth_f, segsnr_f)  # type: ignore
+            y_truth, y_segsnr = get_mixids_data(mixdb, snr_mixids[snr], truth_f, segsnr_f)  # type: ignore[name-defined]
             with warnings.catch_warnings():
-                warnings.filterwarnings(action='ignore', message='divide by zero encountered in log10')
+                warnings.filterwarnings(action="ignore", message="divide by zero encountered in log10")
                 # segmental SNR mean = mixture_snr and target_snr
-                ssnr_stats[ii, 0] = 10 * np.log10(np.mean(y_segsnr))
+                ssnr_stats[ii, 0] = 10 * np.log10(np.mean(y_segsnr))  # type: ignore[index]
                 # segmental SNR 80% percentile
-                ssnr_stats[ii, 1] = 10 * np.log10(np.percentile(y_segsnr, 80, method='midpoint'))
+                ssnr_stats[ii, 1] = 10 * np.log10(np.percentile(y_segsnr, 80, method="midpoint"))  # type: ignore[index]
                 # segmental SNR max
-                ssnr_stats[ii, 2] = 10 * np.log10(max(y_segsnr))
-
-        ii += 1
+                ssnr_stats[ii, 2] = 10 * np.log10(max(y_segsnr))  # type: ignore[index]
 
     # SNR format: PPV, TPR, F1, FPR, ACC, AP, AUC
-    col_n = ['PPV', 'TPR', 'F1', 'FPR', 'ACC', 'AP', 'AUC']
+    col_n = ["PPV", "TPR", "F1", "FPR", "ACC", "AP", "AUC"]
     snr_macrodf = pd.DataFrame(macro_avg, index=list(snr_mixids.keys()), columns=col_n)
     snr_macrodf.sort_index(ascending=False, inplace=True)
 
@@ -112,7 +115,11 @@ def snr_summary(mixdb: MixtureDatabase,
 
     # Add segmental SNR columns if provided
     if segsnr is not None:
-        ssnrdf = pd.DataFrame(ssnr_stats, index=list(snr_mixids.keys()), columns=['SSNRavg', 'SSNR80p', 'SSNRmax'])
+        ssnrdf = pd.DataFrame(
+            ssnr_stats,
+            index=list(snr_mixids.keys()),
+            columns=["SSNRavg", "SSNR80p", "SSNRmax"],
+        )
         ssnrdf.sort_index(ascending=False, inplace=True)
         snr_macrodf = pd.concat([snr_macrodf, ssnrdf], axis=1)
         snr_microdf = pd.concat([snr_microdf, ssnrdf], axis=1)

sonusai/mixture/__init__.py

@@ -1,4 +1,6 @@
 # SonusAI mixture utilities
+# ruff: noqa: F401
+
 from .audio import get_duration
 from .audio import get_next_noise
 from .audio import get_num_samples
@@ -19,15 +21,15 @@ from .augmentation import pad_audio_to_length
 from .class_count import get_class_count_from_mixids
 from .config import get_default_config
 from .config import get_impulse_response_files
-from .config import get_max_class
 from .config import get_noise_files
 from .config import get_spectral_masks
 from .config import get_target_files
+from .config import get_truth_parameters
 from .config import load_config
 from .config import raw_load_config
 from .config import update_config_from_file
 from .config import update_config_from_hierarchy
-from .config import update_truth_settings
+from .config import validate_truth_configs
 from .constants import BIT_DEPTH
 from .constants import CHANNEL_COUNT
 from .constants import DEFAULT_CONFIG
@@ -35,19 +37,22 @@ from .constants import DEFAULT_NOISE
 from .constants import DEFAULT_SPEECH
 from .constants import ENCODING
 from .constants import FLOAT_BYTES
+from .constants import MIXDB_VERSION
 from .constants import RAND_PATTERN
 from .constants import REQUIRED_CONFIGS
+from .constants import REQUIRED_TRUTH_CONFIGS
 from .constants import SAMPLE_BYTES
 from .constants import SAMPLE_RATE
 from .constants import VALID_AUGMENTATIONS
 from .constants import VALID_CONFIGS
 from .constants import VALID_NOISE_MIX_MODES
-from .constants import VALID_TRUTH_SETTINGS
+from .data_io import read_cached_data
+from .data_io import write_cached_data
 from .datatypes import AudioF
-from .datatypes import AudioStatsMetrics
-from .datatypes import AudioT
 from .datatypes import AudiosF
 from .datatypes import AudiosT
+from .datatypes import AudioStatsMetrics
+from .datatypes import AudioT
 from .datatypes import Augmentation
 from .datatypes import AugmentationRule
 from .datatypes import AugmentationRules
@@ -60,10 +65,11 @@ from .datatypes import EnergyT
 from .datatypes import Feature
 from .datatypes import FeatureGeneratorConfig
 from .datatypes import FeatureGeneratorInfo
+from .datatypes import GeneralizedIDs
 from .datatypes import GenFTData
 from .datatypes import GenMixData
-from .datatypes import GeneralizedIDs
 from .datatypes import ImpulseResponseData
+from .datatypes import ImpulseResponseFile
 from .datatypes import ImpulseResponseFiles
 from .datatypes import ListAudiosT
 from .datatypes import MetricDoc
@@ -84,9 +90,11 @@ from .datatypes import TargetFile
 from .datatypes import TargetFiles
 from .datatypes import TransformConfig
 from .datatypes import Truth
-from .datatypes import TruthFunctionConfig
-from .datatypes import TruthSetting
-from .datatypes import TruthSettings
+from .datatypes import TruthConfig
+from .datatypes import TruthConfigs
+from .datatypes import TruthDict
+from .datatypes import TruthParameter
+from .datatypes import TruthParameters
 from .datatypes import UniversalSNR
 from .feature import get_audio_from_feature
 from .feature import get_feature_from_audio
@@ -101,6 +109,7 @@ from .generation import populate_noise_file_table
 from .generation import populate_spectral_mask_table
 from .generation import populate_target_file_table
 from .generation import populate_top_table
+from .generation import populate_truth_parameters_table
 from .generation import update_mixid_width
 from .generation import update_mixture
 from .helpers import augmented_noise_samples
@@ -112,11 +121,9 @@ from .helpers import get_audio_from_transform
 from .helpers import get_ft
 from .helpers import get_segsnr
 from .helpers import get_transform_from_audio
-from .helpers import get_truth_t
+from .helpers import get_truth
 from .helpers import inverse_transform
 from .helpers import mixture_metadata
-from .helpers import read_mixture_data
-from .helpers import write_mixture_data
 from .helpers import write_mixture_metadata
 from .log_duration_and_sizes import log_duration_and_sizes
 from .mixdb import MixtureDatabase
@@ -128,9 +135,8 @@ from .targets import get_augmented_target_ids_by_class
 from .targets import get_augmented_target_ids_for_mixup
 from .targets import get_augmented_targets
 from .targets import get_target_augmentations_for_mixup
-from .targets import get_truth_indices_for_target
 from .tokenized_shell_vars import tokenized_expand
 from .tokenized_shell_vars import tokenized_replace
 from .truth import get_truth_indices_for_mixid
 from .truth import truth_function
-from .truth import truth_reduction
+from .truth import truth_stride_reduction

sonusai/mixture/audio.py

@@ -15,7 +15,7 @@ def get_next_noise(audio: AudioT, offset: int, length: int) -> AudioT:
     """
     import numpy as np
 
-    return np.take(audio, range(offset, offset + length), mode='wrap')
+    return np.take(audio, range(offset, offset + length), mode="wrap")
 
 
 def get_duration(audio: AudioT) -> float:
@@ -35,15 +35,13 @@ def validate_input_file(input_filepath: str | Path) -> None:
 
     from soundfile import available_formats
 
-    from sonusai import SonusAIError
-
     if not exists(input_filepath):
-        raise SonusAIError(f'input_filepath {input_filepath} does not exist.')
+        raise OSError(f"input_filepath {input_filepath} does not exist.")
 
     ext = splitext(input_filepath)[1][1:].lower()
-    read_formats = [item.lower() for item in available_formats().keys()]
+    read_formats = [item.lower() for item in available_formats()]
     if ext not in read_formats:
-        raise SonusAIError(f'This installation cannot process .{ext} files')
+        raise OSError(f"This installation cannot process .{ext} files")
 
 
 @lru_cache