sonusai 0.18.8__py3-none-any.whl → 0.19.5__py3-none-any.whl

sonusai/mixture/db_datatypes.py

@@ -1,72 +1,56 @@
 from collections import namedtuple
 
-TruthSettingRecord = namedtuple('TruthSettingRecord', [
-    'id',
-    'setting'])
-
-TargetFileRecord = namedtuple('TargetFileRecord', [
-    'id',
-    'name',
-    'samples',
-    'level_type',
-    'speaker_id'])
-
-NoiseFileRecord = namedtuple('NoiseFileRecord', [
-    'id',
-    'name',
-    'samples'])
-
-TopRecord = namedtuple('TopRecord', [
-    'id',
-    'version',
-    'class_balancing',
-    'feature',
-    'noise_mix_mode',
-    'num_classes',
-    'seed',
-    'truth_mutex',
-    'truth_reduction_function',
-    'mixid_width',
-    'speaker_metadata_tiers',
-    'textgrid_metadata_tiers'])
-
-ClassLabelRecord = namedtuple('ClassLabelRecord', [
-    'id',
-    'label'])
-
-ClassWeightsThresholdRecord = namedtuple('ClassWeightsThresholdRecord', [
-    'id',
-    'threshold'])
-
-ImpulseResponseFileRecord = namedtuple('ImpulseResponseFileRecord', [
-    'id',
-    'file'])
-
-SpectralMaskRecord = namedtuple('SpectralMaskRecord', [
-    'id',
-    'f_max_width',
-    'f_num',
-    't_max_width',
-    't_num',
-    't_max_percent'])
-
-TargetRecord = namedtuple('TargetRecord', [
-    'id',
-    'file_id',
-    'augmentation',
-    'gain'])
-
-MixtureRecord = namedtuple('MixtureRecord', [
-    'id',
-    'name',
-    'noise_file_id',
-    'noise_augmentation',
-    'noise_offset',
-    'noise_snr_gain',
-    'random_snr',
-    'snr',
-    'samples',
-    'spectral_mask_id',
-    'spectral_mask_seed',
-    'target_snr_gain'
-])
+TruthConfigRecord = namedtuple("TruthConfigRecord", ["id", "name", "function", "stride_reduction", "config"])
+
+TruthParametersRecord = namedtuple("TruthParametersRecord", ["id", "name", "parameters"])
+
+TargetFileRecord = namedtuple("TargetFileRecord", ["id", "name", "samples", "class_indices", "level_type", "speaker_id"])
+
+NoiseFileRecord = namedtuple("NoiseFileRecord", ["id", "name", "samples"])
+
+TopRecord = namedtuple(
+    "TopRecord",
+    [
+        "id",
+        "version",
+        "class_balancing",
+        "feature",
+        "noise_mix_mode",
+        "num_classes",
+        "seed",
+        "mixid_width",
+        "speaker_metadata_tiers",
+        "textgrid_metadata_tiers",
+    ],
+)
+
+ClassLabelRecord = namedtuple("ClassLabelRecord", ["id", "label"])
+
+ClassWeightsThresholdRecord = namedtuple("ClassWeightsThresholdRecord", ["id", "threshold"])
+
+ImpulseResponseFileRecord = namedtuple("ImpulseResponseFileRecord", ["id", "file"])
+
+SpectralMaskRecord = namedtuple(
+    "SpectralMaskRecord",
+    ["id", "f_max_width", "f_num", "t_max_width", "t_num", "t_max_percent"],
+)
+
+TargetRecord = namedtuple("TargetRecord", ["id", "file_id", "augmentation", "gain"])
+
+MixtureRecord = namedtuple(
+    "MixtureRecord",
+    [
+        "id",
+        "name",
+        "noise_file_id",
+        "noise_augmentation",
+        "noise_offset",
+        "noise_snr_gain",
+        "random_snr",
+        "snr",
+        "samples",
+        "spectral_mask_id",
+        "spectral_mask_seed",
+        "target_snr_gain",
+    ],
+)

sonusai/mixture/eq_rule_is_valid.py

@@ -8,7 +8,7 @@ def eq_rule_is_valid(rule: Any) -> bool:
     """
 
     # Must be a list or string equal to 'none'
-    if isinstance(rule, str) and rule == 'none':
+    if isinstance(rule, str) and rule == "none":
         return True
 
     if not isinstance(rule, list):
@@ -27,22 +27,19 @@ def eq_rule_is_valid(rule: Any) -> bool:
         if not all(isinstance(el, float | int | str) for el in r):
             return False
 
-        if isinstance(r, str) and r == 'none':
+        if isinstance(r, str) and r == "none":
             continue
 
         for el in r:
             # If a string, item must start with 'rand'
-            if isinstance(el, str) and not el.startswith('rand'):
+            if isinstance(el, str) and not el.startswith("rand"):
                 return False
 
     return True
 
 
 def _check_for_none(rule: Any) -> bool:
-    """Check if EQ rule is 'none'
-    """
-    if isinstance(rule, str) and rule == 'none':
-        return True
-    if isinstance(rule, list) and len(rule) == 3:
+    """Check if EQ rule is 'none'"""
+    if isinstance(rule, str) and rule == "none":
         return True
-    return False
+    return bool(isinstance(rule, list) and len(rule) == 3)

sonusai/mixture/feature.py

@@ -1,46 +1,38 @@
-from typing import Optional
-
 from sonusai.mixture.datatypes import AudioT
 from sonusai.mixture.datatypes import Feature
 
 
-def get_feature_from_audio(audio: AudioT,
-                           feature_mode: str,
-                           num_classes: Optional[int] = 1,
-                           truth_mutex: Optional[bool] = False) -> Feature:
+def get_feature_from_audio(
+    audio: AudioT,
+    feature_mode: str,
+) -> Feature:
     """Apply forward transform and generate feature data from audio data
 
     :param audio: Time domain audio data [samples]
     :param feature_mode: Feature mode
