sonusai 0.19.9__py3-none-any.whl → 0.19.10__py3-none-any.whl

sonusai/genft.py

@@ -109,7 +109,7 @@ def _genft_kernel(
             write_cached_data(mixdb.location, "mixture", mixdb.mixture(m_id).name, [("segsnr", segsnr)])
 
     if write:
-        write_mixture_metadata(mixdb, m_id)
+        write_mixture_metadata(mixdb, m_id=m_id)
 
     return result
 

sonusai/genmetrics.py

@@ -1,6 +1,6 @@
 """sonusai genmetrics
 
-usage: genmetrics [-hvsd] [-i MIXID] [-n INCLUDE] [-x EXCLUDE] LOC
+usage: genmetrics [-hvusd] [-i MIXID] [-n INCLUDE] [-x EXCLUDE] LOC
 
 options:
     -h, --help
@@ -8,6 +8,7 @@ options:
     -i MIXID, --mixid MIXID         Mixture ID(s) to generate. [default: *].
     -n INCLUDE, --include INCLUDE   Metrics to include. [default: all]
     -x EXCLUDE, --exclude EXCLUDE   Metrics to exclude. [default: none]
+    -u, --update                    Update metrics (do not regenerate existing metrics).
     -s, --supported                 Show list of supported metrics.
     -d, --dryrun                    Show list of metrics that will be generated and exit.
 
@@ -60,16 +61,15 @@ def signal_handler(_sig, _frame):
 signal.signal(signal.SIGINT, signal_handler)
 
 
-def _process_mixture(mixid: int, location: str, metrics: list[str]) -> None:
+def _process_mixture(mixid: int, location: str, metrics: list[str], update: bool = False) -> set[str]:
     from sonusai.mixture import MixtureDatabase
     from sonusai.mixture import write_cached_data
 
     mixdb = MixtureDatabase(location)
+    results = mixdb.mixture_metrics(m_id=mixid, metrics=metrics, force=not update)
+    write_cached_data(mixdb.location, "mixture", mixdb.mixture(mixid).name, list(results.items()))
 
-    values = mixdb.mixture_metrics(m_id=mixid, metrics=metrics, force=True)
-    write_data = list(zip(metrics, values, strict=False))
-
-    write_cached_data(mixdb.location, "mixture", mixdb.mixture(mixid).name, write_data)
+    return set(results.keys())
 
 
 def main() -> None:
@@ -85,6 +85,7 @@ def main() -> None:
     mixids = args["--mixid"]
     includes = {x.strip() for x in args["--include"].replace(" ", ",").lower().split(",") if x != ""}
     excludes = {x.strip() for x in args["--exclude"].replace(" ", ",").lower().split(",") if x != ""}
+    update = args["--update"]
     show_supported = args["--supported"]
     dryrun = args["--dryrun"]
     location = args["LOC"]
@@ -141,20 +142,14 @@ def main() -> None:
 
     requested = included_metrics - excluded_metrics
 
-    # Check for metrics dependencies and cache dependencies even if not explicitly requested.
-    dependencies: set[str] = set()
-    for metric in requested:
-        if metric.startswith("mxwer"):
-            dependencies.add("mxasr." + metric[6:])
-            dependencies.add("tasr." + metric[6:])
-
-    metrics = sorted(requested | dependencies)
+    metrics = sorted(requested)
 
     if len(metrics) == 0:
         logger.warning("No metrics were requested")
         sys.exit(1)
 
-    logger.info(f"Generating metrics: {', '.join(metrics)}")
+    logger.info("Generating metrics:")
+    logger.info(f"{', '.join(metrics)}")
     if dryrun:
         sys.exit(0)
 
@@ -163,14 +158,16 @@ def main() -> None:
     logger.info(f"Found {len(mixids):,} mixtures to process")
 
     progress = track(total=len(mixids), desc="genmetrics")
-    par_track(
-        partial(_process_mixture, location=location, metrics=metrics),
+    results = par_track(
+        partial(_process_mixture, location=location, metrics=metrics, update=update),
         mixids,
         progress=progress,
     )
     progress.close()
 
-    logger.info(f"Wrote metrics for {len(mixids)} mixtures to {location}")
+    written_metrics = sorted(set().union(*results))
+    logger.info(f"Wrote metrics for {len(mixids)} mixtures to {location}:")
+    logger.info(f"{', '.join(written_metrics)}")
     logger.info("")
 
     end_time = time.monotonic()

sonusai/genmix.py

@@ -139,7 +139,7 @@ def _genmix_kernel(
     result.mixture = mixture
     if write:
         write_cached_data(mixdb.location, "mixture", mixdb.mixture(m_id).name, [("mixture", mixture)])
-        write_mixture_metadata(mixdb, m_id)
+        write_mixture_metadata(mixdb, m_id=m_id)
 
     return result
 

sonusai/genmixdb.py

@@ -1,13 +1,11 @@
 """sonusai genmixdb
 
-usage: genmixdb [-hvmfsdjn] LOC
+usage: genmixdb [-hvmdjn] LOC
 
 options:
     -h, --help
     -v, --verbose   Be verbose.
     -m, --mix       ave mixture data. [default: False].
-    -f, --ft        Save feature/truth_f data. [default: False].
-    -s, --segsnr    Save segsnr data. [default: False].
     -d, --dryrun    Perform a dry run showing the processed config. [default: False].
     -j, --json      Save JSON version of database. [default: False].
     -n, --nopar     Do not run in parallel. [default: False].
@@ -116,6 +114,9 @@ will find all .wav files in the specified directories and process them as target
 
 import signal
 
+from sonusai.mixture import Mixture
+from sonusai.mixture import MixtureDatabase
+
 
 def signal_handler(_sig, _frame):
     import sys
@@ -132,8 +133,6 @@ signal.signal(signal.SIGINT, signal_handler)
 def genmixdb(
     location: str,
     save_mix: bool = False,
-    save_ft: bool = False,
-    save_segsnr: bool = False,
     logging: bool = True,
     show_progress: bool = False,
     test: bool = False,
@@ -151,6 +150,7 @@ def genmixdb(
     from sonusai.mixture import AugmentationRule
     from sonusai.mixture import MixtureDatabase
     from sonusai.mixture import balance_targets
+    from sonusai.mixture import generate_mixtures
     from sonusai.mixture import get_all_snrs_from_config
     from sonusai.mixture import get_augmentation_rules
     from sonusai.mixture import get_augmented_targets
@@ -316,8 +316,10 @@ def genmixdb(
             f"{seconds_to_hms(seconds=noise_audio_duration)}"
         )
 
-    used_noise_files, used_noise_samples = populate_mixture_table(
-        location=location,
+    if logging:
+        logger.info("Generating mixtures")
+
+    used_noise_files, used_noise_samples, mixtures = generate_mixtures(
         noise_mix_mode=mixdb.noise_mix_mode,
         augmented_targets=augmented_targets,
         target_files=target_files,
@@ -330,17 +332,16 @@ def genmixdb(
         num_classes=mixdb.num_classes,
         feature_step_samples=mixdb.feature_step_samples,
         num_ir=mixdb.num_impulse_response_files,
-        test=test,
     )
 
-    num_mixtures = len(mixdb.mixtures)
+    num_mixtures = len(mixtures)
     update_mixid_width(location, num_mixtures, test)
 
     if logging:
         logger.info("")
         logger.info(f"Found {num_mixtures:,} mixtures to process")
 
-    total_duration = float(sum([mixture.samples for mixture in mixdb.mixtures])) / SAMPLE_RATE
+    total_duration = float(sum([mixture.samples for mixture in mixtures])) / SAMPLE_RATE
 
     if logging:
         log_duration_and_sizes(
@@ -362,23 +363,29 @@ def genmixdb(
 
     # Fill in the details
     if logging:
-        logger.info("Generating mixtures")
+        logger.info("Processing mixtures")
     progress = track(total=num_mixtures, disable=not show_progress)
-    par_track(
+    mixtures = par_track(
         partial(
             _process_mixture,
             location=location,
             save_mix=save_mix,
-            save_ft=save_ft,
-            save_segsnr=save_segsnr,
             test=test,
         ),
-        range(num_mixtures),
+        mixtures,
         progress=progress,
         no_par=no_par,
     )
     progress.close()
 
+    populate_mixture_table(
+        location=location,
+        mixtures=mixtures,
+        test=test,
+        logging=logging,
+        show_progress=show_progress,
+    )
+
     total_noise_files = len(noise_files)
 
     total_samples = mixdb.total_samples()
@@ -409,32 +416,23 @@ def genmixdb(
 
 
 def _process_mixture(
-    m_id: int,
+    mixture: Mixture,
     location: str,
     save_mix: bool,
-    save_ft: bool,
-    save_segsnr: bool,
     test: bool,
-) -> None:
+) -> Mixture:
     from functools import partial
 
-    from sonusai.mixture import MixtureDatabase
-    from sonusai.mixture import clear_cached_data
-    from sonusai.mixture import update_mixture_table
+    from sonusai.mixture import update_mixture
     from sonusai.mixture import write_cached_data
     from sonusai.mixture import write_mixture_metadata
 
-    with_data = save_mix or save_ft or save_segsnr
-
-    genmix_data = update_mixture_table(location, m_id, with_data, test)
-
-    mixdb = MixtureDatabase(location, test)
-    mixture = mixdb.mixture(m_id)
+    mixdb = MixtureDatabase(location, test=test)
+    mixture, genmix_data = update_mixture(mixdb, mixture, save_mix)
 
     write = partial(write_cached_data, location=location, name="mixture", index=mixture.name)
-    clear = partial(clear_cached_data, location=location, name="mixture", index=mixture.name)
 
-    if with_data:
+    if save_mix:
         write(
             items=[
                 ("targets", genmix_data.targets),
@@ -444,25 +442,9 @@ def _process_mixture(
             ]
         )
 
-        if save_ft:
-            clear(items=["feature", "truth_f"])
-            feature, truth_f = mixdb.mixture_ft(m_id)
-            write(
-                items=[
-                    ("feature", feature),
-                    ("truth_f", truth_f),
-                ]
-            )
-
-        if save_segsnr:
-            clear(items=["segsnr"])
-            segsnr = mixdb.mixture_segsnr(m_id)
-            write(items=[("segsnr", segsnr)])
-
-        if not save_mix:
-            clear(items=["targets", "target", "noise", "mixture"])
+        write_mixture_metadata(mixdb, mixture=mixture)
 
-        write_mixture_metadata(mixdb, m_id)
+    return mixture
 
 
 def main() -> None:
@@ -491,8 +473,6 @@ def main() -> None:
 
     verbose = args["--verbose"]
     save_mix = args["--mix"]
-    save_ft = args["--ft"]
-    save_segsnr = args["--segsnr"]
     dryrun = args["--dryrun"]
     save_json = args["--json"]
     no_par = args["--nopar"]
@@ -522,8 +502,6 @@ def main() -> None:
         genmixdb(
             location=location,
             save_mix=save_mix,
-            save_ft=save_ft,
-            save_segsnr=save_segsnr,
             show_progress=True,
             save_json=save_json,
             no_par=no_par,

sonusai/metrics_summary.py

@@ -0,0 +1,320 @@
+"""sonusai metrics_summary
+
+usage: lsdb [-vlh] [-i MIXID] [-n NCPU] LOCATION
+
+Options:
+    -h, --help
+    -v, --verbose
+    -l, --write-list            Write .csv file list of all mixture metrics
+    -i MIXID, --mixid MIXID     Mixture ID(s) to analyze. [default: *].
+    -n, --num_process NCPU      Number of parallel processes to use [default: auto]
+
+Summarize mixture metrics across a SonusAI mixture database where metrics have been generated by SonusAI genmetrics.
+
+Inputs:
+    LOCATION     A SonusAI mixture database directory with mixdb.db and pre-generated metrics from SonusAI genmetrics.
+
+"""
+
+import signal
+
+import numpy as np
+import pandas as pd
+
+
+def signal_handler(_sig, _frame):
+    import sys
+
+    from sonusai import logger
+
+    logger.info("Canceled due to keyboard interrupt")
+    sys.exit(1)
+
+
+signal.signal(signal.SIGINT, signal_handler)
+
+DB_99 = np.power(10, 99 / 10)
+DB_N99 = np.power(10, -99 / 10)
+
+
+def _process_mixture(
+    m_id: int,
+    location: str,
+    all_metric_names: list[str],
+    scalar_metric_names: list[str],
+    string_metric_names: list[str],
+    frame_metric_names: list[str],
+    bin_metric_names: list[str],
+    ptab_labels: list[str],
+) -> tuple[pd.DataFrame, pd.DataFrame]:
+    from os.path import basename
+
+    from sonusai.metrics import calc_wer
+    from sonusai.mixture import SAMPLE_RATE
+    from sonusai.mixture import MixtureDatabase
+
+    mixdb = MixtureDatabase(location)
+
+    # Process mixture
+    # for mixid in mixids:
+    samples = mixdb.mixture(m_id).samples
+    duration = samples / SAMPLE_RATE
+    tf_frames = mixdb.mixture_transform_frames(m_id)
+    feat_frames = mixdb.mixture_feature_frames(m_id)
+    mxsnr = mixdb.mixture(m_id).snr
+    ti = mixdb.mixture(m_id).targets[0].file_id
+    ni = mixdb.mixture(m_id).noise.file_id
+    t0file = basename(mixdb.target_file(ti).name)
+    nfile = basename(mixdb.noise_file(ni).name)
+
+    all_metrics = mixdb.mixture_metrics(m_id, all_metric_names)
+
+    # replace lists with first value (ignore mixup)
+    scalar_metrics = {
+        key: all_metrics[key][0] if isinstance(all_metrics[key], list) else all_metrics[key]
+        for key in scalar_metric_names
+    }
+    string_metrics = {
+        key: all_metrics[key][0] if isinstance(all_metrics[key], list) else all_metrics[key]
+        for key in string_metric_names
+    }
+
+    # Convert strings into word count
+    for key in string_metrics:
+        string_metrics[key] = calc_wer(string_metrics[key], string_metrics[key]).words
+
+    # Collect pandas table values note: must match given ptab_labels
+    ptab_data: list = [
+        mxsnr,
+        *scalar_metrics.values(),
+        *string_metrics.values(),
+        tf_frames,
+        duration,
+        t0file,
+        nfile,
+    ]
+
+    ptab1 = pd.DataFrame([ptab_data], columns=ptab_labels, index=[m_id])
+
+    # TODO: collect frame metrics and bin metrics
+
+    return ptab1, ptab1
+
+
+def main() -> None:
+    from docopt import docopt
+
+    from sonusai import __version__ as sonusai_ver
+    from sonusai.utils import trim_docstring
+
+    args = docopt(trim_docstring(__doc__), version=sonusai_ver, options_first=True)
+
+    verbose = args["--verbose"]
+    wrlist = args["--write-list"]
+    mixids = args["--mixid"]
+    location = args["LOCATION"]
+    num_proc = args["--num_process"]
+
+    from functools import partial
+    from os.path import basename
+    from os.path import join
+
+    import psutil
+
+    from sonusai import create_file_handler
+    from sonusai import initial_log_messages
+    from sonusai import logger
+    from sonusai import update_console_handler
+    from sonusai.mixture import MixtureDatabase
+    from sonusai.utils import create_timestamp
+    from sonusai.utils import par_track
+    from sonusai.utils import track
+
+    try:
+        mixdb = MixtureDatabase(location)
+        print(f"Found SonusAI mixture database with {mixdb.num_mixtures} mixtures.")
+    except:
+        print(f"Could not open SonusAI mixture database in {location}, exiting ...")
+        return
+
+    metrics_present = mixdb.cached_metrics()
+    num_metrics_present = len(metrics_present)
+    if num_metrics_present < 1:
+        print(f"mixdb reports no pre-generated metrics are present. Nothing to summarize in {location}, exiting ...")
+        return
+
+    # Setup logging file
+    timestamp = create_timestamp()  # string good for embedding into filenames
+    mixdb_fname = basename(location)
+    if verbose:
+        create_file_handler(join(location, "metrics_summary.log"))
+        update_console_handler(verbose)
+        initial_log_messages("metrics_summary")
+        logger.info(f"Logging summary of SonusAI mixture db at {location}")
+    else:
+        update_console_handler(verbose)
+
+    logger.info("")
+    mixids = mixdb.mixids_to_list(mixids)
+    if len(mixids) < mixdb.num_mixtures:
+        logger.info(
+            f"Processing a subset of {len(mixids)} out of total mixdb mixtures of {mixdb.num_mixtures}, "
+            f"summary results will not include entire dataset."
+        )
+        fsuffix = f"_s{len(mixids)}t{mixdb.num_mixtures}"
+    else:
+        logger.info(
+            f"Summarizing SonusAI mixture db with {mixdb.num_mixtures} mixtures "
+            f"and {num_metrics_present} pre-generated metrics ..."
+        )
+        fsuffix = ""
+
+    metric_sup = mixdb.supported_metrics
+    ft_bins = mixdb.ft_config.bin_end - mixdb.ft_config.bin_start + 1  # bins of forward transform
+    # Pre-process first mixid to gather metrics into 4 types: scalar, str (scalar word cnt), frame-array, bin-array
+    # Collect list of indices for each
+    scalar_metric_names: list[str] = []
+    string_metric_names: list[str] = []
+    frame_metric_names: list[str] = []
+    bin_metric_names: list[str] = []
+    all_metrics = mixdb.mixture_metrics(mixids[0], metrics_present)
+    tf_frames = mixdb.mixture_transform_frames(mixids[0])
+    for metric in metrics_present:
+        metval = all_metrics[metric]  # get metric value
+        logger.debug(f"First mixid {mixids[0]} metric {metric} = {metval}")
+        if isinstance(metval, list):
+            if len(metval) > 1:
+                logger.warning(f"Mixid {mixids[0]} metric {metric} has a list with more than 1 element, using first.")
+            metval = metval[0]  # remove any list
+        if isinstance(metval, float):
+            logger.debug("Metric is scalar float, entering in summary table.")
+            scalar_metric_names.append(metric)
+        elif isinstance(metval, str):
+            logger.debug("Metric is string, will summarize with word count.")
+            string_metric_names.append(metric)
+        elif isinstance(metval, np.ndarray):
+            if metval.ndim == 1:
+                if metval.size == tf_frames:
+                    logger.debug("Metric is frames vector.")
+                    frame_metric_names.append(metric)
+                elif metval.size == ft_bins:
+                    logger.debug("Metric is bins vector.")
+                    bin_metric_names.append(metric)
+                else:
+                    logger.warning(f"Mixid {mixids[0]} metric {metric} is a vector of improper size, ignoring.")
+
+    # Setup pandas table for summarizing scalar metrics
+    ptab_labels = [
+        "mxsnr",
+        *scalar_metric_names,
+        *string_metric_names,
+        "fcnt",
+        "duration",
+        "t0file",
+        "nfile",
+    ]
+
+    num_cpu = psutil.cpu_count()
+    cpu_percent = psutil.cpu_percent(interval=1)
+    logger.info("")
+    logger.info(f"#CPUs: {num_cpu}, current CPU utilization: {cpu_percent}%")
+    logger.info(f"Memory utilization: {psutil.virtual_memory().percent}%")
+    if num_proc == "auto":
+        use_cpu = int(num_cpu * (0.9 - cpu_percent / 100))  # default use 80% of available cpus
+    elif num_proc == "None":
+        use_cpu = None
+    else:
+        use_cpu = min(max(int(num_proc), 1), num_cpu)
+
+    logger.info(f"Summarizing metrics for {len(mixids)} mixtures using {use_cpu} parallel processes")
+
+    # progress = tqdm(total=len(mixids), desc='calc_metric_spenh', mininterval=1)
+    progress = track(total=len(mixids))
+    if use_cpu is None:
+        no_par = True
+        num_cpus = None
+    else:
+        no_par = False
+        num_cpus = use_cpu
+
+    all_metrics_tables = par_track(
+        partial(
+            _process_mixture,
+            location=location,
+            all_metric_names=metrics_present,
+            scalar_metric_names=scalar_metric_names,
+            string_metric_names=string_metric_names,
+            frame_metric_names=frame_metric_names,
+            bin_metric_names=bin_metric_names,
+            ptab_labels=ptab_labels,
+        ),
+        mixids,
+        progress=progress,
+        num_cpus=num_cpus,
+        no_par=no_par,
+    )
+    progress.close()
+
+    # Done with mixtures, write out summary metrics
+    header_args = {
+        "mode": "a",
+        "encoding": "utf-8",
+        "index": False,
+        "header": False,
+    }
+    table_args = {
+        "mode": "a",
+        "encoding": "utf-8",
+    }
+    ptab1 = pd.concat([item[0] for item in all_metrics_tables])
+    if wrlist:
+        wlcsv_name = str(join(location, "metric_summary_list" + fsuffix + ".csv"))
+        pd.DataFrame([["Timestamp", timestamp]]).to_csv(wlcsv_name, header=False, index=False)
+        pd.DataFrame([f"Metric list for {mixdb_fname}:"]).to_csv(wlcsv_name, mode="a", header=False, index=False)
+        ptab1.round(2).to_csv(wlcsv_name, **table_args)
+    ptab1_sorted = ptab1.sort_values(by=["mxsnr", "t0file"])
+
+    # Create metrics table except except -99 SNR
+    ptab1_nom99 = ptab1_sorted[ptab1_sorted.mxsnr != -99]
+
+    # Create summary by SNR for all scalar metrics, taking mean
+    mtab_snr_summary = None
+    for snri in range(0, len(mixdb.snrs)):
+        tmp = ptab1_sorted.query("mxsnr==" + str(mixdb.snrs[snri])).mean(numeric_only=True).to_frame().T
+        # avoid nan when subset of mixids specified (i.e. no mixtures exist for an SNR)
+        if ~np.isnan(tmp.iloc[0].to_numpy()[0]).any():
+            mtab_snr_summary = pd.concat([mtab_snr_summary, tmp])
+    mtab_snr_summary = mtab_snr_summary.sort_values(by=["mxsnr"], ascending=False)
+
+    # Write summary to .csv
+    snrcsv_name = str(join(location, "metric_summary_snr" + fsuffix + ".csv"))
+    nmix = len(mixids)
+    nmixtot = mixdb.num_mixtures
+    pd.DataFrame([["Timestamp", timestamp]]).to_csv(snrcsv_name, header=False, index=False)
+    pd.DataFrame(['"Metrics avg over each SNR:"']).to_csv(snrcsv_name, **header_args)
+    mtab_snr_summary.round(2).to_csv(snrcsv_name, index=False, **table_args)
+    pd.DataFrame(["--"]).to_csv(snrcsv_name, header=False, index=False, mode="a")
+    pd.DataFrame([f'"Metrics stats over {nmix} mixtures out of {nmixtot} total:"']).to_csv(snrcsv_name, **header_args)
+    ptab1.describe().round(2).T.to_csv(snrcsv_name, index=True, **table_args)
+    pd.DataFrame(["--"]).to_csv(snrcsv_name, header=False, index=False, mode="a")
+    pd.DataFrame([f'"Metrics stats over {len(ptab1_nom99)} non -99db mixtures out of {nmixtot} total:"']).to_csv(
+        snrcsv_name, **header_args
+    )
+    ptab1_nom99.describe().round(2).T.to_csv(snrcsv_name, index=True, **table_args)
+
+    # Write summary to .csv
+    snrtxt_name = str(join(location, "metric_summary_snr" + fsuffix + ".txt"))
+    with open(snrtxt_name, "w") as f:
+        print(f"Timestamp: {timestamp}", file=f)
+        print("Metrics avg over each SNR:", file=f)
+        print(mtab_snr_summary.round(2).to_string(float_format=lambda x: f"{x:.2f}", index=False), file=f)
+        print("", file=f)
+        print(f"Metrics stats over {len(mixids)} mixtures out of {mixdb.num_mixtures} total:", file=f)
+        print(ptab1.describe().round(2).T.to_string(float_format=lambda x: f"{x:.2f}", index=True), file=f)
+        print("", file=f)
+        print(f"Metrics stats over {len(ptab1_nom99)} non -99db mixtures out of {mixdb.num_mixtures} total:", file=f)
+        print(ptab1_nom99.describe().round(2).T.to_string(float_format=lambda x: f"{x:.2f}", index=True), file=f)
+
+
+if __name__ == "__main__":
+    main()

sonusai/mixture/__init__.py

@@ -87,6 +87,7 @@ from .datatypes import TruthParameter
 from .datatypes import UniversalSNR
 from .feature import get_audio_from_feature
 from .feature import get_feature_from_audio
+from .generation import generate_mixtures
 from .generation import get_all_snrs_from_config
 from .generation import initialize_db
 from .generation import populate_class_label_table
@@ -99,7 +100,7 @@ from .generation import populate_target_file_table
 from .generation import populate_top_table
 from .generation import populate_truth_parameters_table
 from .generation import update_mixid_width
-from .generation import update_mixture_table
+from .generation import update_mixture
 from .helpers import augmented_noise_samples
 from .helpers import augmented_target_samples
 from .helpers import check_audio_files_exist