sonusai 0.15.9__py3-none-any.whl → 0.16.1__py3-none-any.whl

sonusai/data_generator/keras_from_mixdb.py

@@ -1,169 +0,0 @@
-import warnings
-from dataclasses import dataclass
-from multiprocessing import get_context
-from os import cpu_count
-from typing import Optional
-
-import numpy as np
-
-from sonusai.mixture import Feature
-from sonusai.mixture import GeneralizedIDs
-from sonusai.mixture import MixtureDatabase
-from sonusai.mixture import Truth
-
-with warnings.catch_warnings():
-    warnings.simplefilter('ignore')
-    from keras.utils import Sequence
-
-
-@dataclass
-class MPGlobal:
-    mixdb: MixtureDatabase = None
-
-
-MP_GLOBAL = MPGlobal()
-
-
-def _pool_initializer(location: str) -> None:
-    MP_GLOBAL.mixdb = MixtureDatabase(location)
-
-
-def _pool_kernel(mixid: int) -> tuple[Feature, Truth]:
-    return MP_GLOBAL.mixdb.mixture_ft(mixid)
-
-
-class KerasFromMixtureDatabase(Sequence):
-    """Generates data for Keras from a SonusAI mixture database
-    """
-
-    @dataclass(frozen=True)
-    class BatchParams:
-        mixids: list[int]
-        offset: int
-        extra: int
-        padding: int
-
-    def __init__(self,
-                 mixdb: MixtureDatabase,
-                 mixids: GeneralizedIDs,
-                 batch_size: int,
-                 timesteps: int,
-                 flatten: bool,
-                 add1ch: bool,
-                 shuffle: bool = False):
-        """Initialization
-        """
-        self.mixdb = mixdb
-        self.mixids = self.mixdb.mixids_to_list(mixids)
-        self.batch_size = batch_size
-        self.timesteps = timesteps
-        self.flatten = flatten
-        self.add1ch = add1ch
-        self.shuffle = shuffle
-        self.stride = self.mixdb.fg_stride
-        self.feature_parameters = self.mixdb.feature_parameters
-        self.num_classes = self.mixdb.num_classes
-        self.mixture_frame_segments: Optional[int] = None
-        self.batch_frame_segments: Optional[int] = None
-        self.total_batches: Optional[int] = None
-
-        self._initialize_mixtures()
-
-        self.pool = get_context('fork').Pool(processes=cpu_count(),
-                                             initializer=_pool_initializer,
-                                             initargs=(self.mixdb.location,))
-
-    def __len__(self) -> int:
-        """Denotes the number of batches per epoch
-        """
-        return self.total_batches
-
-    def __getitem__(self, batch_index: int) -> tuple[np.ndarray, np.ndarray]:
-        """Get one batch of data
-        """
-        from sonusai.utils import reshape_inputs
-
-        batch_params = self.batch_params[batch_index]
-
-        result = self.pool.map(_pool_kernel, batch_params.mixids)
-        feature = np.vstack([result[i][0] for i in range(len(result))])
-        truth = np.vstack([result[i][1] for i in range(len(result))])
-
-        pad_shape = list(feature.shape)
-        pad_shape[0] = batch_params.padding
-        feature = np.vstack([feature, np.zeros(pad_shape)])
-
-        pad_shape = list(truth.shape)
-        pad_shape[0] = batch_params.padding
-        truth = np.vstack([truth, np.zeros(pad_shape)])
-
-        if batch_params.extra > 0:
-            feature = feature[batch_params.offset:-batch_params.extra]
-            truth = truth[batch_params.offset:-batch_params.extra]
-        else:
-            feature = feature[batch_params.offset:]
-            truth = truth[batch_params.offset:]
-
-        feature, truth = reshape_inputs(feature=feature,
-                                        truth=truth,
-                                        batch_size=self.batch_size,
-                                        timesteps=self.timesteps,
-                                        flatten=self.flatten,
-                                        add1ch=self.add1ch)
-
-        return feature, truth
-
-    def on_epoch_end(self) -> None:
-        """Modification of dataset between epochs
-        """
-        import random
-
-        if self.shuffle:
-            random.shuffle(self.mixids)
-            self._initialize_mixtures()
-
-    def _initialize_mixtures(self) -> None:
-        from sonusai.utils import get_frames_per_batch
-
-        frames_per_batch = get_frames_per_batch(self.batch_size, self.timesteps)
-        # Always extend the number of batches to use all available data
-        # The last batch may need padding
-        self.total_batches = int(np.ceil(self.mixdb.total_feature_frames(self.mixids) / frames_per_batch))
-
-        # Compute mixid, offset, and extra for dataset
-        # offsets and extras are needed because mixtures are not guaranteed to fall on batch boundaries.
-        # When fetching a new index that starts in the middle of a sequence of mixtures, the
-        # previous feature frame offset must be maintained in order to preserve the correct
-        # data sequence. And the extra must be maintained in order to preserve the correct data length.
-        cumulative_frames = 0
-        start_mixture_index = 0
-        offset = 0
-        self.batch_params = []
-        self.file_indices = []
-        total_frames = 0
-        for idx, mixid in enumerate(self.mixids):
-            current_frames = self.mixdb.mixture(mixid).samples // self.mixdb.feature_step_samples
-            self.file_indices.append(slice(total_frames, total_frames + current_frames))
-            total_frames += current_frames
-            cumulative_frames += current_frames
-            while cumulative_frames >= frames_per_batch:
-                extra = cumulative_frames - frames_per_batch
-                mixids = self.mixids[start_mixture_index:idx + 1]
-                self.batch_params.append(self.BatchParams(mixids=mixids, offset=offset, extra=extra, padding=0))
-                if extra == 0:
-                    start_mixture_index = idx + 1
-                    offset = 0
-                else:
-                    start_mixture_index = idx
-                    offset = current_frames - extra
-                cumulative_frames = extra
-
-        # If needed, add final batch with padding
-        needed_frames = self.total_batches * frames_per_batch
-        padding = needed_frames - total_frames
-        if padding != 0:
-            mixids = self.mixids[start_mixture_index:]
-            self.batch_params.append(self.BatchParams(mixids=mixids, offset=offset, extra=0, padding=padding))
-
-
-KerasFromH5 = KerasFromMixtureDatabase

