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

sonusai/torchl_train.py

@@ -1,223 +0,0 @@
-"""sonusai torchl_train
-
-usage: torchl_train [-hgv] (-m MODEL) (-l VLOC) [-w WEIGHTS] [-k CKPT]
-                           [-e EPOCHS] [-b BATCH] [-t TSTEPS] [-p ESP] TLOC
-
-options:
-    -h, --help
-    -v, --verbose                   Be verbose.
-    -m MODEL, --model MODEL         Python .py file with MyHyperModel custom PL class definition.
-    -l VLOC, --vloc VLOC            Location of SonusAI mixture database to use for validation.
-    -w WEIGHTS, --weights WEIGHTS   Optional PL checkpoint file for initializing model weights.
-    -k CKPT, --ckpt CKPT            Optional PL checkpoint file for full resume of training.
-    -e EPOCHS, --epochs EPOCHS      Number of epochs to use in training. [default: 8].
-    -b BATCH, --batch BATCH         Batch size.
-    -t TSTEPS, --tsteps TSTEPS      Timesteps.
-    -p ESP, --patience ESP          Early stopping patience. [default: 12]
-    -g, --loss-batch-log            Enable per-batch loss log. [default: False]
-
-Train a PL (Pytorch Lightning) model defined in MODEL .py using Sonusai mixture data in TLOC.
-
-Inputs:
-    TLOC    A SonusAI mixture database directory to use for training data.
-    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
-
-"""
-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']
-    weights_name = args['--weights']
-    ckpt_name = args['--ckpt']
-    v_name = args['--vloc']
-    epochs = int(args['--epochs'])
-    batch_size = args['--batch']
-    timesteps = args['--tsteps']
-    esp = int(args['--patience'])
-    loss_batch_log = args['--loss-batch-log']
-    t_name = args['TLOC']
-
-    import warnings
-    from os import makedirs
-    from os.path import basename
-    from os.path import join
-    from os.path import splitext
-
-    # import keras_tuner as kt
-
-    with warnings.catch_warnings():
-        warnings.simplefilter('ignore')
-        # from keras import backend as kb
-        # from keras.callbacks import EarlyStopping
-
-    from sonusai import create_file_handler
-    from sonusai import initial_log_messages
-    from sonusai import update_console_handler
-    from sonusai.data_generator import TorchFromMixtureDatabase
-    # from sonusai.data_generator import KerasFromH5
-    from sonusai.mixture import MixtureDatabase
-    from sonusai.utils import create_ts_name
-    from sonusai.utils import import_keras_model
-    from lightning.pytorch import Trainer
-    from pytorch_lightning.loggers.csv_logs import CSVLogger
-    from lightning.pytorch.callbacks import ModelSummary
-    from lightning.pytorch.callbacks import ModelCheckpoint
-    from lightning.pytorch.callbacks import EarlyStopping
-    from lightning.pytorch.loggers import TensorBoardLogger
-
-    model_base = basename(model_name)
-    model_root = splitext(model_base)[0]
-
-    if batch_size is not None:
-        batch_size = int(batch_size)
-
-    if timesteps is not None:
-        timesteps = int(timesteps)
-
-    output_dir = create_ts_name(model_root)
-    makedirs(output_dir, exist_ok=True)
-    base_name = join(output_dir, model_root)
-
-    # Setup logging file
-    create_file_handler(join(output_dir, 'torchl_train.log'))
-    update_console_handler(verbose)
-    initial_log_messages('torchl_train')
-    logger.info('')
-
-    t_mixdb = MixtureDatabase(t_name)
-    logger.info(f'Training: found {t_mixdb.num_mixtures} mixtures with {t_mixdb.num_classes} classes from {t_name}')
-
-    v_mixdb = MixtureDatabase(v_name)
-    logger.info(f'Validation: found {v_mixdb.num_mixtures} mixtures with {v_mixdb.num_classes} classes from {v_name}')
-
-    # Import model definition file
-    logger.info(f'Importing {model_base}')
-    litemodel = import_keras_model(model_name)  # note works for PL as well as keras
-
-    # 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 and compiling model')
-    try:
-        model = litemodel.MyHyperModel(feature=t_mixdb.feature,
-                                       # num_classes=t_mixdb.num_classes,
-                                       timesteps=timesteps,
-                                       batch_size=batch_size)
-    except Exception as e:
-        logger.exception(f'Error: building {model_base} failed: {e}')
-        raise SystemExit(1)
-
-    logger.info('')
-    # built_model.summary(print_fn=logger.info)
-    # logger.info(model)
-    # logger.info((summary(model)))
-    # logger.info(summary(hypermodel, input_size=tuple(hypermodel.input_shape)))
-    logger.info('')
-    logger.info(f'feature       {model.hparams.feature}')
-    logger.info(f'batch_size    {model.hparams.batch_size}')
-    logger.info(f'timesteps     {model.hparams.timesteps}')
-    logger.info(f'num_classes   {model.num_classes}')
-    logger.info(f'flatten       {model.flatten}')
-    logger.info(f'add1ch        {model.add1ch}')
-    logger.info(f'input_shape   {model.input_shape}')
-    logger.info(f'truth_mutex   {model.truth_mutex}')
-    # logger.info(f'lossf         {hypermodel.lossf}')
-    # logger.info(f'optimizer     {hypermodel.configure_optimizers()}')
-    logger.info('')
-
-    t_mixid = t_mixdb.mixids_to_list()
-    v_mixid = v_mixdb.mixids_to_list()
-
-    # Use SonusAI DataGenerator to create validation feature/truth on the fly
-    sampler = None  # TBD how to stratify, also see stratified_shuffle_split_mixid(t_mixdb, vsplit=0)
-    t_datagen = TorchFromMixtureDatabase(mixdb=t_mixdb,
-                                         mixids=t_mixid,
-                                         batch_size=model.hparams.batch_size,
-                                         cut_len=model.hparams.timesteps,
-                                         flatten=model.flatten,
-                                         add1ch=model.add1ch,
-                                         random_cut=True,
-                                         sampler=sampler,
-                                         drop_last=True,
-                                         num_workers=4)
-
-    v_datagen = TorchFromMixtureDatabase(mixdb=v_mixdb,
-                                         mixids=v_mixid,
-                                         batch_size=1,
-                                         cut_len=0,
-                                         flatten=model.flatten,
-                                         add1ch=model.add1ch,
-                                         random_cut=False,
-                                         sampler=sampler,
-                                         drop_last=True,
-                                         num_workers=0)
-
-    csvl = CSVLogger(output_dir, name="logs", version="")
-    tbl = TensorBoardLogger(output_dir, "logs", "", log_graph=True, default_hp_metric=False)
-    es_cb = EarlyStopping(monitor="val_loss", min_delta=0.00, patience=esp, verbose=False, mode="min")
-    ckpt_topv = ModelCheckpoint(dirpath=output_dir + '/ckpt/', save_top_k=5, monitor="val_loss",
-                                mode="min", filename=model_root + "-{epoch:03d}-{val_loss:.3g}")
-    # lr_monitor = LearningRateMonitor(logging_interval="step")
-    ckpt_last = ModelCheckpoint(dirpath=output_dir + '/ckpt/', save_last=True)
-    # lr_monitor = LearningRateMonitor(logging_interval="step")
-    callbacks = [ModelSummary(max_depth=2), ckpt_topv, es_cb, ckpt_last]  # , lr_monitor]
-
-    profiler = None  # 'advanced'
-    if profiler == 'advanced':
-        from lightning.pytorch.profilers import AdvancedProfiler
-        profiler = AdvancedProfiler(dirpath=output_dir, filename="perf_logs")
-    else:
-        profiler = None
-
-    if weights_name is not None and ckpt_name is None:
-        logger.info(f'Loading weights from {weights_name}')
-        model = litemodel.MyHyperModel.load_from_checkpoint(weights_name,
-                                                            feature=t_mixdb.feature,
-                                                            # num_classes=t_mixdb.num_classes,
-                                                            timesteps=timesteps,
-                                                            batch_size=batch_size)
-
-    if ckpt_name is not None:
-        logger.info(f'Loading full checkpoint and resuming training from {ckpt_name}')
-        ckpt_path = ckpt_name
-    else:
-        ckpt_path = None
-
-    logger.info(f'  training mixtures    {len(t_mixid)}')
-    logger.info(f'  validation mixtures  {len(v_mixid)}')
-    logger.info(f'Starting training with early stopping patience = {esp} ...')
-    logger.info('')
-
-    trainer = Trainer(max_epochs=epochs,
-                      default_root_dir=output_dir,
-                      logger=[tbl, csvl],
-                      log_every_n_steps=10,
-                      profiler=profiler,
-                      # precision='16-mixed',
-                      # accelerator="cpu",
-                      # devices=4,
-                      callbacks=callbacks)
-    trainer.fit(model, t_datagen, v_datagen, ckpt_path=ckpt_path)
-
-
-if __name__ == '__main__':
-    try:
-        main()
-    except KeyboardInterrupt:
-        logger.info('Canceled due to keyboard interrupt')
-        exit()

