sonusai 1.0.16__cp311-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

sonusai/mixture/truth_functions/sed.py

@@ -0,0 +1,98 @@
+from numpy.lib.utils import source
+
+from ...datatypes import Truth
+from ..mixdb import MixtureDatabase
+
+
+def sed_validate(config: dict) -> None:
+    if len(config) == 0:
+        raise AttributeError("sed truth function is missing config")
+
+    parameters = ["thresholds"]
+    for parameter in parameters:
+        if parameter not in config:
+            raise AttributeError(f"sed truth function is missing required '{parameter}'")
+
+    thresholds = config["thresholds"]
+    if not _strictly_decreasing(thresholds):
+        raise ValueError(f"sed truth function 'thresholds' are not strictly decreasing: {thresholds}")
+
+
+def sed_parameters(_feature: str, num_classes: int, _config: dict) -> int:
+    return num_classes
+
+
+def sed(mixdb: MixtureDatabase, m_id: int, category: str, config: dict) -> Truth:
+    """Sound energy detection truth generation function
+
+    Calculates sound energy detection truth using simple 3 threshold
+    hysteresis algorithm. SED outputs 3 possible probabilities of
+    sound presence: 1.0 present, 0.5 (transition/uncertain), 0 not
+    present. The output values will be assigned to the truth output
+    at the index specified in the config.
+
+    Output shape: [:, num_classes]
+
+    index       Truth index <int> or list(<int>)
+
+    index indicates which truth fields should be set.
+    0 indicates none, 1 is first element in truth output vector, 2 2nd element, etc.
+
+                Examples:
+                  index = 5       truth in class 5, truth(4, 1)
+                  index = [1, 5]  truth in classes 1 and 5, truth([0, 4], 1)
+
+                In mutually-exclusive mode, a frame is expected to only
+                belong to one class and thus all probabilities must sum to
+                1. This is effectively truth for a classifier with multichannel
+                softmax output.
+
+                For multi-label classification each class is an individual
+                probability for that class and any given frame can be
+                assigned to multiple classes/labels, i.e., the classes are
+                not mutually-exclusive. For example, a NN classifier with
+                multichannel sigmoid output. In this case, index could
+                also be a vector with multiple class indices.
+    """
+    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
+
+    source_audio = torch.from_numpy(mixdb.mixture_sources(m_id)[category])
+
+    frame_size = feature_inverse_transform_config(mixdb.feature)["overlap"]
+
+    ft = ForwardTransform(**feature_forward_transform_config(mixdb.feature))
+
+    if len(source_audio) % frame_size != 0:
+        raise ValueError(f"Number of samples in audio is not a multiple of {frame_size}")
+
+    frames = ft.frames(source_audio)
+    parameters = sed_parameters(mixdb.feature, mixdb.num_classes, config)
+    if mixdb.mixture(m_id).all_sources[category].snr_gain == 0:
+        return np.zeros((frames, parameters), dtype=np.float32)
+
+    # SED wants 1-based indices
+    s = SED(
+        thresholds=config["thresholds"],
+        index=mixdb.source_file(mixdb.mixture(m_id).all_sources[category].file_id).class_indices,
+        frame_size=frame_size,
+        num_classes=mixdb.num_classes,
+    )
+
+    # Compute energy
+    target_energy = ft.execute_all(source_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

@@ -0,0 +1,142 @@
+from ...datatypes import Truth
+from ..mixdb import MixtureDatabase
+
+
+def target_f_validate(_config: dict) -> None:
+    pass
+
+
+def target_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
+
+    return ft.bins * 2
+
+
+def target_f(mixdb: MixtureDatabase, m_id: int, category: str, _config: dict) -> Truth:
+    """Frequency domain target truth function
+
+    Calculates the true transform of the target using the STFT
+    configuration defined by the feature. This will include a
+    forward transform window if defined by the feature.
+
+    Output shape: [:, 2 * bins] (target stacked real, imag) or
+                  [:, 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_audio = torch.from_numpy(mixdb.mixture_sources(m_id)[category])
+
+    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(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 ft.bins * 4
+
+
+def target_mixture_f(mixdb: MixtureDatabase, m_id: int, category: str, _config: dict) -> Truth:
+    """Frequency domain target and mixture truth function
+
+    Calculates the true transform of the target and the mixture
+    using the STFT configuration defined by the feature. This
+    will include a forward transform window if defined by the
+    feature.
+
+    Output shape: [:, 4 * bins] (target stacked real, imag; mixture stacked real, imag) or
+                  [:, 2 * bins] (target real; mixture real for tdac-co)
+    """
+    import numpy as np
+    import torch
+    from pyaaware import ForwardTransform
+    from pyaaware import feature_forward_transform_config
+
+    ft = ForwardTransform(**feature_forward_transform_config(mixdb.feature))
+
+    target_audio = torch.from_numpy(mixdb.mixture_sources(m_id)[category])
+    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, ft.ttype)
+    truth[:, bins * 2 :] = _stack_real_imag(mixture_freq, ft.ttype)
+    return truth
+
+
+def target_swin_f_validate(_config: dict) -> None:
+    pass
+
+
+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(mixdb: MixtureDatabase, m_id: int, category: str, _config: dict) -> Truth:
+    """Frequency domain target with synthesis window truth function
+
+    Calculates the true transform of the target using the STFT
+    configuration defined by the feature. This will include a
+    forward transform window if defined by the feature and also
+    the inverse transform (or synthesis) window.
+
+    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 ...utils.stacked_complex import stack_complex
+
+    ft = ForwardTransform(**feature_forward_transform_config(mixdb.feature))
+    it = InverseTransform(**feature_inverse_transform_config(mixdb.feature))
+
+    target_audio = mixdb.mixture_sources(m_id)[category]
+
+    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: Truth, ttype: str) -> Truth:
+    import numpy as np
+
+    from ...utils.stacked_complex import stack_complex
+
+    if ttype == "tdac-co":
+        return np.real(data)
+
+    return stack_complex(data)