-    :param num_classes: Number of classes
-    :param truth_mutex: Whether to calculate 'other' label
     :return: Feature data [frames, strides, feature_parameters]
     """
     import numpy as np
     from pyaaware import FeatureGenerator
 
-    from .augmentation import pad_audio_to_frame
     from .datatypes import TransformConfig
     from .helpers import forward_transform
 
-    fg = FeatureGenerator(feature_mode=feature_mode,
-                          num_classes=num_classes,
-                          truth_mutex=truth_mutex)
-
-    feature_step_samples = fg.ftransform_R * fg.decimation * fg.step
-    audio = pad_audio_to_frame(audio, feature_step_samples)
-
-    audio_f = forward_transform(audio=audio,
-                                config=TransformConfig(N=fg.ftransform_N,
-                                                       R=fg.ftransform_R,
-                                                       bin_start=fg.bin_start,
-                                                       bin_end=fg.bin_end,
-                                                       ttype=fg.ftransform_ttype))
-
-    samples = len(audio)
-    transform_frames = samples // fg.ftransform_R
-    feature_frames = samples // feature_step_samples
-
+    fg = FeatureGenerator(feature_mode=feature_mode)
+
+    audio_f = forward_transform(
+        audio=audio,
+        config=TransformConfig(
+            length=fg.ftransform_length,
+            overlap=fg.ftransform_overlap,
+            bin_start=fg.bin_start,
+            bin_end=fg.bin_end,
+            ttype=fg.ftransform_ttype,
+        ),
+    )
+
+    transform_frames = audio_f.shape[0]
+    feature_frames = transform_frames // (fg.decimation * fg.step)
     feature = np.empty((feature_frames, fg.stride, fg.feature_parameters), dtype=np.float32)
 
     feature_frame = 0
@@ -54,37 +46,49 @@ def get_feature_from_audio(audio: AudioT,
     return feature
 
 
-def get_audio_from_feature(feature: Feature,
-                           feature_mode: str,
-                           num_classes: Optional[int] = 1,
-                           truth_mutex: Optional[bool] = False) -> AudioT:
+def get_audio_from_feature(
+    feature: Feature,
+    feature_mode: str,
+    num_classes: int | None = 1,
+    truth_mutex: bool | None = False,
+) -> AudioT:
     """Apply inverse transform to feature data to generate audio data
 
-    :param feature: Feature data [frames, strides, feature_parameters]
+    :param feature: Feature data [frames, stride=1, feature_parameters]
     :param feature_mode: Feature mode
     :param num_classes: Number of classes
     :param truth_mutex: Whether to calculate 'other' label
     :return: Audio data [samples]
     """
     import numpy as np
-
     from pyaaware import FeatureGenerator
 
+    from sonusai.utils.compress import power_uncompress
+    from sonusai.utils.stacked_complex import unstack_complex
+
     from .datatypes import TransformConfig
     from .helpers import inverse_transform
-    from sonusai.utils.stacked_complex import unstack_complex
-    from sonusai.utils.compress import power_uncompress
 
-    fg = FeatureGenerator(feature_mode=feature_mode,
-                          num_classes=num_classes,
-                          truth_mutex=truth_mutex)
+    if feature.ndim != 3:
+        raise ValueError("feature must have 3 dimensions: [frames, stride=1, feature_parameters]")
+
+    if feature.shape[1] != 1:
+        raise ValueError("Strided feature data is not supported for audio extraction; stride must be 1.")
+
+    fg = FeatureGenerator(feature_mode=feature_mode, num_classes=num_classes, truth_mutex=truth_mutex)
 
-    feature_complex = unstack_complex(feature)
-    if feature_mode[0:1] == 'h':
+    feature_complex = unstack_complex(feature.squeeze())
+    if feature_mode[0:1] == "h":
         feature_complex = power_uncompress(feature_complex)
-    return np.squeeze(inverse_transform(transform=feature_complex,
-                                        config=TransformConfig(N=fg.itransform_N,
-                                                               R=fg.itransform_R,
-                                                               bin_start=fg.bin_start,
-                                                               bin_end=fg.bin_end,
-                                                               ttype=fg.itransform_ttype)))
+    return np.squeeze(
+        inverse_transform(
+            transform=feature_complex,
+            config=TransformConfig(
+                length=fg.itransform_length,
+                overlap=fg.itransform_overlap,
+                bin_start=fg.bin_start,
+                bin_end=fg.bin_end,
+                ttype=fg.itransform_ttype,
+            ),
+        )
+    )