sonusai/utils/asr_functions/aixplain_whisper.py

@@ -1,59 +0,0 @@
-from sonusai.utils import ASRResult
-from sonusai.utils.asr_functions.data import Data
-
-
-def aixplain_whisper(data: Data) -> ASRResult:
-    import tempfile
-    from os import getenv
-    from os.path import join
-
-    from aixplain.factories.model_factory import ModelFactory
-
-    from sonusai import SonusAIError
-    from sonusai.utils import ASRResult
-    from sonusai.utils import float_to_int16
-    from sonusai.utils import write_wav
-
-    whisper_model = data.whisper_model
-    if whisper_model is None:
-        envvar = 'AIXP_WHISPER_' + data.whisper_model_name.upper()
-        modelkey = getenv(envvar)
-        if modelkey is None:
-            raise SonusAIError(f'{envvar} environment variable does not exist')
-
-        whisper_model = ModelFactory.get(modelkey)
-
-    with tempfile.TemporaryDirectory() as tmp:
-        file = join(tmp, 'asr.wav')
-        write_wav(name=file, audio=float_to_int16(data.audio))
-
-        retry = 5
-        count = 0
-        while True:
-            try:
-                results = whisper_model.run(file)
-                return ASRResult(text=results['data'], confidence=results['confidence'])
-            except Exception as e:
-                count += 1
-                print(f'Warning: aiXplain exception: {e}')
-                if count >= retry:
-                    raise SonusAIError(f'Whisper exception: {e.args}')
-
-
-"""
-aiXplain Whisper results:
-{
-  'completed': True,
-  'data': 'The birch canoe slid on the smooth planks.',
-  'usedCredits': 3.194770833333333e-05,
-  'runTime': 114.029,
-  'confidence': None,
-  'details': [],
-  'rawData': {
-    'predictions': [
-      ' The birch canoe slid on the smooth planks.'
-    ]
-  },
-  'status': 'SUCCESS'
-}
-"""

