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

sonusai/mixture/truth_functions/energy.py

@@ -1,20 +1,44 @@
 import numpy as np
 
-from sonusai.mixture.datatypes import Truth
-from sonusai.mixture.truth_functions.datatypes import TruthFunctionConfig
-from sonusai.mixture.truth_functions.datatypes import TruthFunctionData
+from sonusai.mixture import MixtureDatabase
+from sonusai.mixture import Truth
+from sonusai.utils import load_object
+
+
+def _core(
+    mixdb: MixtureDatabase,
+    m_id: int,
+    target_index: int,
+    config: dict,
+    parameters: int,
+    mapped: bool,
+    snr: bool,
+) -> Truth:
+    from os.path import join
 
+    import torch
+    from pyaaware import ForwardTransform
+    from pyaaware import feature_forward_transform_config
 
-def _core(data: TruthFunctionData, config: TruthFunctionConfig, mapped: bool, snr: bool) -> Truth:
     from sonusai.utils import compute_energy_f
 
-    target_energy = compute_energy_f(time_domain=data.target_audio, transform=config.target_fft)
+    target_audio = mixdb.mixture_targets(m_id)[target_index]
+    ft = ForwardTransform(**feature_forward_transform_config(mixdb.feature))
+
+    frames = ft.frames(torch.from_numpy(target_audio))
+
+    if mixdb.mixture(m_id).target_gain(target_index) == 0:
+        return np.zeros((frames, parameters), dtype=np.float32)
+
+    noise_audio = mixdb.mixture_noise(m_id)
+
+    target_energy = compute_energy_f(time_domain=target_audio, transform=ft)
     noise_energy = None
     if snr:
-        noise_energy = compute_energy_f(time_domain=data.noise_audio, transform=config.noise_fft)
+        noise_energy = compute_energy_f(time_domain=noise_audio, transform=ft)
 
     frames = len(target_energy)
-    truth = np.empty((frames, config.target_fft.bins), dtype=np.float32)
+    truth = np.empty((frames, ft.bins), dtype=np.float32)
     for frame in range(frames):
         tmp = target_energy[frame]
 
