sonusai 0.11.2__tar.gz → 0.11.4__tar.gz

{sonusai-0.11.2 → sonusai-0.11.4}/PKG-INFO

@@ -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 → sonusai-0.11.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "sonusai"
-version = "0.11.2"
+version = "0.11.4"
 description = "Framework for building deep neural network models for sound, speech, and voice AI"
 authors = ["Chris Eddington <chris@aaware.com>", "Jason Calderwood <jason@aaware.com>"]
 maintainers = ["Chris Eddington <chris@aaware.com>", "Jason Calderwood <jason@aaware.com>"]
@@ -22,15 +22,14 @@ jiwer = "^2.5.1"
 keras-tuner = "^1.1.3"
 matplotlib = "^3.6.1"
 onnxruntime-gpu = "^1.12.1"
-openai-whisper = "^20230124"
+openai-whisper = "^20230308"
 paho-mqtt = "^1.6.1"
 pandas = "^1.5.1"
 pesq = "^0.0.4"
-pyaaware = "^1.4.8"
+pyaaware = "^1.4.10"
 python = ">=3.8,<3.11"
 python-magic = "^0.4.27"
 scikit-learn = "^1.2.0"
-setuptools = "^67.0.0"
 sh = "^1.14.3"
 sox = "^1.4.1"
 speechrecognition = "^3.9.0"

{sonusai-0.11.2 → sonusai-0.11.4}/setup.py

@@ -23,14 +23,13 @@ install_requires = \
  'keras-tuner>=1.1.3,<2.0.0',
  'matplotlib>=3.6.1,<4.0.0',
  'onnxruntime-gpu>=1.12.1,<2.0.0',
- 'openai-whisper>=20230124,<20230125',
+ 'openai-whisper>=20230308,<20230309',
  'paho-mqtt>=1.6.1,<2.0.0',
  'pandas>=1.5.1,<2.0.0',
  'pesq>=0.0.4,<0.0.5',
- 'pyaaware>=1.4.8,<2.0.0',
+ 'pyaaware>=1.4.10,<2.0.0',
  'python-magic>=0.4.27,<0.5.0',
  'scikit-learn>=1.2.0,<2.0.0',
- 'setuptools>=67.0.0,<68.0.0',
  'sh>=1.14.3,<2.0.0',
  'sox>=1.4.1,<2.0.0',
  'speechrecognition>=3.9.0,<4.0.0',
@@ -45,7 +44,7 @@ entry_points = \
 
 setup_kwargs = {
     'name': 'sonusai',
-    'version': '0.11.2',
+    'version': '0.11.4',
     'description': 'Framework for building deep neural network models for sound, speech, and voice AI',
     'long_description': "Sonus AI: Framework for simplified creation of deep NN models for sound, speech, and voice AI\n\nSonus AI includes functions for pre-processing training and validation data and\ncreating performance metrics reports for key types of Keras models:\n- recurrent, convolutional, or a combination (i.e. RCNNs)\n- binary, multiclass single-label, multiclass multi-label, and regresssion\n- training with data augmentations:  noise mixing, pitch and time stretch, etc.\n\nSonus AI python functions are used by:\n - Aaware Inc. sonusai executable:  Easily create train/validation data, run prediction, evaluate model performance\n - Keras model scripts:             User python scripts for keras model creation, training, and prediction. These can use sonusai-specific data but also some general useful utilities for trainining rnn-based models like CRNN's, DSCRNN's, etc. in Keras\n",
     'author': 'Chris Eddington',

{sonusai-0.11.2 → sonusai-0.11.4}/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-0.11.2 → sonusai-0.11.4}/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-0.11.4/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-0.11.2 → sonusai-0.11.4}/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-0.11.2 → sonusai-0.11.4}/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-0.11.2 → sonusai-0.11.4}/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-0.11.2 → sonusai-0.11.4}/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-0.11.2 → sonusai-0.11.4}/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))