sonusai 0.11.2__py3-none-any.whl → 0.11.4__py3-none-any.whl

sonusai/__init__.py

@@ -1,9 +1,8 @@
 import logging
+from importlib import metadata
 from os.path import dirname
 
-from pkg_resources import get_distribution
-
-__version__ = get_distribution('sonusai').version
+__version__ = metadata.version('sonusai')
 BASEDIR = dirname(__file__)
 
 # create logger

sonusai/data_generator/__init__.py

@@ -1,3 +1,4 @@
 # SonusAI data generator classes
 from sonusai.data_generator.keras_from_mixdb import KerasFromH5
 from sonusai.data_generator.keras_from_mixdb import KerasFromMixtureDatabase
+from sonusai.data_generator.dataset_from_mixdb import DatasetFromMixtureDatabase

sonusai/data_generator/dataset_from_mixdb.py

@@ -0,0 +1,246 @@
+import warnings
+from dataclasses import dataclass
+from typing import List
+
+import numpy as np
+import tensorflow as tf
+
+from sonusai.mixture import GeneralizedIDs
+from sonusai.mixture import MixtureDatabase
+from sonusai.utils import get_frames_per_batch
+
+
+def get_dataset_from_mixdb(mixdb: MixtureDatabase,
+                           mixids: GeneralizedIDs,
+                           batch_size: int,
+                           timesteps: int,
+                           flatten: bool,
+                           add1ch: bool,
+                           shuffle: bool = False) -> tf.data.Dataset:
+    @dataclass(frozen=True)
+    class BatchParams:
+        mixids: List[int]
+        offset: int
+        extra: int
+        padding: int
+
+    def _getitem(batch_index) -> (np.ndarray, np.ndarray):
+        """Get one batch of data
+        """
+        from sonusai.utils import reshape_inputs
+
+        batch_params = self.batch_params[batch_index]
+
+        result = [self.mixdb.mixture_ft(mixid) for mixid in 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
+
+    mixids = mixdb.mixids_to_list(mixids)
+    stride = mixdb.fg.stride
+    num_bands = mixdb.fg.num_bands
+    num_classes = mixdb.num_classes
+    mixture_frame_segments = None
+    batch_frame_segments = None
+
+    frames_per_batch = get_frames_per_batch(batch_size, timesteps)
+    # Always extend the number of batches to use all available data
+    # The last batch may need padding
+    total_batches = int(np.ceil(mixdb.total_feature_frames(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
+    batch_params = []
+    file_indices = []
+    total_frames = 0
+    for idx, mixid in enumerate(mixids):
+        current_frames = mixdb.mixture_samples(mixid) // mixdb.feature_step_samples
+        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 = mixids[start_mixture_index:idx + 1]
+            batch_params.append(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 = total_batches * frames_per_batch
+    padding = needed_frames - total_frames
+    if padding != 0:
+        mixids = mixids[start_mixture_index:]
+        batch_params.append(BatchParams(mixids=mixids, offset=offset, extra=0, padding=padding))
+
+    dataset = tf.data.Dataset.from_generator()
+    return dataset
+
+
+with warnings.catch_warnings():
+    warnings.simplefilter('ignore')
+    from keras.utils import Sequence
+
+
+class DatasetFromMixtureDatabase(Sequence):
+    """Generates data for Keras from a SonusAI mixture database
+    """
+    from dataclasses import dataclass
+
+    @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.num_bands = self.mixdb.fg.num_bands
+        self.num_classes = self.mixdb.num_classes
+        self.mixture_frame_segments = None
+        self.batch_frame_segments = None
+        self.total_batches = None
+
+        self._initialize_mixtures()
+
+    def __len__(self) -> int:
+        """Denotes the number of batches per epoch
+        """
+        return self.total_batches
+
+    def __getitem__(self, batch_index: int) -> (np.ndarray, np.ndarray):
+        """Get one batch of data
+        """
+        from sonusai.utils import reshape_inputs
+
+        batch_params = self.batch_params[batch_index]
+
+        result = [self.mixdb.mixture_ft(mixid) for mixid in 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_samples(mixid) // 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))

sonusai/data_generator/keras_from_mixdb.py

@@ -1,20 +1,40 @@
+import multiprocessing as mp
 import warnings
+from dataclasses import dataclass
 from typing import List
 
 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_init(mixdb: MixtureDatabase) -> None:
+    MP_GLOBAL.mixdb = mixdb
+
+
+def _pool_func(mixid: int) -> (Feature, Truth):
+    mixdb = MP_GLOBAL.mixdb
+    return mixdb.mixture_ft(mixid)
+
+
 class KerasFromMixtureDatabase(Sequence):
     """Generates data for Keras from a SonusAI mixture database
     """
-    from dataclasses import dataclass
 
     @dataclass(frozen=True)
     class BatchParams:
@@ -49,6 +69,10 @@ class KerasFromMixtureDatabase(Sequence):
 
         self._initialize_mixtures()
 
+        self.pool = mp.Pool(processes=mp.cpu_count(),
+                            initializer=_pool_init,
+                            initargs=[mixdb])
+
     def __len__(self) -> int:
         """Denotes the number of batches per epoch
         """
@@ -61,7 +85,7 @@ class KerasFromMixtureDatabase(Sequence):
 
         batch_params = self.batch_params[batch_index]
 
-        result = [self.mixdb.mixture_ft(mixid) for mixid in batch_params.mixids]
+        result = self.pool.map(_pool_func, 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))])
 

sonusai/keras_train.py

@@ -1,6 +1,6 @@
 """sonusai keras_train
 
-usage: keras_train [-hv] (-m MODEL) (-l VLOC) [-w KMODEL] [-e EPOCHS] [-b BATCH] [-t TSTEPS] [-p ESP] TLOC
+usage: keras_train [-hgv] (-m MODEL) (-l VLOC) [-w KMODEL] [-e EPOCHS] [-b BATCH] [-t TSTEPS] [-p ESP] TLOC
 
 options:
     -h, --help
@@ -12,6 +12,7 @@ options:
     -b BATCH, --batch BATCH         Batch size.
     -t TSTEPS, --tsteps TSTEPS      Timesteps.
     -p ESP, --patience ESP          Early stopping patience.
+    -g, --loss-batch-log            Enable per-batch loss log. [default: False]
 
 Use Keras to train a model defined by a Python definition file and SonusAI genft data.
 
@@ -20,6 +21,7 @@ Inputs:
     VLOC    A SonusAI mixture database directory to use for validation data.
 
 Results are written into subdirectory <MODEL>-<TIMESTAMP>.
+Per-batch loss history, if enabled, is written to <basename>-history-lossb.npy
 
 """
 import tensorflow as tf
@@ -27,6 +29,20 @@ import tensorflow as tf
 from sonusai import logger
 
 
+class LossBatchHistory(tf.keras.callbacks.Callback):
+    def __init__(self):
+        super().__init__()
+        self.history = None
+
+    def on_train_begin(self, logs=None):
+        self.history = {'loss': []}
+
+    def on_batch_end(self, batch, logs=None):
+        if logs is None:
+            logs = {}
+        self.history['loss'].append(logs.get('loss'))
+
+
 class SonusAIModelCheckpoint(tf.keras.callbacks.ModelCheckpoint):
     def __init__(self,
                  filepath,
@@ -80,6 +96,7 @@ def main():
     batch_size = args['--batch']
     timesteps = args['--tsteps']
     esp = args['--patience']
+    loss_batch_log = args['--loss-batch-log']
     t_name = args['TLOC']
 
     import warnings
@@ -108,6 +125,7 @@ def main():
     from sonusai.utils import import_keras_model
     from sonusai.utils import stratified_shuffle_split_mixid
     from sonusai.utils import reshape_outputs
+    from sonusai.utils import get_frames_per_batch
 
     model_base = basename(model_name)
     model_root = splitext(model_base)[0]
@@ -143,15 +161,18 @@ def main():
 
     # Check overrides
     timesteps = check_keras_overrides(model, t_mixdb.feature, t_mixdb.num_classes, timesteps, batch_size)
+    # Calculate batches per epoch, use ceiling as last batch is zero extended
+    frames_per_batch = get_frames_per_batch(batch_size, timesteps)
+    batches_per_epoch = int(np.ceil(t_mixdb.total_feature_frames('*') / frames_per_batch))
 
-    logger.info('Building model')
+    logger.info('Building and compiling model')
     try:
         hypermodel = model.MyHyperModel(feature=t_mixdb.feature,
                                         num_classes=t_mixdb.num_classes,
                                         timesteps=timesteps,
                                         batch_size=batch_size)
         built_model = hypermodel.build_model(kt.HyperParameters())
-        built_model = hypermodel.compile_default(built_model)
+        built_model = hypermodel.compile_default(built_model, batches_per_epoch)
     except Exception as e:
         logger.exception(f'Error: build_model() in {model_base} failed: {e}')
         raise SystemExit(1)
@@ -225,6 +246,15 @@ def main():
                                            feature=hypermodel.feature,
                                            num_classes=hypermodel.num_classes)
 
+    csv_logger = tf.keras.callbacks.CSVLogger(base_name + '-history.csv')
+    callbacks = [es, ckpt_callback, csv_logger]
+    # loss_batch_log = True
+    loss_batchlogger = None
+    if loss_batch_log is True:
+        loss_batchlogger = LossBatchHistory()
+        callbacks.append(loss_batchlogger)
+        logger.info(f'Adding per batch loss logging to training')
+
     if weights_name is not None:
         logger.info(f'Loading weights from {weights_name}')
         built_model.load_weights(weights_name)
@@ -240,13 +270,17 @@ def main():
                               epochs=epochs,
                               validation_data=v_datagen,
                               shuffle=False,
-                              callbacks=[es, ckpt_callback])
+                              callbacks=callbacks)
 
     # Save history into numpy file
     history_name = base_name + '-history'
     np.save(history_name, history.history)
     # Note: Reload with history=np.load(history_name, allow_pickle='TRUE').item()
     logger.info(f'Saved training history to numpy file {history_name}.npy')
+    if loss_batch_log is True:
+        his_batch_loss_name = base_name + '-history-lossb.npy'
+        np.save(his_batch_loss_name, loss_batchlogger.history)
+        logger.info(f'Saved per-batch loss history to numpy file {his_batch_loss_name}')
 
     # Find checkpoint file and load weights for prediction and model save
     checkpoint_name = None

sonusai/mixture/mixdb.py

@@ -88,6 +88,8 @@ class MixtureDatabaseConfig(DataClassSonusAIMixin):
 class TransformConfig:
     N: int
     R: int
+    bin_start: int
+    bin_end: int
     ttype: str
 
 
@@ -112,14 +114,20 @@ class MixtureDatabase:
 
         self.ft_config = TransformConfig(N=self.fg.ftransform_N,
                                          R=self.fg.ftransform_R,
+                                         bin_start=self.fg.bin_start,
+                                         bin_end=self.fg.bin_end,
                                          ttype=self.fg.ftransform_ttype)
 
         self.eft_config = TransformConfig(N=self.fg.eftransform_N,
                                           R=self.fg.eftransform_R,
+                                          bin_start=self.fg.bin_start,
+                                          bin_end=self.fg.bin_end,
                                           ttype=self.fg.eftransform_ttype)
 
         self.it_config = TransformConfig(N=self.fg.itransform_N,
                                          R=self.fg.itransform_R,
+                                         bin_start=self.fg.bin_start,
+                                         bin_end=self.fg.bin_end,
                                          ttype=self.fg.itransform_ttype)
 
         self.show_progress = show_progress
@@ -183,6 +191,8 @@ class MixtureDatabase:
         return calculate_transform_from_audio(audio=audio,
                                               transform=ForwardTransform(N=self.ft_config.N,
                                                                          R=self.ft_config.R,
+                                                                         bin_start=self.ft_config.bin_start,
+                                                                         bin_end=self.ft_config.bin_end,
                                                                          ttype=self.ft_config.ttype))
 
     def inverse_transform(self, transform: AudioF, trim: bool = True) -> AudioT:
@@ -201,6 +211,8 @@ class MixtureDatabase:
         return calculate_audio_from_transform(data=transform,
                                               transform=InverseTransform(N=self.it_config.N,
                                                                          R=self.it_config.R,
+                                                                         bin_start=self.it_config.bin_start,
+                                                                         bin_end=self.it_config.bin_end,
                                                                          ttype=self.it_config.ttype),
                                               trim=trim)
 
@@ -931,7 +943,11 @@ class MixtureDatabase:
         if noise is None:
             noise = self.mixture_noise(mixid=mixid)
 
-        fft = ForwardTransform(N=self.ft_config.N, R=self.ft_config.R, ttype=self.ft_config.ttype)
+        fft = ForwardTransform(N=self.ft_config.N,
+                               R=self.ft_config.R,
+                               bin_start=self.ft_config.bin_start,
+                               bin_end=self.ft_config.bin_end,
+                               ttype=self.ft_config.ttype)
 
         segsnr_t = np.empty(self.mixture_samples(mixid), dtype=np.float32)
 

sonusai/mixture/truth_functions/data.py

@@ -22,11 +22,17 @@ class Data:
         self.zero_based_indices = [x - 1 for x in config.index]
         self.target_fft = ForwardTransform(N=fg.ftransform_N,
                                            R=fg.ftransform_R,
+                                           bin_start=fg.bin_start,
+                                           bin_end=fg.bin_end,
                                            ttype=fg.ftransform_ttype)
         self.noise_fft = ForwardTransform(N=fg.ftransform_N,
                                           R=fg.ftransform_R,
+                                          bin_start=fg.bin_start,
+                                          bin_end=fg.bin_end,
                                           ttype=fg.ftransform_ttype)
         self.swin = InverseTransform(N=fg.itransform_N,
                                      R=fg.itransform_R,
+                                     bin_start=fg.bin_start,
+                                     bin_end=fg.bin_end,
                                      ttype=fg.itransform_ttype).W
         self.truth = np.zeros((len(target_audio), config.num_classes), dtype=np.float32)

sonusai/post_spenh_targetf.py

@@ -30,6 +30,8 @@ from sonusai import logger
 class MPGlobal:
     N: int = None
     R: int = None
+    bin_start: int = None
+    bin_end: int = None
     ttype: str = None
     output_dir: str = None
 
@@ -86,6 +88,8 @@ def main():
 
     MP_GLOBAL.N = fg.itransform_N
     MP_GLOBAL.R = fg.itransform_R
+    MP_GLOBAL.bin_start = fg.bin_start
+    MP_GLOBAL.bin_end = fg.bin_end
     MP_GLOBAL.ttype = fg.itransform_ttype
     MP_GLOBAL.output_dir = output_dir
 
@@ -135,6 +139,8 @@ def _process(file: str) -> None:
     audio = calculate_audio_from_transform(data=predict,
                                            transform=InverseTransform(N=MP_GLOBAL.N,
                                                                       R=MP_GLOBAL.R,
+                                                                      bin_start=MP_GLOBAL.bin_start,
+                                                                      bin_end=MP_GLOBAL.bin_end,
                                                                       ttype=MP_GLOBAL.ttype))
     write_wav(name=output_name, audio=float_to_int16(audio))
 

{sonusai-0.11.2.dist-info → sonusai-0.11.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sonusai
-Version: 0.11.2
+Version: 0.11.4
 Summary: Framework for building deep neural network models for sound, speech, and voice AI
 Home-page: https://aaware.com
 License: GPL-3.0-only
@@ -22,14 +22,13 @@ Requires-Dist: jiwer (>=2.5.1,<3.0.0)
 Requires-Dist: keras-tuner (>=1.1.3,<2.0.0)
 Requires-Dist: matplotlib (>=3.6.1,<4.0.0)
 Requires-Dist: onnxruntime-gpu (>=1.12.1,<2.0.0)
-Requires-Dist: openai-whisper (>=20230124,<20230125)
+Requires-Dist: openai-whisper (>=20230308,<20230309)
 Requires-Dist: paho-mqtt (>=1.6.1,<2.0.0)
 Requires-Dist: pandas (>=1.5.1,<2.0.0)
 Requires-Dist: pesq (>=0.0.4,<0.0.5)
-Requires-Dist: pyaaware (>=1.4.8,<2.0.0)
+Requires-Dist: pyaaware (>=1.4.10,<2.0.0)
 Requires-Dist: python-magic (>=0.4.27,<0.5.0)
 Requires-Dist: scikit-learn (>=1.2.0,<2.0.0)
-Requires-Dist: setuptools (>=67.0.0,<68.0.0)
 Requires-Dist: sh (>=1.14.3,<2.0.0)
 Requires-Dist: sox (>=1.4.1,<2.0.0)
 Requires-Dist: speechrecognition (>=3.9.0,<4.0.0)

{sonusai-0.11.2.dist-info → sonusai-0.11.4.dist-info}/RECORD

@@ -1,10 +1,11 @@
-sonusai/__init__.py,sha256=JARlx5Ajhbu96_s3F1OHy5XarxlAV2bJRGlQZjopKDI,1545
+sonusai/__init__.py,sha256=tJ9Xc9buVO_kJx_4lt3FAXS9yydQh5r3M2h2Zd0PXaM,1524
 sonusai/aawscd_probwrite.py,sha256=nHvcQYNGFgsD6p-83BIgatDXAH7Cn8vBsYnj7bK8NsI,3595
 sonusai/calc_metric_spenh_targetf.py,sha256=Z9kT7KFLdLf3wqx6iPAZVfRj0SIJq1YwOUakUzPrUoY,39136
 sonusai/data/genmixdb.yml,sha256=_TVmMKuq-XDiI7JKIp0-1PxeJ5vplH6a1GL5dcnisyk,14811
 sonusai/data/whitenoise.wav,sha256=I2umov0m34y56F9IsIBi1XtE76ZeZaSKDf70cJRe3pI,1920044
-sonusai/data_generator/__init__.py,sha256=LlQB3ixkiRLu3RHpFymHDdPycUq7cy_aqEcG8n_F51U,174
-sonusai/data_generator/keras_from_mixdb.py,sha256=7RyvnZbRIJGY_gLTVImFJrMGYAj6_QC04DXtfCcm6S4,5488
+sonusai/data_generator/__init__.py,sha256=J049X4nPPYxUsEQD3Gw5kO_cWNgloqvXKC3f0oNYP7Y,255
+sonusai/data_generator/dataset_from_mixdb.py,sha256=jwLEwB6Zp70Be0A4fHoYOTfSNBdyldzsIeooyASxZHM,9648
+sonusai/data_generator/keras_from_mixdb.py,sha256=oJ1rYUCagf5tCAwA2SZPGMHaYjWxraVwgLcE60AbCYY,5998
 sonusai/evaluate.py,sha256=pNM8fgAEuynQWgxbJBAbhJ1ViaYP9h0SsslireX8yuk,9905
 sonusai/genft.py,sha256=N_W4RCbjDds_Ck8UdAvGOwibLjjjqmO_yCXjatm3pKA,5244
 sonusai/genmix.py,sha256=VeZ16dW5pblX-hD7n7H1m9XKA1-uKcvTk8FdP87ljI0,6791
@@ -12,7 +13,7 @@ sonusai/genmixdb.py,sha256=Hki2SFotce4tu4SsXkWXRRbRgKTXqjVlZft_CDYt9kU,27762
 sonusai/gentcst.py,sha256=KiGF2ay0hTe2bYP7PxAAaxxjof-8wjNAJVuGXh_Eec8,17999
 sonusai/keras_onnx.py,sha256=e1RBbmpWVVsSJpY2hK2W5X_k832S_mm9qjOjvNpNZlU,2650
 sonusai/keras_predict.py,sha256=oIX7o7jy8wCoxxPgAv59ic6HdE1-4hnMvrOQwywRA-Y,9036
-sonusai/keras_train.py,sha256=PiVPSmamQfh6rO0GfU2Soiki_2Wc7ey6dRCXR23GCpM,11776
+sonusai/keras_train.py,sha256=TJkkxVu2Kq8lZu345XAsvK0vXx15rSRSxMJal5N6vDw,13263
 sonusai/lsdb.py,sha256=rVv0fC6SWtiD4Jye3ymZBLnUvHVcEP2rYTWEhYEGFCU,6048
 sonusai/main.py,sha256=QQdhz__7eIRYjKISXXAkOaHNnyCeuTzX-eAdjwXJSXU,2686
 sonusai/metrics/__init__.py,sha256=JGRraTXY0riOgr7C2F_4u6l_XyS2L_TM4R2zW1MpJ7c,782
@@ -39,14 +40,14 @@ sonusai/mixture/feature.py,sha256=REclCIcO8MLM0w6r7k6OkVOkKYhdutB74TaQQNOv3QM,95
 sonusai/mixture/initialize.py,sha256=bUnYcTG3wOLUX4L2ohF4F_dMhiNmEjnd6WCqGIa_ayQ,5825
 sonusai/mixture/log_duration_and_sizes.py,sha256=oZMRRf0A2fD9brGDfQoOJTHSBhhGO986QUOEMDdr-mc,1337
 sonusai/mixture/mapped_snr_f.py,sha256=OMs5GJGVVbXQrublUSrAY8zDuh1fPM7OZB1BT8BXI2w,1808
-sonusai/mixture/mixdb.py,sha256=DigSU4K7RtfPSvNu-cmOVdGukaiEn6WhMPpq899koOQ,45640
+sonusai/mixture/mixdb.py,sha256=6lkNW-JEviebBvN4S5xQmhmwTW10yQgZW1Xw5ZLEybA,46706
 sonusai/mixture/spectral_mask.py,sha256=qHR2DBpbtz4u1o9sdFMRsUDVUjbof_MRKPW8uY4RxKI,2099
 sonusai/mixture/target_class_balancing.py,sha256=dmk7GLSv_h4tbxc09tyXPY76U_kR_U3chuQi-CDut50,3809
 sonusai/mixture/targets.py,sha256=nqL1OE5czarI6AoFB_kBen6o8j443a4e5tEvYKS2rcg,6929
 sonusai/mixture/truth.py,sha256=DGmQDDYP6B7tKFVFeNliHGbrgo4V9XDt4kanaCekEj8,1480
 sonusai/mixture/truth_functions/__init__.py,sha256=22KGvx1yAzQlYUlsoXRG3_aJhsjN02NSSuINNkrlQ4s,731
 sonusai/mixture/truth_functions/crm.py,sha256=t4YZqLX-ZAlzfJzQAhQPWqxkYu4B6yr6jzKdz5TQdVc,1899
-sonusai/mixture/truth_functions/data.py,sha256=siia-pj2pAUWaWW7XO3ONXeTqTVwaJE_tx6KfCTaHyc,1461
+sonusai/mixture/truth_functions/data.py,sha256=sm6eXae2-ZXvRi1daZO3Xf74pAm-hCwuvdSVD-UAjRI,1837
 sonusai/mixture/truth_functions/energy.py,sha256=1sQi0XfgFKZuY4fDt-S9zhid05QUJY3nNPiTkt3D3YI,2795
 sonusai/mixture/truth_functions/file.py,sha256=gz6w0Q8kmqgaOSzS11ZUq02MZjzjC1T0CYjJBvSdono,1486
 sonusai/mixture/truth_functions/phoneme.py,sha256=HTRy6uaOrFR7yNCQMITQSHvhZUp0X2eU9wwfdb-g_Vo,465
@@ -56,7 +57,7 @@ sonusai/mixture/types.py,sha256=I8hJ7bt1q7IQS6OrNwE1M7_w8HT6w8eKSP5yAQcaeQU,4028
 sonusai/mkwav.py,sha256=hibVT8LhE_fxDJQjMTX8cR0PQn9vNu4-05BZerVw9gk,5255
 sonusai/onnx_predict.py,sha256=VeC5VTSxqg83pCfEljDnUczTxOSZ8z4E1QuYO9hs-18,8816
 sonusai/plot.py,sha256=KB0yTU-pIyJSJc8tPHJxmnFkDmFG6DTwkYZmqKgzHvY,16983
-sonusai/post_spenh_targetf.py,sha256=I3zDE-vCxYjBjhqQM3_idQCQpQaa3AjwsyeOhmPIs74,4607
+sonusai/post_spenh_targetf.py,sha256=hL0XgOw-ZyJCZ11Q63uHHpoEvIf_2LEOjLBoanyBJ1s,4929
 sonusai/queries/__init__.py,sha256=_8HEa0W4gA6Yeh8SuQ9_tAIMuZY0VbFgNRlKRZT-ZqA,473
 sonusai/queries/queries.py,sha256=LTjSHTnh4_O6-CdLNWaERAzCjorhZ7T_O6lZbm_sGxs,9182
 sonusai/tplot.py,sha256=aLU05nxcWoIbxlCbVqTeGR7aBFVzLEIC0KKkfWXqGGQ,14412
@@ -95,7 +96,7 @@ sonusai/utils/trim_docstring.py,sha256=dSrtiRsEN4wkkvKBp6WDr13RUypfqZzgH_jOBLs1o
 sonusai/utils/wave.py,sha256=bixtXS8ZXSTAu1k_2N7fVKaIl4h5xsxIiCVHxB0giBI,445
 sonusai/utils/yes_or_no.py,sha256=zSQu9tumz8M-du9KLKWeytHiFB6sohC_s28rQq2lXRc,282
 sonusai/vars.py,sha256=nPVsBKM5Kwpyn1eqrclOQV8OC-4RnR5evuBaGA6-nIA,517
-sonusai-0.11.2.dist-info/METADATA,sha256=bzkYezIMZRhkCmDmUa-9dEfvi9EpXAewO5Z9hq_sWrM,2508
-sonusai-0.11.2.dist-info/entry_points.txt,sha256=zMNjEphEPO6B3cD1GNpit7z-yA9tUU5-j3W2v-UWstU,92
-sonusai-0.11.2.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
-sonusai-0.11.2.dist-info/RECORD,,
+sonusai-0.11.4.dist-info/METADATA,sha256=1QcrEh9C3XZ6KMJrCzmiP-i-b9r6lcLaS5fh2yOSwQA,2464
+sonusai-0.11.4.dist-info/entry_points.txt,sha256=zMNjEphEPO6B3cD1GNpit7z-yA9tUU5-j3W2v-UWstU,92
+sonusai-0.11.4.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
+sonusai-0.11.4.dist-info/RECORD,,