sonusai/data_generator/torch_from_mixdb.py

@@ -1,122 +0,0 @@
-from typing import Optional
-
-import numpy as np
-from torch.utils.data import DataLoader
-from torch.utils.data import Dataset
-from torch.utils.data import Sampler
-
-from sonusai.mixture import GeneralizedIDs
-from sonusai.mixture import MixtureDatabase
-
-
-class MixtureDatabaseDataset(Dataset):
-    """Generates a PyTorch dataset from a SonusAI mixture database
-    """
-
-    def __init__(self,
-                 mixdb: MixtureDatabase,
-                 mixids: GeneralizedIDs,
-                 cut_len: int,
-                 flatten: bool,
-                 add1ch: bool,
-                 random_cut: bool = True):
-        """Initialization
-        """
-        self.mixdb = mixdb
-        self.mixids = self.mixdb.mixids_to_list(mixids)
-        self.cut_len = cut_len
-        self.flatten = flatten
-        self.add1ch = add1ch
-        self.random_cut = random_cut
-
-    def __len__(self):
-        return len(self.mixids)
-
-    def __getitem__(self, idx: int) -> tuple[np.ndarray, np.ndarray, int]:
-        """Get data from one mixture
-        """
-        import random
-
-        from sonusai.utils import reshape_inputs
-
-        feature, truth = self.mixdb.mixture_ft(self.mixids[idx])
-        feature, truth = reshape_inputs(feature=feature,
-                                        truth=truth,
-                                        batch_size=1,
-                                        timesteps=0,
-                                        flatten=self.flatten,
-                                        add1ch=self.add1ch)
-
-        length = feature.shape[0]
-
-        if self.cut_len > 0:
-            if length < self.cut_len:
-                feature_final = []
-                truth_final = []
-                for _ in range(self.cut_len // length):
-                    feature_final.append(feature)
-                    truth_final.append(truth)
-                feature_final.append(feature[: self.cut_len % length])
-                truth_final.append(truth[: self.cut_len % length])
-                feature = np.vstack([feature_final[i] for i in range(len(feature_final))])
-                truth = np.vstack([truth_final[i] for i in range(len(truth_final))])
-            else:
-                if self.random_cut:
-                    start = random.randint(0, length - self.cut_len)
-                else:
-                    start = 0
-                feature = feature[start:start + self.cut_len]
-                truth = truth[start:start + self.cut_len]
-
-        return feature, truth, idx
-
-
-class AawareDataLoader(DataLoader):
-    _cut_len: Optional[int] = None
-
-    @property
-    def cut_len(self) -> int:
-        return self._cut_len
-
-    @cut_len.setter
-    def cut_len(self, value: int) -> None:
-        self._cut_len = value
-
-
-def TorchFromMixtureDatabase(mixdb: MixtureDatabase,
-                             mixids: GeneralizedIDs,
-                             batch_size: int,
-                             flatten: bool,
-                             add1ch: bool,
-                             num_workers: int = 0,
-                             cut_len: int = 0,
-                             drop_last: bool = False,
-                             shuffle: bool = False,
-                             random_cut: bool = True,
-                             sampler: Optional[type[Sampler]] = None,
-                             pin_memory: bool = False) -> AawareDataLoader:
-    """Generates a PyTorch dataloader from a SonusAI mixture database
-    """
-    dataset = MixtureDatabaseDataset(mixdb=mixdb,
-                                     mixids=mixids,
-                                     cut_len=cut_len,
-                                     flatten=flatten,
-                                     add1ch=add1ch,
-                                     random_cut=random_cut)
-
-    if sampler is not None:
-        my_sampler = sampler(dataset)
-    else:
-        my_sampler = None
-
-    result = AawareDataLoader(dataset=dataset,
-                              batch_size=batch_size,
-                              pin_memory=pin_memory,
-                              shuffle=shuffle,
-                              sampler=my_sampler,
-                              drop_last=drop_last,
-                              num_workers=num_workers)
-
-    result.cut_len = cut_len
-
-    return result

sonusai/keras_onnx.py

@@ -1,86 +0,0 @@
-"""sonusai keras_onnx
-
-usage: keras_onnx [-hvr] (-m MODEL) (-w WEIGHTS) [-b BATCH] [-t TSTEPS] [-o OUTPUT]
-
-options:
-    -h, --help
-    -v, --verbose                   Be verbose.
-    -m MODEL, --model MODEL         Python model file.
-    -w WEIGHTS, --weights WEIGHTS   Keras model weights file.
-    -b BATCH, --batch BATCH         Batch size.
-    -t TSTEPS, --tsteps TSTEPS      Timesteps.
-    -o OUTPUT, --output OUTPUT      Output directory.
-
-Convert a trained Keras model to ONNX.
-
-Inputs:
-    MODEL       A SonusAI Python model file with build and/or hypermodel functions.
-    WEIGHTS     A Keras model weights file (or model file with weights).
-
-Outputs:
-    OUTPUT/     A directory containing:
-                    <MODEL>.onnx        Model file with batch_size and timesteps equal to provided parameters
-                    <MODEL>-b1.onnx     Model file with batch_size=1 and if the timesteps dimension exists it
-                                        is set to 1 (useful for real-time inference applications)
-                    keras_onnx.log
-
-Results are written into subdirectory <MODEL>-<TIMESTAMP> unless OUTPUT is specified.
-
-"""
-from sonusai import logger
-
-
-def main() -> None:
-    from docopt import docopt
-
-    import sonusai
-    from sonusai.utils import trim_docstring
-
-    args = docopt(trim_docstring(__doc__), version=sonusai.__version__, options_first=True)
-
-    verbose = args['--verbose']
-    model_name = args['--model']
-    weight_name = args['--weights']
-    batch_size = args['--batch']
-    timesteps = args['--tsteps']
-    output_dir = args['--output']
-
-    from os import makedirs
-    from os.path import basename
-    from os.path import join
-    from os.path import splitext
-
-    from sonusai import create_file_handler
-    from sonusai import initial_log_messages
-    from sonusai import update_console_handler
-    from sonusai.utils import create_ts_name
-    from sonusai.utils import keras_onnx
-
-    model_tail = basename(model_name)
-    model_root = splitext(model_tail)[0]
-
-    if batch_size is not None:
-        batch_size = int(batch_size)
-
-    if timesteps is not None:
-        timesteps = int(timesteps)
-
-    if output_dir is None:
-        output_dir = create_ts_name(model_root)
-
-    makedirs(output_dir, exist_ok=True)
-
-    # Setup logging file
-    create_file_handler(join(output_dir, 'keras_onnx.log'))
-    update_console_handler(verbose)
-    initial_log_messages('keras_onnx')
-
-    keras_onnx(model_name, weight_name, timesteps, batch_size, output_dir)
-
-
-if __name__ == '__main__':
-    try:
-        main()
-    except KeyboardInterrupt:
-        logger.info('Canceled due to keyboard interrupt')
-        exit()

sonusai/keras_predict.py

@@ -1,231 +0,0 @@
-"""sonusai keras_predict
-
-usage: keras_predict [-hvr] [-i MIXID] (-m MODEL) (-w KMODEL) [-b BATCH] [-t TSTEPS] INPUT ...
-
-options:
-    -h, --help
-    -v, --verbose                   Be verbose.
-    -i MIXID, --mixid MIXID         Mixture ID(s) to generate if input is a mixture database. [default: *].
-    -m MODEL, --model MODEL         Python model file.
-    -w KMODEL, --weights KMODEL     Keras model weights file.
-    -b BATCH, --batch BATCH         Batch size.
-    -t TSTEPS, --tsteps TSTEPS      Timesteps.
-    -r, --reset                     Reset model between each file.
-
-Run prediction on a trained Keras model defined by a SonusAI Keras Python model file using SonusAI genft or WAV data.
-
-Inputs:
-    MODEL       A SonusAI Python model file with build and/or hypermodel functions.
-    KMODEL      A Keras model weights file (or model file with weights).
-    INPUT       The input data must be one of the following:
-                * Single WAV file or glob of WAV files
-                  Using the given model, generate feature data and run prediction. A model file must be
-                  provided. The MIXID is ignored.
-
-                * directory
-                  Using the given SonusAI mixture database directory, generate feature and truth data if not found.
-                  Run prediction. The MIXID is required.
-
-Outputs the following to kpredict-<TIMESTAMP> directory:
-    <id>.h5
-        dataset:    predict
-    keras_predict.log
-
-"""
-from typing import Any
-
-from sonusai import logger
-from sonusai.mixture import Feature
-from sonusai.mixture import Predict
-
-
-def main() -> None:
-    from docopt import docopt
-
-    import sonusai
-    from sonusai.utils import trim_docstring
-
-    args = docopt(trim_docstring(__doc__), version=sonusai.__version__, options_first=True)
-
-    verbose = args['--verbose']
-    mixids = args['--mixid']
-    model_name = args['--model']
-    weights_name = args['--weights']
-    batch_size = args['--batch']
-    timesteps = args['--tsteps']
-    reset = args['--reset']
-    input_name = args['INPUT']
-
-    from os import makedirs
-    from os.path import basename
-    from os.path import isdir
-    from os.path import isfile
-    from os.path import join
-    from os.path import splitext
-
-    import h5py
-    import keras_tuner as kt
-    import tensorflow as tf
-    from keras import backend as kb
-
-    from sonusai import create_file_handler
-    from sonusai import initial_log_messages
-    from sonusai import update_console_handler
-    from sonusai.data_generator import KerasFromH5
-    from sonusai.mixture import MixtureDatabase
-    from sonusai.mixture import get_feature_from_audio
-    from sonusai.mixture import read_audio
-    from sonusai.utils import create_ts_name
-    from sonusai.utils import get_frames_per_batch
-    from sonusai.utils import import_and_check_keras_model
-    from sonusai.utils import reshape_outputs
-
-    if batch_size is not None:
-        batch_size = int(batch_size)
-
-    if timesteps is not None:
-        timesteps = int(timesteps)
-
-    output_dir = create_ts_name('kpredict')
-    makedirs(output_dir, exist_ok=True)
-
-    # Setup logging file
-    create_file_handler(join(output_dir, 'keras_predict.log'))
-    update_console_handler(verbose)
-    initial_log_messages('keras_predict')
-
-    logger.info(f'tensorflow    {tf.__version__}')
-    logger.info(f'keras         {tf.keras.__version__}')
-    logger.info('')
-
-    hypermodel = import_and_check_keras_model(model_name=model_name,
-                                              weights_name=weights_name,
-                                              timesteps=timesteps,
-                                              batch_size=batch_size)
-    built_model = hypermodel.build_model(kt.HyperParameters())
-
-    frames_per_batch = get_frames_per_batch(hypermodel.batch_size, hypermodel.timesteps)
-
-    kb.clear_session()
-    logger.info('')
-    built_model.summary(print_fn=logger.info)
-    logger.info('')
-    logger.info(f'feature       {hypermodel.feature}')
-    logger.info(f'num_classes   {hypermodel.num_classes}')
-    logger.info(f'batch_size    {hypermodel.batch_size}')
-    logger.info(f'timesteps     {hypermodel.timesteps}')
-    logger.info(f'flatten       {hypermodel.flatten}')
-    logger.info(f'add1ch        {hypermodel.add1ch}')
-    logger.info(f'truth_mutex   {hypermodel.truth_mutex}')
-    logger.info(f'input_shape   {hypermodel.input_shape}')
-    logger.info('')
-
-    logger.info(f'Loading weights from {weights_name}')
-    built_model.load_weights(weights_name)
-
-    logger.info('')
-    if len(input_name) == 1 and isdir(input_name[0]):
-        input_name = input_name[0]
-        logger.info(f'Load mixture database from {input_name}')
-        mixdb = MixtureDatabase(input_name)
-
-        if mixdb.feature != hypermodel.feature:
-            logger.exception(f'Feature in mixture database does not match feature in model')
-            raise SystemExit(1)
-
-        mixids = mixdb.mixids_to_list(mixids)
-        if reset:
-            # reset mode cycles through each file one at a time
-            for mixid in mixids:
-                feature, _ = mixdb.mixture_ft(mixid)
-
-                feature, predict = _pad_and_predict(hypermodel=hypermodel,
-                                                    built_model=built_model,
-                                                    feature=feature,
-                                                    frames_per_batch=frames_per_batch)
-
-                output_name = join(output_dir, mixdb.mixtures[mixid].name)
-                with h5py.File(output_name, 'a') as f:
-                    if 'predict' in f:
-                        del f['predict']
-                    f.create_dataset(name='predict', data=predict)
-        else:
-            # Run all data at once using a data generator
-            feature = KerasFromH5(mixdb=mixdb,
-                                  mixids=mixids,
-                                  batch_size=hypermodel.batch_size,
-                                  timesteps=hypermodel.timesteps,
-                                  flatten=hypermodel.flatten,
-                                  add1ch=hypermodel.add1ch)
-
-            predict = built_model.predict(feature, batch_size=hypermodel.batch_size, verbose=1)
-            predict, _ = reshape_outputs(predict=predict, timesteps=hypermodel.timesteps)
-
-            # Write data to separate files
-            for idx, mixid in enumerate(mixids):
-                output_name = join(output_dir, mixdb.mixtures[mixid].name)
-                with h5py.File(output_name, 'a') as f:
-                    if 'predict' in f:
-                        del f['predict']
-                    f.create_dataset('predict', data=predict[feature.file_indices[idx]])
-
-        logger.info(f'Saved results to {output_dir}')
-        return
-
-    if not all(isfile(file) and splitext(file)[1] == '.wav' for file in input_name):
-        logger.exception(f'Do not know how to process input from {input_name}')
-        raise SystemExit(1)
-
-    logger.info(f'Run prediction on {len(input_name):,} WAV files')
-    for file in input_name:
-        # Convert WAV to feature data
-        audio = read_audio(file)
-        feature = get_feature_from_audio(audio=audio, feature_mode=hypermodel.feature)
-
-        feature, predict = _pad_and_predict(hypermodel=hypermodel,
-                                            built_model=built_model,
-                                            feature=feature,
-                                            frames_per_batch=frames_per_batch)
-
-        output_name = join(output_dir, splitext(basename(file))[0] + '.h5')
-        with h5py.File(output_name, 'a') as f:
-            if 'feature' in f:
-                del f['feature']
-            f.create_dataset(name='feature', data=feature)
-
-            if 'predict' in f:
-                del f['predict']
-            f.create_dataset(name='predict', data=predict)
-
-    logger.info(f'Saved results to {output_dir}')
-
-
-def _pad_and_predict(hypermodel: Any,
-                     built_model: Any,
-                     feature: Feature,
-                     frames_per_batch: int) -> tuple[Feature, Predict]:
-    import numpy as np
-
-    from sonusai.utils import reshape_inputs
-    from sonusai.utils import reshape_outputs
-
-    frames = feature.shape[0]
-    padding = frames_per_batch - frames % frames_per_batch
-    feature = np.pad(array=feature, pad_width=((0, padding), (0, 0), (0, 0)))
-    feature, _ = reshape_inputs(feature=feature,
-                                batch_size=hypermodel.batch_size,
-                                timesteps=hypermodel.timesteps,
-                                flatten=hypermodel.flatten,
-                                add1ch=hypermodel.add1ch)
-    predict = built_model.predict(feature, batch_size=hypermodel.batch_size, verbose=1)
-    predict, _ = reshape_outputs(predict=predict, timesteps=hypermodel.timesteps)
-    predict = predict[:frames, :]
-    return feature, predict
-
-
-if __name__ == '__main__':
-    try:
-        main()
-    except KeyboardInterrupt:
-        logger.info('Canceled due to keyboard interrupt')
-        exit()