sonusai/utils/asr_functions/data.py

@@ -1,16 +0,0 @@
-from dataclasses import dataclass
-from typing import Any
-from typing import Optional
-
-from sonusai.mixture.datatypes import AudioT
-
-
-@dataclass(frozen=True)
-class Data:
-    audio: AudioT
-    whisper_model: Optional[Any] = None
-    whisper_model_name: Optional[str] = None
-    device: Optional[str] = None
-    cpu_threads: Optional[int] = None
-    compute_type: Optional[str] = None
-    beam_size: Optional[int] = None

sonusai/utils/asr_functions/deepgram.py

@@ -1,97 +0,0 @@
-from sonusai.utils import ASRResult
-from sonusai.utils.asr_functions.data import Data
-
-
-def deepgram(data: Data) -> ASRResult:
-    import tempfile
-    from os import getenv
-    from os.path import join
-    from random import random
-    from time import sleep
-
-    import magic
-    from deepgram import Deepgram
-    from deepgram._types import BufferSource
-
-    from sonusai import SonusAIError
-    from sonusai.utils import float_to_int16
-    from sonusai.utils import write_wav
-
-    key = getenv('DEEPGRAM_API_KEY')
-    if key is None:
-        raise SonusAIError('DEEPGRAM_API_KEY environment variable does not exist')
-
-    client = Deepgram(key)
-    with tempfile.TemporaryDirectory() as tmp:
-        file = join(tmp, 'asr.wav')
-        write_wav(name=file, audio=float_to_int16(data.audio))
-
-        mimetype = magic.from_file(file, mime=True)
-        with open(file, 'rb') as audio:
-            source = BufferSource(buffer=audio, mimetype=mimetype)
-            retry = 5
-            count = 0
-            while True:
-                try:
-                    results = client.transcription.sync_prerecorded(source)['results']
-                    return ASRResult(text=results['channels'][0]['alternatives'][0]['transcript'],
-                                     confidence=results['channels'][0]['alternatives'][0]['confidence'])
-                except Exception as e:
-                    count += 1
-                    print(f'Warning: Deepgram exception: {e}')
-                    if count >= retry:
-                        raise SonusAIError(f'Deepgram exception: {e.args}')
-                    sleep(count * (1 + random()))
-
-
-"""
-Deepgram results:
-{'metadata': {'channels': 1,
-              'created': '2023-01-30T21:49:44.048Z',
-              'duration': 2.3795626,
-              'model_info': {'c12089d0-0766-4ca0-9511-98fd2e443ebd': {'name': 'general',
-                                                                      'tier': 'base',
-                                                                      'version': '2022-01-18.1'}},
-              'models': ['c12089d0-0766-4ca0-9511-98fd2e443ebd'],
-              'request_id': 'e1154979-07f7-46a3-89e6-d5d796676d31',
-              'sha256': '3cad2f30a83e351eab3c4dcaa2ec47185e8f2979c90abec0c2332a7eef7c2d40',
-              'transaction_key': 'deprecated'},
- 'results': {'channels': [{'alternatives': [{'confidence': 0.9794922,
-                                             'transcript': 'the birch can canoe slid on the smooth planks',
-                                             'words': [{'confidence': 0.9794922,
-                                                        'end': 0.29625,
-                                                        'start': 0.13825,
-                                                        'word': 'the'},
-                                                       {'confidence': 0.9902344,
-                                                        'end': 0.57275,
-                                                        'start': 0.29625,
-                                                        'word': 'birch'},
-                                                       {'confidence': 0.73535156,
-                                                        'end': 0.73074996,
-                                                        'start': 0.57275,
-                                                        'word': 'can'},
-                                                       {'confidence': 0.9550781,
-                                                        'end': 1.08625,
-                                                        'start': 0.73074996,
-                                                        'word': 'canoe'},
-                                                       {'confidence': 0.98876953,
-                                                        'end': 1.2442499,
-                                                        'start': 1.08625,
-                                                        'word': 'slid'},
-                                                       {'confidence': 0.9921875,
-                                                        'end': 1.3627499,
-                                                        'start': 1.2442499,
-                                                        'word': 'on'},
-                                                       {'confidence': 0.9584961,
-                                                        'end': 1.5997499,
-                                                        'start': 1.3627499,
-                                                        'word': 'the'},
-                                                       {'confidence': 0.9970703,
-                                                        'end': 1.9947499,
-                                                        'start': 1.5997499,
-                                                        'word': 'smooth'},
-                                                       {'confidence': 0.98828125,
-                                                        'end': 2.23175,
-                                                        'start': 1.9947499,
-                                                        'word': 'planks'}]}]}]}}
-"""