@@ -26,7 +50,9 @@ def _core(data: TruthFunctionData, config: TruthFunctionConfig, mapped: bool, sn
         tmp = np.nan_to_num(tmp, nan=-np.inf, posinf=np.inf, neginf=-np.inf)
 
         if mapped:
-            tmp = _calculate_mapped_snr_f(tmp, config.config["snr_db_mean"], config.config["snr_db_std"])
+            snr_db_mean = load_object(join(mixdb.location, config["snr_db_mean"]))
+            snr_db_std = load_object(join(mixdb.location, config["snr_db_std"]))
+            tmp = _calculate_mapped_snr_f(tmp, snr_db_mean, snr_db_std)
 
         truth[frame] = tmp
 
@@ -52,11 +78,14 @@ def energy_f_validate(_config: dict) -> None:
     pass
 
 
-def energy_f_parameters(config: TruthFunctionConfig) -> int:
-    return config.target_fft.bins
+def energy_f_parameters(feature: str, _num_classes: int, _config: dict) -> int:
+    from pyaaware import ForwardTransform
+    from pyaaware import feature_forward_transform_config
+
+    return ForwardTransform(**feature_forward_transform_config(feature)).bins
 
 
-def energy_f(data: TruthFunctionData, config: TruthFunctionConfig) -> Truth:
+def energy_f(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict) -> Truth:
     """Frequency domain energy truth generation function
 
     Calculates the true energy per bin:
@@ -67,23 +96,29 @@ def energy_f(data: TruthFunctionData, config: TruthFunctionConfig) -> Truth:
 
     Output shape: [:, bins]
     """
-    frames = config.target_fft.frames(data.target_audio)
-    parameters = energy_f_parameters(config)
-    if config.target_gain == 0:
-        return np.zeros((frames, parameters), dtype=np.float32)
-
-    return _core(data=data, config=config, mapped=False, snr=False)
+    return _core(
+        mixdb=mixdb,
+        m_id=m_id,
+        target_index=target_index,
+        config=config,
+        parameters=energy_f_parameters(mixdb.feature, mixdb.num_classes, config),
+        mapped=False,
+        snr=False,
+    )
 
 
 def snr_f_validate(_config: dict) -> None:
     pass
 
 
-def snr_f_parameters(config: TruthFunctionConfig) -> int:
-    return config.target_fft.bins
+def snr_f_parameters(feature: str, _num_classes: int, _config: dict) -> int:
+    from pyaaware import ForwardTransform
+    from pyaaware import feature_forward_transform_config
 
+    return ForwardTransform(**feature_forward_transform_config(feature)).bins
 
-def snr_f(data: TruthFunctionData, config: TruthFunctionConfig) -> Truth:
+
+def snr_f(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict) -> Truth:
     """Frequency domain SNR truth function documentation
 
     Calculates the true SNR per bin:
@@ -94,54 +129,58 @@ def snr_f(data: TruthFunctionData, config: TruthFunctionConfig) -> Truth:
 
     Output shape: [:, bins]
     """
-    frames = config.target_fft.frames(data.target_audio)
-    parameters = snr_f_parameters(config)
-    if config.target_gain == 0:
-        return np.zeros((frames, parameters), dtype=np.float32)
-
-    return _core(data=data, config=config, mapped=False, snr=True)
-
-
-def mapped_snr_f_validate(config: TruthFunctionConfig) -> None:
-    if len(config.config) == 0:
+    return _core(
+        mixdb=mixdb,
+        m_id=m_id,
+        target_index=target_index,
+        config=config,
+        parameters=snr_f_parameters(mixdb.feature, mixdb.num_classes, config),
+        mapped=False,
+        snr=True,
+    )
+
+
+def mapped_snr_f_validate(config: dict) -> None:
+    if len(config) == 0:
         raise AttributeError("mapped_snr_f truth function is missing config")
 
     for parameter in ("snr_db_mean", "snr_db_std"):
-        if parameter not in config.config:
+        if parameter not in config:
             raise AttributeError(f"mapped_snr_f truth function is missing required '{parameter}'")
 
-        if len(config.config[parameter]) != config.target_fft.bins:
-            raise ValueError(
-                f"mapped_snr_f truth function '{parameter}' does not have {config.target_fft.bins} elements"
-            )
 
+def mapped_snr_f_parameters(feature: str, _num_classes: int, _config: dict) -> int:
+    from pyaaware import ForwardTransform
+    from pyaaware import feature_forward_transform_config
 
-def mapped_snr_f_parameters(config: TruthFunctionConfig) -> int:
-    return config.target_fft.bins
+    return ForwardTransform(**feature_forward_transform_config(feature)).bins
 
 
-def mapped_snr_f(data: TruthFunctionData, config: TruthFunctionConfig) -> Truth:
+def mapped_snr_f(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict) -> Truth:
     """Frequency domain mapped SNR truth function documentation
 
     Output shape: [:, bins]
     """
-    frames = config.target_fft.frames(data.target_audio)
-    parameters = mapped_snr_f_parameters(config)
-    if config.target_gain == 0:
-        return np.zeros((frames, parameters), dtype=np.float32)
-
-    return _core(data=data, config=config, mapped=True, snr=True)
+    return _core(
+        mixdb=mixdb,
+        m_id=m_id,
+        target_index=target_index,
+        config=config,
+        parameters=mapped_snr_f_parameters(mixdb.feature, mixdb.num_classes, config),
+        mapped=True,
+        snr=True,
+    )
 
 
 def energy_t_validate(_config: dict) -> None:
     pass
 
 
-def energy_t_parameters(_config: TruthFunctionConfig) -> int:
+def energy_t_parameters(_feature: str, _num_classes: int, _config: dict) -> int:
     return 1
 
 
-def energy_t(data: TruthFunctionData, config: TruthFunctionConfig) -> Truth:
+def energy_t(mixdb: MixtureDatabase, m_id: int, target_index: int, _config: dict) -> Truth:
     """Time domain energy truth function documentation
 
     Calculates the true time domain energy of each frame:
@@ -164,10 +203,16 @@ def energy_t(data: TruthFunctionData, config: TruthFunctionConfig) -> Truth:
     transform config.
     """
     import torch
+    from pyaaware import ForwardTransform
+    from pyaaware import feature_forward_transform_config
+
+    target_audio = torch.from_numpy(mixdb.mixture_targets(m_id)[target_index])
+
+    ft = ForwardTransform(**feature_forward_transform_config(mixdb.feature))
 
-    frames = config.target_fft.frames(data.target_audio)
-    parameters = energy_t_parameters(config)
-    if config.target_gain == 0:
+    frames = ft.frames(target_audio)
+    parameters = energy_f_parameters(mixdb.feature, mixdb.num_classes, _config)
+    if mixdb.mixture(m_id).target_gain(target_index) == 0:
         return np.zeros((frames, parameters), dtype=np.float32)
 
-    return config.target_fft.execute_all(torch.from_numpy(data.target_audio))[1].numpy()
+    return ft.execute_all(target_audio)[1].numpy()

sonusai/mixture/truth_functions/file.py

@@ -1,6 +1,5 @@
-from sonusai.mixture.datatypes import Truth
-from sonusai.mixture.truth_functions.datatypes import TruthFunctionConfig
-from sonusai.mixture.truth_functions.datatypes import TruthFunctionData
+from sonusai.mixture import MixtureDatabase
+from sonusai.mixture import Truth
 
 
 def file_validate(config: dict) -> None:
@@ -17,28 +16,33 @@ def file_validate(config: dict) -> None:
             raise ValueError("Truth file does not contain truth_f dataset")
 
 
-def file_parameters(config: TruthFunctionConfig) -> int:
+def file_parameters(_feature: str, _num_classes: int, config: dict) -> int:
     import h5py
     import numpy as np
 
-    with h5py.File(config.config["file"], "r") as f:
+    with h5py.File(config["file"], "r") as f:
         truth = np.array(f["truth_f"])
 
     return truth.shape[-1]
 
 
-def file(data: TruthFunctionData, config: TruthFunctionConfig) -> Truth:
+def file(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict) -> Truth:
     """file truth function documentation"""
     import h5py
     import numpy as np
+    from pyaaware import feature_inverse_transform_config
+
+    target_audio = mixdb.mixture_targets(m_id)[target_index]
 
-    with h5py.File(config.config["file"], "r") as f:
+    frame_size = feature_inverse_transform_config(mixdb.feature)["overlap"]
+
+    with h5py.File(config["file"], "r") as f:
         truth = np.array(f["truth_f"])
 
     if truth.ndim != 2:
         raise ValueError("Truth file data is not 2 dimensions")
 
-    if truth.shape[0] != len(data.target_audio) // config.frame_size:
+    if truth.shape[0] != len(target_audio) // frame_size:
         raise ValueError("Truth file does not contain the right amount of frames")
 
     return truth

sonusai/mixture/truth_functions/metadata.py

@@ -0,0 +1,24 @@
+from sonusai.mixture import MixtureDatabase
+from sonusai.mixture import Truth
+
+
+def metadata_validate(config: dict) -> None:
+    if len(config) == 0:
+        raise AttributeError("metadata truth function is missing config")
+
+    parameters = ["tier"]
+    for parameter in parameters:
+        if parameter not in config:
+            raise AttributeError(f"metadata truth function is missing required '{parameter}'")
+
+
+def metadata_parameters(_feature: str, _num_classes: int, _config: dict) -> int | None:
+    return None
+
+
+def metadata(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict) -> Truth:
+    """Metadata truth generation function
+
+    Retrieves metadata from target.
+    """
+    return mixdb.mixture_speech_metadata(m_id, config["tier"])[target_index]

sonusai/mixture/truth_functions/metrics.py

@@ -0,0 +1,28 @@
+from sonusai.mixture import MixtureDatabase
+from sonusai.mixture import Truth
+
+
+def metrics_validate(config: dict) -> None:
+    if len(config) == 0:
+        raise AttributeError("metrics truth function is missing config")
+
+    parameters = ["metric"]
+    for parameter in parameters:
+        if parameter not in config:
+            raise AttributeError(f"metrics truth function is missing required '{parameter}'")
+
+
+def metrics_parameters(_feature: str, _num_classes: int, _config: dict) -> int | None:
+    return None
+
+
+def metrics(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict) -> Truth:
+    """Metadata truth generation function
+
+    Retrieves metrics from target.
+    """
+    if not isinstance(config["metric"], list):
+        m = [config["metric"]]
+    else:
+        m = config["metric"]
+    return mixdb.mixture_metrics(m_id, m)[0][target_index]

sonusai/mixture/truth_functions/phoneme.py

@@ -1,17 +1,16 @@
-from sonusai.mixture.datatypes import Truth
-from sonusai.mixture.truth_functions.datatypes import TruthFunctionConfig
-from sonusai.mixture.truth_functions.datatypes import TruthFunctionData
+from sonusai.mixture import MixtureDatabase
+from sonusai.mixture import Truth
 
 
 def phoneme_validate(_config: dict) -> None:
     raise NotImplementedError("Truth function phoneme is not supported yet")
 
 
-def phoneme_parameters(_config: TruthFunctionConfig) -> int:
+def phoneme_parameters(_feature: str, _num_classes: int, _config: dict) -> int:
     raise NotImplementedError("Truth function phoneme is not supported yet")
 
 
-def phoneme(_data: TruthFunctionData, _config: TruthFunctionConfig) -> Truth:
+def phoneme(_mixdb: MixtureDatabase, _m_id: int, _target_index: int, _config: dict) -> Truth:
     """Read in .txt transcript and run a Python function to generate text grid data
     (indicating which phonemes are active). Then generate truth based on this data and put
     in the correct classes based on the index in the config.

sonusai/mixture/truth_functions/sed.py

@@ -1,12 +1,5 @@
-from sonusai.mixture.datatypes import Truth
-from sonusai.mixture.truth_functions.datatypes import TruthFunctionConfig
-from sonusai.mixture.truth_functions.datatypes import TruthFunctionData
-
-
-def _strictly_decreasing(list_to_check: list) -> bool:
-    from itertools import pairwise
-
-    return all(x > y for x, y in pairwise(list_to_check))
+from sonusai.mixture import MixtureDatabase
+from sonusai.mixture import Truth
 
 
 def sed_validate(config: dict) -> None:
@@ -23,11 +16,11 @@ def sed_validate(config: dict) -> None:
         raise ValueError(f"sed truth function 'thresholds' are not strictly decreasing: {thresholds}")
 
 
-def sed_parameters(config: TruthFunctionConfig) -> int:
-    return config.num_classes
+def sed_parameters(_feature: str, num_classes: int, _config: dict) -> int:
+    return num_classes
 
 
-def sed(data: TruthFunctionData, config: TruthFunctionConfig) -> Truth:
+def sed(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict) -> Truth:
     """Sound energy detection truth generation function
 
     Calculates sound energy detection truth using simple 3 threshold
@@ -62,30 +55,46 @@ def sed(data: TruthFunctionData, config: TruthFunctionConfig) -> Truth:
     import numpy as np
     import torch
     from pyaaware import SED
+    from pyaaware import ForwardTransform
+    from pyaaware import feature_forward_transform_config
+    from pyaaware import feature_inverse_transform_config
+
+    target_audio = torch.from_numpy(mixdb.mixture_targets(m_id)[target_index])
+
+    frame_size = feature_inverse_transform_config(mixdb.feature)["overlap"]
 
-    if len(data.target_audio) % config.frame_size != 0:
-        raise ValueError(f"Number of samples in audio is not a multiple of {config.frame_size}")
+    ft = ForwardTransform(**feature_forward_transform_config(mixdb.feature))
 
-    frames = config.target_fft.frames(data.target_audio)
-    parameters = sed_parameters(config)
-    if config.target_gain == 0:
+    if len(target_audio) % frame_size != 0:
+        raise ValueError(f"Number of samples in audio is not a multiple of {frame_size}")
+
+    frames = ft.frames(target_audio)
+    parameters = sed_parameters(mixdb.feature, mixdb.num_classes, config)
+    target_gain = mixdb.mixture(m_id).target_gain(target_index)
+    if target_gain == 0:
         return np.zeros((frames, parameters), dtype=np.float32)
 
     # SED wants 1-based indices
     s = SED(
-        thresholds=config.config["thresholds"],
-        index=config.class_indices,
-        frame_size=config.frame_size,
-        num_classes=config.num_classes,
+        thresholds=config["thresholds"],
+        index=mixdb.target_file(mixdb.mixture(m_id).targets[target_index].file_id).class_indices,
+        frame_size=frame_size,
+        num_classes=mixdb.num_classes,
     )
 
     # Back out target gain
-    target_audio = data.target_audio / config.target_gain
+    target_audio = target_audio / target_gain
 
     # Compute energy
-    target_energy = config.target_fft.execute_all(torch.from_numpy(target_audio))[1].numpy()
+    target_energy = ft.execute_all(target_audio)[1].numpy()
 
     if frames != target_energy.shape[0]:
         raise ValueError("Incorrect frames calculation in sed truth function")
 
     return s.execute_all(target_energy)
+
+
+def _strictly_decreasing(list_to_check: list) -> bool:
+    from itertools import pairwise
+
+    return all(x > y for x, y in pairwise(list_to_check))

sonusai/mixture/truth_functions/target.py

@@ -1,21 +1,24 @@
-from sonusai.mixture.datatypes import AudioF
-from sonusai.mixture.datatypes import Truth
-from sonusai.mixture.truth_functions.datatypes import TruthFunctionConfig
-from sonusai.mixture.truth_functions.datatypes import TruthFunctionData
+from sonusai.mixture import MixtureDatabase
+from sonusai.mixture import Truth
 
 
 def target_f_validate(_config: dict) -> None:
     pass
 
 
-def target_f_parameters(config: TruthFunctionConfig) -> int:
-    if config.ttype == "tdac-co":
-        return config.target_fft.bins
+def target_f_parameters(feature: str, _num_classes: int, _config: dict) -> int:
+    from pyaaware import ForwardTransform
+    from pyaaware import feature_forward_transform_config
 
-    return config.target_fft.bins * 2
+    ft = ForwardTransform(**feature_forward_transform_config(feature))
 
+    if ft.ttype == "tdac-co":
+        return ft.bins
 
-def target_f(data: TruthFunctionData, config: TruthFunctionConfig) -> Truth:
+    return ft.bins * 2
+
+
+def target_f(mixdb: MixtureDatabase, m_id: int, target_index: int, _config: dict) -> Truth:
     """Frequency domain target truth function
 
     Calculates the true transform of the target using the STFT
@@ -26,23 +29,34 @@ def target_f(data: TruthFunctionData, config: TruthFunctionConfig) -> Truth:
                   [:, bins] (target real only for tdac-co)
     """
     import torch
+    from pyaaware import ForwardTransform
+    from pyaaware import feature_forward_transform_config
+
+    ft = ForwardTransform(**feature_forward_transform_config(mixdb.feature))
 
-    target_freq = config.target_fft.execute_all(torch.from_numpy(data.target_audio))[0].numpy()
-    return _stack_real_imag(target_freq, config.ttype)
+    target_audio = torch.from_numpy(mixdb.mixture_targets(m_id)[target_index])
+
+    target_freq = ft.execute_all(target_audio)[0].numpy()
+    return _stack_real_imag(target_freq, ft.ttype)
 
 
 def target_mixture_f_validate(_config: dict) -> None:
     pass
 
 
-def target_mixture_f_parameters(config: TruthFunctionConfig) -> int:
-    if config.ttype == "tdac-co":
-        return config.target_fft.bins * 2
+def target_mixture_f_parameters(feature: str, _num_classes: int, _config: dict) -> int:
+    from pyaaware import ForwardTransform
+    from pyaaware import feature_forward_transform_config
+
+    ft = ForwardTransform(**feature_forward_transform_config(feature))
+
+    if ft.ttype == "tdac-co":
+        return ft.bins * 2
 
-    return config.target_fft.bins * 4
+    return ft.bins * 4
 
 
-def target_mixture_f(data: TruthFunctionData, config: TruthFunctionConfig) -> Truth:
+def target_mixture_f(mixdb: MixtureDatabase, m_id: int, target_index: int, _config: dict) -> Truth:
     """Frequency domain target and mixture truth function
 
     Calculates the true transform of the target and the mixture
@@ -55,14 +69,21 @@ def target_mixture_f(data: TruthFunctionData, config: TruthFunctionConfig) -> Tr
     """
     import numpy as np
     import torch
+    from pyaaware import ForwardTransform
+    from pyaaware import feature_forward_transform_config
 
-    target_freq = config.target_fft.execute_all(torch.from_numpy(data.target_audio))[0].numpy()
-    mixture_freq = config.mixture_fft.execute_all(torch.from_numpy(data.mixture_audio))[0].numpy()
+    ft = ForwardTransform(**feature_forward_transform_config(mixdb.feature))
+
+    target_audio = torch.from_numpy(mixdb.mixture_targets(m_id)[target_index])
+    mixture_audio = torch.from_numpy(mixdb.mixture_mixture(m_id))
+
+    target_freq = ft.execute_all(torch.from_numpy(target_audio))[0].numpy()
+    mixture_freq = ft.execute_all(torch.from_numpy(mixture_audio))[0].numpy()
 
     frames, bins = target_freq.shape
     truth = np.empty((frames, bins * 4), dtype=np.float32)
-    truth[:, : bins * 2] = _stack_real_imag(target_freq, config.ttype)
-    truth[:, bins * 2 :] = _stack_real_imag(mixture_freq, config.ttype)
+    truth[:, : bins * 2] = _stack_real_imag(target_freq, ft.ttype)
+    truth[:, bins * 2 :] = _stack_real_imag(mixture_freq, ft.ttype)
     return truth
 
 
@@ -70,11 +91,14 @@ def target_swin_f_validate(_config: dict) -> None:
     pass
 
 
-def target_swin_f_parameters(config: TruthFunctionConfig) -> int:
-    return config.target_fft.bins * 2
+def target_swin_f_parameters(feature: str, _num_classes: int, _config: dict) -> int:
+    from pyaaware import ForwardTransform
+    from pyaaware import feature_forward_transform_config
+
+    return ForwardTransform(**feature_forward_transform_config(feature)).bins * 2
 
 
-def target_swin_f(data: TruthFunctionData, config: TruthFunctionConfig) -> Truth:
+def target_swin_f(mixdb: MixtureDatabase, m_id: int, target_index: int, _config: dict) -> Truth:
     """Frequency domain target with synthesis window truth function
 
     Calculates the true transform of the target using the STFT
@@ -85,20 +109,29 @@ def target_swin_f(data: TruthFunctionData, config: TruthFunctionConfig) -> Truth
     Output shape: [:, 2 * bins] (stacked real, imag)
     """
     import numpy as np
+    import torch
+    from pyaaware import ForwardTransform
+    from pyaaware import InverseTransform
+    from pyaaware import feature_forward_transform_config
+    from pyaaware import feature_inverse_transform_config
 
     from sonusai.utils import stack_complex
 
-    truth = np.empty((len(data.target_audio) // config.frame_size, config.target_fft.bins * 2), dtype=np.float32)
-    for idx, offset in enumerate(range(0, len(data.target_audio), config.frame_size)):
-        target_freq = config.target_fft.execute(
-            np.multiply(data.target_audio[offset : offset + config.frame_size], config.swin)
-        )[0]
+    ft = ForwardTransform(**feature_forward_transform_config(mixdb.feature))
+    it = InverseTransform(**feature_inverse_transform_config(mixdb.feature))
+
+    target_audio = mixdb.mixture_targets(m_id)[target_index]
+
+    truth = np.empty((len(target_audio) // ft.overlap, ft.bins * 2), dtype=np.float32)
+    for idx, offset in enumerate(range(0, len(target_audio), ft.overlap)):
+        audio_frame = torch.from_numpy(np.multiply(target_audio[offset : offset + ft.overlap], it.window))
+        target_freq = ft.execute(audio_frame)[0].numpy()
         truth[idx] = stack_complex(target_freq)
 
     return truth
 
 
-def _stack_real_imag(data: AudioF, ttype: str) -> Truth:
+def _stack_real_imag(data: Truth, ttype: str) -> Truth:
     import numpy as np
 
     from sonusai.utils import stack_complex