sonusai 1.0.16__cp311-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

sonusai/utils/reshape.py

@@ -0,0 +1,154 @@
+import numpy as np
+
+from ..datatypes import Feature
+from ..datatypes import Predict
+from ..datatypes import Truth
+
+
+def get_input_shape(feature: Feature) -> tuple[int, ...]:
+    return feature.shape[1:]
+
+
+def reshape_inputs(
+    feature: Feature,
+    batch_size: int,
+    truth: Truth | None = None,
+    timesteps: int = 0,
+    flatten: bool = False,
+    add1ch: bool = False,
+) -> tuple[Feature, Truth | None]:
+    """Check SonusAI feature and truth data and reshape feature of size [frames, strides, feature_parameters] into
+    one of several options:
+
+    If timesteps > 0: (i.e., for recurrent NNs):
+      no-flatten, no-channel:   [sequences, timesteps, strides, feature_parameters]      (4-dim)
+      flatten, no-channel:      [sequences, timesteps, strides*feature_parameters]       (3-dim)
+      no-flatten, add-1channel: [sequences, timesteps, strides, feature_parameters, 1]   (5-dim)
+      flatten, add-1channel:    [sequences, timesteps, strides*feature_parameters, 1]    (4-dim)
+
+    If batch_size is None, then do not reshape; just calculate new input shape and return.
+
+    If timesteps == 0, then do not add timesteps dimension.
+
+    The number of samples is trimmed to be a multiple of batch_size (Keras requirement) for
+    both feature and truth.
+    Channel is added to last/outer dimension for channel_last support in Keras/TF.
+
+    Returns:
+      feature       reshaped feature
+      truth         reshaped truth
+    """
+    frames, strides, feature_parameters = feature.shape
+    if truth is not None:
+        truth_frames, num_classes = truth.shape
+        # Double-check correctness of inputs
+        if frames != truth_frames:
+            raise ValueError("Frames in feature and truth do not match")
+    else:
+        num_classes = 0
+
+    if flatten:
+        feature = np.reshape(feature, (frames, strides * feature_parameters))
+
+    # Reshape for Keras/TF recurrent models that require timesteps/sequence length dimension
+    if timesteps > 0:
+        sequences = frames // timesteps
+
+        # Remove frames if remainder exists (not fitting into a multiple of new number of sequences)
+        frames_rem = frames % timesteps
+        batch_rem = (frames // timesteps) % batch_size
+        bf_rem = batch_rem * timesteps
+        sequences = sequences - batch_rem
+        fr2drop = frames_rem + bf_rem
+        if fr2drop:
+            if feature.ndim == 2:
+                feature = feature[0:-fr2drop,]  # flattened input
+            elif feature.ndim == 3:
+                feature = feature[0:-fr2drop,]  # un-flattened input
+
+            if truth is not None:
+                truth = truth[0:-fr2drop,]
+
+        # Reshape
+        if feature.ndim == 2:  # flattened input
+            # was [frames, feature_parameters*timesteps]
+            feature = np.reshape(feature, (sequences, timesteps, strides * feature_parameters))
+            if truth is not None:
+                # was [frames, num_classes]
+                truth = np.reshape(truth, (sequences, timesteps, num_classes))
+        elif feature.ndim == 3:  # un-flattened input
+            # was [frames, feature_parameters, timesteps]
+            feature = np.reshape(feature, (sequences, timesteps, strides, feature_parameters))
+            if truth is not None:
+                # was [frames, num_classes]
+                truth = np.reshape(truth, (sequences, timesteps, num_classes))
+    else:
+        # Drop frames if remainder exists (not fitting into a multiple of new number of sequences)
+        fr2drop = feature.shape[0] % batch_size
+        if fr2drop > 0:
+            feature = feature[0:-fr2drop,]
+            if truth is not None:
+                truth = truth[0:-fr2drop,]
+
+    # Add channel dimension if required for input to model (i.e. for cnn type input)
+    if add1ch:
+        feature = np.expand_dims(feature, axis=feature.ndim)  # add as last/outermost dim
+
+    return feature, truth
+
+
+def get_num_classes_from_predict(predict: Predict, timesteps: int = 0) -> int:
+    num_dims = predict.ndim
+    dims = predict.shape
+
+    if num_dims == 3 or (num_dims == 2 and timesteps > 0):
+        # 2D with timesteps - [frames, timesteps]
+        if num_dims == 2:
+            return 1
+
+        # 3D - [frames, timesteps, num_classes]
+        return dims[2]
+
+    # 1D - [frames]
+    if num_dims == 1:
+        return 1
+
+    # 2D without timesteps - [frames, num_classes]
+    return dims[1]
+
+
+def reshape_outputs(predict: Predict, truth: Truth | None = None, timesteps: int = 0) -> tuple[Predict, Truth | None]:
+    """Reshape model output data.
+
+    truth and predict can be either [frames, num_classes], or [frames, timesteps, num_classes]
+    In binary case, num_classes dim may not exist; detect this and set num_classes to 1.
+    """
+    if truth is not None and predict.shape != truth.shape:
+        raise ValueError("predict and truth shapes do not match")
+
+    ndim = predict.ndim
+    shape = predict.shape
+
+    if not (0 < ndim <= 3):
+        raise ValueError(f"do not know how to reshape data with {ndim} dimensions")
+
+    if ndim == 3 or (ndim == 2 and timesteps > 0):
+        if ndim == 2:
+            # 2D with timesteps - [frames, timesteps]
+            num_classes = 1
+        else:
+            # 3D - [frames, timesteps, num_classes]
+            num_classes = shape[2]
+
+        # reshape to remove timestep dimension
+        shape = (shape[0] * shape[1], num_classes)
+        predict = np.reshape(predict, shape)
+        if truth is not None:
+            truth = np.reshape(truth, shape)
+    elif ndim == 1:
+        # convert to 2D - [frames, 1]
+        predict = np.expand_dims(predict, 1)
+        if truth is not None:
+            truth = np.expand_dims(truth, 1)
+
+    return predict, truth

sonusai/utils/seconds_to_hms.py

@@ -0,0 +1,7 @@
+def seconds_to_hms(seconds: float) -> str:
+    """Convert given seconds into string of H:MM:SS"""
+    h = int(seconds / 3600)
+    s = seconds - h * 3600
+    m = int(s / 60)
+    s = int(seconds - h * 3600 - m * 60)
+    return f"{h:d}:{m:02d}:{s:02d} (H:MM:SS)"

sonusai/utils/stacked_complex.py

@@ -0,0 +1,82 @@
+import numpy as np
+
+
+def stack_complex(unstacked: np.ndarray) -> np.ndarray:
+    """Stack a complex array
+
+    A stacked array doubles the last dimension and organizes the data as:
+        - first half is all the real data
+        - second half is all the imaginary data
+
+    :param unstacked: An nD array (n > 1) containing complex data
+    :return: A stacked array
+    :raises TypeError:
+    """
+    if not unstacked.ndim > 1:
+        raise ValueError("unstacked must have more than 1 dimension")
+
+    shape = list(unstacked.shape)
+    shape[-1] = shape[-1] * 2
+    stacked = np.empty(shape, dtype=np.float32)
+    half = unstacked.shape[-1]
+    stacked[..., :half] = np.real(unstacked)
+    stacked[..., half:] = np.imag(unstacked)
+
+    return stacked
+
+
+def unstack_complex(stacked: np.ndarray) -> np.ndarray:
+    """Unstack a stacked complex array
+
+    :param stacked: An nD array (n > 1) where the last dimension contains stacked complex data in which the first half
+        is all the real data and the second half is all the imaginary data
+    :return: An unstacked complex array
+    :raises TypeError:
+    """
+    if not stacked.ndim > 1:
+        raise ValueError("stacked must have more than 1 dimension")
+
+    if stacked.shape[-1] % 2 != 0:
+        raise ValueError("last dimension of stacked must be a multiple of 2")
+
+    half = stacked.shape[-1] // 2
+    unstacked = 1j * stacked[..., half:]
+    unstacked += stacked[..., :half]
+
+    return unstacked
+
+
+def stacked_complex_real(stacked: np.ndarray) -> np.ndarray:
+    """Get the real elements from a stacked complex array
+
+    :param stacked: An nD array (n > 1) where the last dimension contains stacked complex data in which the first half
+        is all the real data and the second half is all the imaginary data
+    :return: The real elements
+    :raises TypeError:
+    """
+    if not stacked.ndim > 1:
+        raise ValueError("stacked must have more than 1 dimension")
+
+    if stacked.shape[-1] % 2 != 0:
+        raise ValueError("last dimension of stacked must be a multiple of 2")
+
+    half = stacked.shape[-1] // 2
+    return stacked[..., :half]
+
+
+def stacked_complex_imag(stacked: np.ndarray) -> np.ndarray:
+    """Get the imaginary elements from a stacked complex array
+
+    :param stacked: An nD array (n > 1) where the last dimension contains stacked complex data in which the first half
+        is all the real data and the second half is all the imaginary data
+    :return: The imaginary elements
+    :raises TypeError:
+    """
+    if not stacked.ndim > 1:
+        raise ValueError("stacked must have more than 1 dimension")
+
+    if stacked.shape[-1] % 2 != 0:
+        raise ValueError("last dimension of stacked must be a multiple of 2")
+
+    half = stacked.shape[-1] // 2
+    return stacked[..., half:]

sonusai/utils/stratified_shuffle_split.py

@@ -0,0 +1,170 @@
+import numpy as np
+
+from ..mixture.mixdb import MixtureDatabase
+
+
+def stratified_shuffle_split_mixid(
+    mixdb: MixtureDatabase,
+    vsplit: float = 0.2,
+    nsplit: int = 0,
+    rnd_seed: int | None = 0,
+) -> tuple[list[int], list[int], np.ndarray, np.ndarray]:
+    """
+    Create a training and test/validation list of mixture IDs from all mixtures in a mixture database.
+    The test/validation split is specified by vsplit (0.0 to 1.0), default 0.2.
+    The mixtures are randomly shuffled by rnd_seed; set to int for repeatability, or None for no shuffle.
+    The mixtures are then stratified across all populated classes.
+
+    Inputs:
+        mixdb:      Mixture database created by Aaware SonusAI genmixdb.
+        vsplit:     Fractional split of mixtures for validation, 1-vsplit for training.
+        nsplit:     Number of splits (TBD).
+        rnd_seed:   Seed integer for reproducible random shuffling (or None for no shuffling).
+
+    Outputs:
+        t_mixid:        list of mixture IDs for training
+        v_mixid:        list of mixture IDs for validation
+        t_num_mixid:    list of class counts in t_mixid
+        v_num_mixid:    list of class counts in v_mixid
+
+    Examples:
+        t_mixid, v_mixid, t_num_mixid, v_num_mixid = stratified_shuffle_split_mixid(mixdb, vsplit=vsplit)
+
+    @author: Chris Eddington
+    """
+    import random
+    from copy import deepcopy
+
+    from .. import logger
+    from ..mixture.class_count import get_class_count_from_mixids
+
+    if vsplit < 0 or vsplit > 1:
+        raise ValueError("vsplit must be between 0 and 1")
+
+    a_class_mixid: dict[int, list[int]] = {i + 1: [] for i in range(mixdb.num_classes)}
+    for mixid, mixture in enumerate(mixdb.mixtures()):
+        class_count = get_class_count_from_mixids(mixdb, mixid)
+        if any(class_count):
+            for class_index in mixdb.target_files[mixture.targets[0].file_id].class_indices:
+                a_class_mixid[class_index].append(mixid)
+        else:
+            # no counts and mutex mode means this is all 'other' class
+            a_class_mixid[mixdb.num_classes].append(mixid)
+
+    t_class_mixid: list[list[int]] = [[] for _ in range(mixdb.num_classes)]
+    v_class_mixid: list[list[int]] = [[] for _ in range(mixdb.num_classes)]
+
+    a_num_mixid = np.zeros(mixdb.num_classes, dtype=np.int32)
+    t_num_mixid = np.zeros(mixdb.num_classes, dtype=np.int32)
+    v_num_mixid = np.zeros(mixdb.num_classes, dtype=np.int32)
+
+    if rnd_seed is not None:
+        random.seed(rnd_seed)
+
+    # For each class pick percentage of shuffled mixids for training, validation
+    for ci in range(mixdb.num_classes):
+        # total number of mixids for class
+        a_num_mixid[ci] = len(a_class_mixid[ci + 1])
+
+        # number of training mixids for class
+        t_num_mixid[ci] = int(np.floor(a_num_mixid[ci] * (1 - vsplit)))
+
+        # number of validation mixids for class
+        v_num_mixid[ci] = a_num_mixid[ci] - t_num_mixid[ci]
+
+        # indices for all mixids in class
+        indices = [*range(a_num_mixid[ci])]
+        if rnd_seed is not None:
+            # randomize order
+            random.shuffle(indices)
+
+        t_class_mixid[ci] = [a_class_mixid[ci + 1][ii] for ii in indices[0 : t_num_mixid[ci]]]
+        v_class_mixid[ci] = [a_class_mixid[ci + 1][ii] for ii in indices[t_num_mixid[ci] :]]
+
+    if np.any(~(t_num_mixid > 0)):
+        logger.warning(f"Some classes have zero coverage: {np.where(~(t_num_mixid > 0))[0]}")
+
+    # Stratify over non-zero classes
+    nz_indices = np.where(t_num_mixid > 0)[0]
+    # First stratify pass is min count / 3 times through all classes, one each least populated class count (of non-zero)
+    min_class = min(t_num_mixid[nz_indices])
+    # number of mixids in each class for stratify by 1
+    n0 = int(np.ceil(min_class / 3))
+    # 3rd stage for stratify by 1
+    n3 = int(n0)
+    # 2nd stage stratify by class_count/min(class_count-n3) n2 times
+    n2 = int(max(min_class - n0 - n3, 0))
+
+    logger.info(
+        f"Stratifying training, x1 cnt {n0}: x(class_count/{n2}): x1 cnt {n3} x1, "
+        f"for {len(nz_indices)} populated classes"
+    )
+
+    # initialize source list
+    tt = deepcopy(t_class_mixid)
+    t_num_mixid2 = deepcopy(t_num_mixid)
+    t_mixid = []
+    for _ in range(n0):
+        for ci in range(mixdb.num_classes):
+            if t_num_mixid2[ci] > 0:
+                # append first
+                t_mixid.append(tt[ci][0])
+                del tt[ci][0]
+                t_num_mixid2[ci] = len(tt[ci])
+
+    # Now extract weighted by how many are left in class minus n3
+    # which will leave approx n3 remaining
+    if n2 > 0:
+        # should always be non-zero
+        min_class = int(np.min(t_num_mixid2 - n3))
+        class_count = np.floor((t_num_mixid2 - n3) / min_class)
+        # class_count = np.maximum(np.floor((t_num_mixid2 - n3) / n2),0) # Counts per class
+        for _ in range(min_class):
+            for ci in range(mixdb.num_classes):
+                if class_count[ci] > 0:
+                    for _ in range(int(class_count[ci])):
+                        # append first
+                        t_mixid.append(tt[ci][0])
+                        del tt[ci][0]
+                        t_num_mixid2[ci] = len(tt[ci])
+
+    # Now extract remaining mixids, one each class until empty
+    # There should be ~n3 remaining mixids in each
+    t_mixid = _extract_remaining_mixids(mixdb, t_mixid, t_num_mixid2, tt)
+
+    if len(t_mixid) != sum(t_num_mixid):
+        logger.warning("Final stratified training list length does not match starting list length.")
+
+    if any(t_num_mixid2) or any(tt):
+        logger.warning("Remaining training mixid list not empty.")
+
+    # Now stratify the validation list, which is probably not as important, so use simple method
+    # initialize source list
+    vv = deepcopy(v_class_mixid)
+    v_num_mixid2 = deepcopy(v_num_mixid)
+    v_mixid = _extract_remaining_mixids(mixdb, [], v_num_mixid2, vv)
+
+    if len(v_mixid) != sum(v_num_mixid):
+        logger.warning("Final stratified validation list length does not match starting lists length.")
+
+    if any(v_num_mixid2) or any(vv):
+        logger.warning("Remaining validation mixid list not empty.")
+
+    return t_mixid, v_mixid, t_num_mixid, v_num_mixid
+
+
+def _extract_remaining_mixids(
+    mixdb: MixtureDatabase,
+    mixid: list[int],
+    num_mixid: np.ndarray,
+    class_mixid: list[list[int]],
+) -> list[int]:
+    for _ in range(max(num_mixid)):
+        for ci in range(mixdb.num_classes):
+            if num_mixid[ci] > 0:
+                # append first
+                mixid.append(class_mixid[ci][0])
+                del class_mixid[ci][0]
+                num_mixid[ci] = len(class_mixid[ci])
+
+    return mixid

sonusai/utils/tokenized_shell_vars.py

@@ -0,0 +1,143 @@
+from pathlib import Path
+
+
+def tokenized_expand(name: str | bytes | Path) -> tuple[str, dict[str, str]]:
+    """Expand shell variables of the forms $var, ${var} and %var%.
+    Unknown variables are left unchanged.
+
+    Expand paths containing shell variable substitutions. The following rules apply:
+        - no expansion within single quotes
+        - '$$' is translated into '$'
+        - '%%' is translated into '%' if '%%' are not seen in %var1%%var2%
+        - ${var} is accepted.
+        - $varname is accepted.
+        - %var% is accepted.
+        - vars can be made out of letters, digits and the characters '_-'
+        (though is not verified in the ${var} and %var% cases)
+
+    :param name: String to expand
+    :return: Tuple of (expanded string, dictionary of tokens)
+    """
+    import os
+    import string
+
+    from ..constants import DEFAULT_NOISE
+
+    os.environ["default_noise"] = str(DEFAULT_NOISE)  # noqa: SIM112
+
+    if isinstance(name, bytes):
+        name = name.decode("utf-8")
+
+    if isinstance(name, Path):
+        name = name.as_posix()
+
+    name = os.fspath(name)
+    token_map: dict = {}
+
+    if "$" not in name and "%" not in name:
+        return name, token_map
+
+    var_chars = string.ascii_letters + string.digits + "_-"
+    quote = "'"
+    percent = "%"
+    brace = "{"
+    rbrace = "}"
+    dollar = "$"
+    environ = os.environ
+
+    result = name[:0]
+    index = 0
+    path_len = len(name)
+    while index < path_len:
+        c = name[index : index + 1]
+        if c == quote:  # no expansion within single quotes
+            name = name[index + 1 :]
+            path_len = len(name)
+            try:
+                index = name.index(c)
+                result += c + name[: index + 1]
+            except ValueError:
+                result += c + name
+                index = path_len - 1
+        elif c == percent:  # variable or '%'
+            if name[index + 1 : index + 2] == percent:
+                result += c
+                index += 1
+            else:
+                name = name[index + 1 :]
+                path_len = len(name)
+                try:
+                    index = name.index(percent)
+                except ValueError:
+                    result += percent + name
+                    index = path_len - 1
+                else:
+                    var = name[:index]
+                    try:
+                        if environ is None:
+                            value = os.fsencode(os.environ[os.fsdecode(var)]).decode("utf-8")  # type: ignore[unreachable]
+                        else:
+                            value = environ[var]
+                        token_map[var] = value
+                    except KeyError:
+                        value = percent + var + percent
+                    result += value
+        elif c == dollar:  # variable or '$$'
+            if name[index + 1 : index + 2] == dollar:
+                result += c
+                index += 1
+            elif name[index + 1 : index + 2] == brace:
+                name = name[index + 2 :]
+                path_len = len(name)
+                try:
+                    index = name.index(rbrace)
+                except ValueError:
+                    result += dollar + brace + name
+                    index = path_len - 1
+                else:
+                    var = name[:index]
+                    try:
+                        if environ is None:
+                            value = os.fsencode(os.environ[os.fsdecode(var)]).decode("utf-8")  # type: ignore[unreachable]
+                        else:
+                            value = environ[var]
+                        token_map[var] = value
+                    except KeyError:
+                        value = dollar + brace + var + rbrace
+                    result += value
+            else:
+                var = name[:0]
+                index += 1
+                c = name[index : index + 1]
+                while c and c in var_chars:
+                    var += c
+                    index += 1
+                    c = name[index : index + 1]
+                try:
+                    if environ is None:
+                        value = os.fsencode(os.environ[os.fsdecode(var)]).decode("utf-8")  # type: ignore[unreachable]
+                    else:
+                        value = environ[var]
+                    token_map[var] = value
+                except KeyError:
+                    value = dollar + var
+                result += value
+                if c:
+                    index -= 1
+        else:
+            result += c
+        index += 1
+
+    return result, token_map
+
+
+def tokenized_replace(name: str, tokens: dict[str, str]) -> str:
+    """Replace text with shell variables.
+
+    :param name: String to replace
+    :param tokens: Dictionary of replacement tokens
+    :return: replaced string
+    """
+    for key, value in tokens.items():
+        name = name.replace(value, f"${key}")
+    return name

sonusai/utils/write_audio.py

@@ -0,0 +1,26 @@
+from ..constants import SAMPLE_RATE
+from ..datatypes import AudioT
+
+
+def write_audio(name: str, audio: AudioT, sample_rate: int = SAMPLE_RATE) -> None:
+    """Write an audio file.
+
+    To write multiple channels, use a 2D array of shape [channels, samples].
+    The bits per sample and PCM/float are determined by the data type.
+
+    """
+    import torch
+    import torchaudio
+
+    data = torch.tensor(audio)
+
+    if data.dim() == 1:
+        data = torch.reshape(data, (1, data.shape[0]))
+    if data.dim() != 2:
+        raise ValueError("audio must be a 1D or 2D array")
+
+    # Assuming data has more samples than channels, check if array needs to be transposed
+    if data.shape[1] < data.shape[0]:
+        data = torch.transpose(data, 0, 1)
+
+    torchaudio.save(uri=name, src=data, sample_rate=sample_rate)

sonusai/utils/yes_or_no.py

@@ -0,0 +1,8 @@
+def yes_or_no(question: str) -> bool:
+    """Wait for yes or no input"""
+    while True:
+        reply = str(input(question + " (y/n)?: ")).lower().strip()
+        if reply[:1] == "y":
+            return True
+        if reply[:1] == "n":
+            return False

sonusai/vars.py

@@ -0,0 +1,47 @@
+"""sonusai vars
+
+usage: vars [-h]
+
+options:
+   -h, --help   Display this help.
+
+List custom SonusAI variables.
+
+"""
+
+
+def main() -> None:
+    from docopt import docopt
+
+    from sonusai import __version__ as sai_version
+    from sonusai.utils.docstring import trim_docstring
+
+    docopt(trim_docstring(__doc__), version=sai_version, options_first=True)
+
+    from os import environ
+    from os import getenv
+
+    from sonusai.constants import DEFAULT_NOISE
+
+    print("Custom SonusAI variables:")
+    print("")
+    print(f"${{default_noise}}: {DEFAULT_NOISE}")
+    print("")
+    print("SonusAI recognized environment variables:")
+    print("")
+    print(f"DEEPGRAM_API_KEY {getenv('DEEPGRAM_API_KEY')}")
+    print(f"GOOGLE_SPEECH_API_KEY {getenv('GOOGLE_SPEECH_API_KEY')}")
+    print("")
+    items = ["DEEPGRAM_API_KEY", "GOOGLE_SPEECH_API_KEY"]
+    items += [item for item in environ if item.upper().startswith("AIXP_WHISPER_")]
+
+
+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)