sonusai/utils/asr_functions/fastwhisper.py

@@ -1,90 +0,0 @@
-from sonusai.utils import ASRResult
-from sonusai.utils.asr_functions.data import Data
-
-
-def fastwhisper(data: Data) -> ASRResult:
-    from os import getpid
-    from timeit import default_timer as timer
-
-    from faster_whisper import WhisperModel
-
-    from sonusai import SonusAIError
-
-    whisper_model = data.whisper_model
-    pid = getpid()
-    # print(f'{pid}: Loading model ...')
-    retry = 2
-    count = 0
-    while True:
-        try:
-            # To pre-download model, first provide whisper_model_name without whisper_model (or =None)
-            if whisper_model is None:
-                model = WhisperModel(data.whisper_model_name,
-                                     device=data.device,
-                                     cpu_threads=data.cpu_threads,
-                                     compute_type=data.compute_type)
-            else:
-                model = WhisperModel(whisper_model,
-                                     device=data.device,
-                                     cpu_threads=data.cpu_threads,
-                                     compute_type=data.compute_type,
-                                     local_files_only=True)
-
-            # print(f'{pid}: Done Loading, now transcribing ...')
-            s_time = timer()
-            segments, info = model.transcribe(data.audio, beam_size=int(data.beam_size))
-            segments = list(segments)  # The transcription will actually run here.
-            e_time = timer()
-            elapsed = e_time - s_time
-            transcription = "".join(segment.text for segment in segments)
-            # print(f'{pid}: Done transcribing.')
-            tmp = ASRResult(text=transcription,
-                            lang=info.language,
-                            lang_prob=info.language_probability,
-                            duration=info.duration,
-                            num_segments=len(segments),
-                            asr_cpu_time=elapsed
-                            )
-            return tmp
-        except Exception as e:
-            count += 1
-            print(f'{pid}: Warning: fastwhisper exception: {e}')
-            if count >= retry:
-                raise SonusAIError(f'{pid}: Fastwhisper exception: {e.args}')
-
-
-"""
-Whisper results:
-{
-  'text': ' The birch canoe slid on the smooth planks.',
-  'segments': [
-    {
-      'id': 0,
-      'seek': 0,
-      'start': 0.0,
-      'end': 2.4,
-      'text': ' The birch canoe slid on the smooth planks.',
-      'tokens': [
-        50363,
-        383,
-        35122,
-        354,
-        47434,
-        27803,
-        319,
-        262,
-        7209,
-        1410,
-        591,
-        13,
-        50483
-      ],
-      'temperature': 0.0,
-      'avg_logprob': -0.4188103675842285,
-      'compression_ratio': 0.8571428571428571,
-      'no_speech_prob': 0.003438911633566022
-    }
-  ],
-  'language': 'en'
-}
-"""