sonusai/mkwav.py

@@ -0,0 +1,135 @@
+"""sonusai mkwav
+
+usage: mkwav [-hvtsn] [-i MIXID] LOC
+
+options:
+    -h, --help
+    -v, --verbose                   Be verbose.
+    -i MIXID, --mixid MIXID         Mixture ID(s) to generate. [default: *].
+    -t, --source                    Write source file.
+    -s, --sources                   Write sources files.
+    -n, --noise                     Write noise file.
+
+The mkwav command creates WAV files from a SonusAI database.
+
+Inputs:
+    LOC         A SonusAI mixture database directory.
+    MIXID       A glob of mixture ID(s) to generate.
+
+Outputs the following to the mixture database directory:
+    <id>
+        mixture.wav:        mixture
+        source.wav:         source (optional)
+        source_<c>.wav:     source <category> (optional)
+        noise.wav:          noise (optional)
+        metadata.txt
+    mkwav.log
+
+"""
+
+
+def _process_mixture(m_id: int, location: str, write_target: bool, write_targets: bool, write_noise: bool) -> None:
+    from os import makedirs
+    from os.path import join
+
+    from sonusai.mixture import MixtureDatabase
+    from sonusai.mixture.helpers import write_mixture_metadata
+    from sonusai.utils.numeric_conversion import float_to_int16
+    from sonusai.utils.write_audio import write_audio
+
+    mixdb = MixtureDatabase(location)
+
+    index = mixdb.mixture(m_id).name
+    location = join(mixdb.location, "mixture", index)
+    makedirs(location, exist_ok=True)
+
+    write_audio(name=join(location, "mixture.wav"), audio=float_to_int16(mixdb.mixture_mixture(m_id)))
+    if write_target:
+        write_audio(name=join(location, "source.wav"), audio=float_to_int16(mixdb.mixture_source(m_id)))
+    if write_targets:
+        for category, source in mixdb.mixture_sources(m_id).items():
+            write_audio(name=join(location, f"sources_{category}.wav"), audio=float_to_int16(source))
+    if write_noise:
+        write_audio(name=join(location, "noise.wav"), audio=float_to_int16(mixdb.mixture_noise(m_id)))
+
+    write_mixture_metadata(mixdb, m_id=m_id)
+
+
+def main() -> None:
+    from docopt import docopt
+
+    from sonusai import __version__ as sai_version
+    from sonusai.utils.docstring import trim_docstring
+
+    args = docopt(trim_docstring(__doc__), version=sai_version, options_first=True)
+
+    verbose = args["--verbose"]
+    mixid = args["--mixid"]
+    write_source = args["--source"]
+    write_sources = args["--sources"]
+    write_noise = args["--noise"]
+    location = args["LOC"]
+
+    import time
+    from functools import partial
+    from os.path import join
+
+    from sonusai import create_file_handler
+    from sonusai import initial_log_messages
+    from sonusai import logger
+    from sonusai import update_console_handler
+    from sonusai.mixture import MixtureDatabase
+    from sonusai.mixture.helpers import check_audio_files_exist
+    from sonusai.utils.parallel import par_track
+    from sonusai.utils.parallel import track
+    from sonusai.utils.seconds_to_hms import seconds_to_hms
+
+    start_time = time.monotonic()
+
+    create_file_handler(join(location, "mkwav.log"), verbose)
+    update_console_handler(verbose)
+    initial_log_messages("mkwav")
+
+    logger.info(f"Load mixture database from {location}")
+    mixdb = MixtureDatabase(location)
+    mixid = mixdb.mixids_to_list(mixid)
+
+    total_samples = mixdb.total_samples(mixid)
+
+    logger.info("")
+    logger.info(f"Found {len(mixid):,} mixtures to process")
+    logger.info(f"{total_samples:,} samples")
+
+    check_audio_files_exist(mixdb)
+
+    progress = track(total=len(mixid))
+    par_track(
+        partial(
+            _process_mixture,
+            location=location,
+            write_target=write_source,
+            write_targets=write_sources,
+            write_noise=write_noise,
+        ),
+        mixid,
+        progress=progress,
+        # no_par=True,
+    )
+    progress.close()
+
+    logger.info(f"Wrote {len(mixid)} mixtures to {location}")
+    logger.info("")
+    end_time = time.monotonic()
+    logger.info(f"Completed in {seconds_to_hms(seconds=end_time - start_time)}")
+    logger.info("")
+
+
+if __name__ == "__main__":
+    from sonusai import exception_handler
+    from sonusai.utils.keyboard_interrupt import register_keyboard_interrupt
+
+    register_keyboard_interrupt()
+    try:
+        main()
+    except Exception as e:
+        exception_handler(e)