sonusai/utils/asr_functions/google.py

@@ -1,95 +0,0 @@
-from sonusai.utils import ASRResult
-from sonusai.utils.asr_functions.data import Data
-
-
-def google(data: Data) -> ASRResult:
-    import tempfile
-    from os import getenv
-    from os.path import getsize
-    from os.path import join
-    from random import random
-    from time import sleep
-
-    import speech_recognition as sr
-
-    from sonusai import SonusAIError
-    from sonusai.utils import float_to_int16
-    from sonusai.utils import human_readable_size
-    from sonusai.utils import write_wav
-
-    key = getenv('GOOGLE_SPEECH_API_KEY')
-    if key is None:
-        raise SonusAIError('GOOGLE_SPEECH_API_KEY environment variable does not exist')
-
-    r = sr.Recognizer()
-    with tempfile.TemporaryDirectory() as tmp:
-        file = join(tmp, 'asr.wav')
-        write_wav(name=file, audio=float_to_int16(data.audio))
-        size = getsize(file)
-        if size > 10 * 1024 * 1024:
-            print(f'Warning: file size exceeds Google single request limit: {human_readable_size(size)} > 10 MB')
-
-        with sr.AudioFile(file) as source:
-            audio = r.record(source)
-
-        try:
-            retry = 5
-            count = 0
-            while True:
-                try:
-                    sleep(count * (1 + random()))
-                    results = r.recognize_google(audio, key=key, show_all=True)
-                    if not isinstance(results, dict) or len(results.get('alternative', [])) == 0:
-                        raise ValueError
-                    break
-                except ValueError:
-                    print(f'Warning: speech_recognition ValueError {count}\n{results}')
-                    count += 1
-                    if count >= retry:
-                        raise SonusAIError(f'speech_recognition exception: ValueError retry count exceeded.')
-
-            if 'confidence' in results['alternative']:
-                # return alternative with highest confidence score
-                best_hypothesis = max(results['alternative'], key=lambda alternative: alternative['confidence'])
-            else:
-                # when there is no confidence available, we arbitrarily choose the first hypothesis.
-                best_hypothesis = results['alternative'][0]
-            if "transcript" not in best_hypothesis:
-                raise SonusAIError('speech_recognition: UnknownValueError')
-            confidence = best_hypothesis.get('confidence', 0.5)
-            return ASRResult(text=best_hypothesis['transcript'], confidence=confidence)
-        except sr.UnknownValueError:
-            return ASRResult(text='', confidence=0)
-        except sr.RequestError as e:
-            raise SonusAIError(f'Could not request results from Google Speech Recognition service: {e}')
-
-
-"""
-Google results:
-{
-  "result": [
-    {
-      "alternative": [
-        {
-          "transcript": "the Birch canoe slid on the smooth planks",
-          "confidence": 0.94228178
-        },
-        {
-          "transcript": "the Burj canoe slid on the smooth planks"
-        },
-        {
-          "transcript": "the Birch canoe slid on the smooth plank"
-        },
-        {
-          "transcript": "the Birch canoe slit on the smooth planks"
-        },
-        {
-          "transcript": "the Birch canoes slid on the smooth planks"
-        }
-      ],
-      "final": true
-    }
-  ],
-  "result_index": 0
-}
-"""

sonusai/utils/asr_functions/whisper.py

@@ -1,49 +0,0 @@
-from sonusai.utils import ASRResult
-from sonusai.utils.asr_functions.data import Data
-
-
-def whisper(data: Data) -> ASRResult:
-    from whisper import load_model
-
-    whisper_model = data.whisper_model
-    if whisper_model is None:
-        whisper_model = load_model(data.whisper_model_name, device=data.device)
-
-    return ASRResult(text=whisper_model.transcribe(data.audio, fp16=False)['text'])
-
-
-"""
-Whisper results:
-{
-  'text': ' The birch canoe slid on the smooth planks.',
-  'segments': [
-    {
-      'id': 0,
-      'seek': 0,
-      'start': 0.0,
-      'end': 2.4,
-      'text': ' The birch canoe slid on the smooth planks.',
-      'tokens': [
-        50363,
-        383,
-        35122,
-        354,
-        47434,
-        27803,
-        319,
-        262,
-        7209,
-        1410,
-        591,
-        13,
-        50483
-      ],
-      'temperature': 0.0,
-      'avg_logprob': -0.4188103675842285,
-      'compression_ratio': 0.8571428571428571,
-      'no_speech_prob': 0.003438911633566022
-    }
-  ],
-  'language': 'en'
-}
-"""