sonusai 0.17.0__py3-none-any.whl → 0.17.3__py3-none-any.whl

sonusai/calc_metric_spenh-save.py

@@ -1,1334 +0,0 @@
-"""sonusai calc_metric_spenh
-
-usage: calc_metric_spenh [-hvtpws] [-i MIXID] [-e WER] [-m WMNAME] PLOC TLOC
-
-options:
-    -h, --help
-    -v, --verbose               Be verbose.
-    -i MIXID, --mixid MIXID     Mixture ID(s) to process, can be range like 0:maxmix+1 [default: *].
-    -t, --truth-est-mode        Calculate extraction and metrics using truth (instead of prediction).
-    -p, --plot                  Enable PDF plots file generation per mixture.
-    -w, --wav                   Generate WAV files per mixture.
-    -s, --summary               Enable summary files generation.
-    -e WER, --wer-method WER    Word-Error-Rate method: deepgram, google, aixplain_whisper
-                                or whisper (locally run) [default: none]
-    -m WMNAME, --whisper-model  Whisper model name used in aixplain_whisper and whisper WER methods.
-                                [default: tiny]
-
-Calculate speech enhancement metrics of prediction data in PLOC using SonusAI mixture data
-in TLOC as truth/label reference. Metric and extraction data files are written into PLOC.
-
-PLOC  directory containing prediction data in .h5 files created from truth/label mixture data in TLOC
-TLOC  directory with SonusAI mixture database of truth/label mixture data
-
-For whisper WER methods, the possible models used in local processing (WER = whisper) are:
-    {tiny.en,tiny,base.en,base,small.en,small,medium.en,medium,large-v1,large-v2,large}
-but note most are very computationally demanding and can overwhelm/hang a local system.
-
-Outputs the following to PLOC (where id is mixd number 0:num_mixtures):
-    <id>_metric_spenh.txt
-
-    If --plot:
-        <id>_metric_spenh.pdf
-
-    If --wav:
-        <id>_target.wav
-        <id>_target_est.wav
-        <id>_noise.wav
-        <id>_noise_est.wav
-        <id>_mixture.wav
-
-        If --truth-est-mode:
-            <id>_target_truth_est.wav
-            <id>_noise_truth_est.wav
-
-    If --summary:
-        metric_spenh_targetf_summary.txt
-        metric_spenh_targetf_summary.csv
-        metric_spenh_targetf_list.csv
-        metric_spenh_targetf_estats_list.csv
-
-        If --truth-est-mode:
-            metric_spenh_targetf_truth_list.csv
-            metric_spenh_targetf_estats_truth_list.csv
-
-TBD
-Metric and extraction data are written into prediction location PLOC as separate files per mixture.
-
-    -d PLOC, --ploc PLOC        Location of SonusAI predict data.
-
-Inputs:
-
-"""
-from dataclasses import dataclass
-from typing import Optional
-
-import matplotlib
-import matplotlib.pyplot as plt
-import numpy as np
-import pandas as pd
-
-from sonusai import logger
-from sonusai.mixture import AudioF
-from sonusai.mixture import AudioT
-from sonusai.mixture import Feature
-from sonusai.mixture import MixtureDatabase
-from sonusai.mixture import Predict
-
-matplotlib.use('SVG')
-
-
-@dataclass
-class MPGlobal:
-    mixdb: MixtureDatabase = None
-    predict_location: str = None
-    predwav_mode: bool = None
-    truth_est_mode: bool = None
-    enable_plot: bool = None
-    enable_wav: bool = None
-    wer_method: str = None
-    whisper_model: str = None
-
-
-MP_GLOBAL = MPGlobal()
-
-
-def power_compress(spec):
-    mag = np.abs(spec)
-    phase = np.angle(spec)
-    mag = mag ** 0.3
-    real_compress = mag * np.cos(phase)
-    imag_compress = mag * np.sin(phase)
-    return real_compress + 1j * imag_compress
-
-
-def power_uncompress(spec):
-    mag = np.abs(spec)
-    phase = np.angle(spec)
-    mag = mag ** (1. / 0.3)
-    real_uncompress = mag * np.cos(phase)
-    imag_uncompress = mag * np.sin(phase)
-    return real_uncompress + 1j * imag_uncompress
-
-
-def snr(clean_speech, processed_speech, sample_rate):
-    # Check the length of the clean and processed speech. Must be the same.
-    clean_length = len(clean_speech)
-    processed_length = len(processed_speech)
-    if clean_length != processed_length:
-        raise ValueError('Both Speech Files must be same length.')
-
-    overall_snr = 10 * np.log10(np.sum(np.square(clean_speech)) / np.sum(np.square(clean_speech - processed_speech)))
-
-    # Global Variables
-    winlength = round(30 * sample_rate / 1000)  # window length in samples
-    skiprate = int(np.floor(winlength / 4))  # window skip in samples
-    MIN_SNR = -10  # minimum SNR in dB
-    MAX_SNR = 35  # maximum SNR in dB
-
-    # For each frame of input speech, calculate the Segmental SNR
-    num_frames = int(clean_length / skiprate - (winlength / skiprate))  # number of frames
-    start = 0  # starting sample
-    window = 0.5 * (1 - np.cos(2 * np.pi * np.arange(1, winlength + 1) / (winlength + 1)))
-
-    segmental_snr = np.empty(num_frames)
-    EPS = np.spacing(1)
-    for frame_count in range(num_frames):
-        # (1) Get the Frames for the test and reference speech. Multiply by Hanning Window.
-        clean_frame = clean_speech[start:start + winlength]
-        processed_frame = processed_speech[start:start + winlength]
-        clean_frame = np.multiply(clean_frame, window)
-        processed_frame = np.multiply(processed_frame, window)
-
-        # (2) Compute the Segmental SNR
-        signal_energy = np.sum(np.square(clean_frame))
-        noise_energy = np.sum(np.square(clean_frame - processed_frame))
-        segmental_snr[frame_count] = 10 * np.log10(signal_energy / (noise_energy + EPS) + EPS)
-        segmental_snr[frame_count] = max(segmental_snr[frame_count], MIN_SNR)
-        segmental_snr[frame_count] = min(segmental_snr[frame_count], MAX_SNR)
-
-        start = start + skiprate
-
-    return overall_snr, segmental_snr
-
-
-def lpcoeff(speech_frame, model_order):
-    # (1) Compute Autocorrelation Lags
-    winlength = np.size(speech_frame)
-    R = np.empty(model_order + 1)
-    E = np.empty(model_order + 1)
-    for k in range(model_order + 1):
-        R[k] = np.dot(speech_frame[0:winlength - k], speech_frame[k: winlength])
-
-    # (2) Levinson-Durbin
-    a = np.ones(model_order)
-    a_past = np.empty(model_order)
-    rcoeff = np.empty(model_order)
-    E[0] = R[0]
-    for i in range(model_order):
-        a_past[0: i] = a[0: i]
-        sum_term = np.dot(a_past[0: i], R[i:0:-1])
-        rcoeff[i] = (R[i + 1] - sum_term) / E[i]
-        a[i] = rcoeff[i]
-        if i == 0:
-            a[0: i] = a_past[0: i] - np.multiply(a_past[i - 1:-1:-1], rcoeff[i])
-        else:
-            a[0: i] = a_past[0: i] - np.multiply(a_past[i - 1::-1], rcoeff[i])
-        E[i + 1] = (1 - rcoeff[i] * rcoeff[i]) * E[i]
-    acorr = R
-    refcoeff = rcoeff
-    lpparams = np.concatenate((np.array([1]), -a))
-    return acorr, refcoeff, lpparams
-
-
-def llr(clean_speech, processed_speech, sample_rate):
-    from scipy.linalg import toeplitz
-
-    # Check the length of the clean and processed speech.  Must be the same.
-    clean_length = np.size(clean_speech)
-    processed_length = np.size(processed_speech)
-    if clean_length != processed_length:
-        raise ValueError('Both Speech Files must be same length.')
-
-    # Global Variables
-    winlength = (np.round(30 * sample_rate / 1000)).astype(int)  # window length in samples
-    skiprate = (np.floor(winlength / 4)).astype(int)  # window skip in samples
-    if sample_rate < 10000:
-        P = 10  # LPC Analysis Order
-    else:
-        P = 16  # this could vary depending on sampling frequency.
-
-    # For each frame of input speech, calculate the Log Likelihood Ratio
-    num_frames = int((clean_length - winlength) / skiprate)  # number of frames
-    start = 0  # starting sample
-    window = 0.5 * (1 - np.cos(2 * np.pi * np.arange(1, winlength + 1) / (winlength + 1)))
-
-    distortion = np.empty(num_frames)
-    for frame_count in range(num_frames):
-        # (1) Get the Frames for the test and reference speech. Multiply by Hanning Window.
-        clean_frame = clean_speech[start: start + winlength]
-        processed_frame = processed_speech[start: start + winlength]
-        clean_frame = np.multiply(clean_frame, window)
-        processed_frame = np.multiply(processed_frame, window)
-
-        # (2) Get the autocorrelation lags and LPC parameters used to compute the LLR measure.
-        R_clean, Ref_clean, A_clean = lpcoeff(clean_frame, P)
-        R_processed, Ref_processed, A_processed = lpcoeff(processed_frame, P)
-
-        # (3) Compute the LLR measure
-        numerator = np.dot(np.matmul(A_processed, toeplitz(R_clean)), A_processed)
-        denominator = np.dot(np.matmul(A_clean, toeplitz(R_clean)), A_clean)
-        distortion[frame_count] = np.log(numerator / denominator)
-        start = start + skiprate
-    return distortion
-
-
-def wss(clean_speech, processed_speech, sample_rate):
-    from scipy.fftpack import fft
-
-    # Check the length of the clean and processed speech, which must be the same.
-    clean_length = np.size(clean_speech)
-    processed_length = np.size(processed_speech)
-    if clean_length != processed_length:
-        raise ValueError('Files must have same length.')
-
-    # Global variables
-    winlength = (np.round(30 * sample_rate / 1000)).astype(int)  # window length in samples
-    skiprate = (np.floor(np.divide(winlength, 4))).astype(int)  # window skip in samples
-    max_freq = (np.divide(sample_rate, 2)).astype(int)  # maximum bandwidth
-    num_crit = 25  # number of critical bands
-
-    USE_FFT_SPECTRUM = 1  # defaults to 10th order LP spectrum
-    n_fft = (np.power(2, np.ceil(np.log2(2 * winlength)))).astype(int)
-    n_fftby2 = (np.multiply(0.5, n_fft)).astype(int)  # FFT size/2
-    Kmax = 20.0  # value suggested by Klatt, pg 1280
-    Klocmax = 1.0  # value suggested by Klatt, pg 1280
-
-    # Critical Band Filter Definitions (Center Frequency and Bandwidths in Hz)
-    cent_freq = np.array([50.0000, 120.000, 190.000, 260.000, 330.000, 400.000, 470.000,
-                          540.000, 617.372, 703.378, 798.717, 904.128, 1020.38, 1148.30,
-                          1288.72, 1442.54, 1610.70, 1794.16, 1993.93, 2211.08, 2446.71,
-                          2701.97, 2978.04, 3276.17, 3597.63])
-    bandwidth = np.array([70.0000, 70.0000, 70.0000, 70.0000, 70.0000, 70.0000, 70.0000,
-                          77.3724, 86.0056, 95.3398, 105.411, 116.256, 127.914, 140.423,
-                          153.823, 168.154, 183.457, 199.776, 217.153, 235.631, 255.255,
-                          276.072, 298.126, 321.465, 346.136])
-
-    bw_min = bandwidth[0]  # minimum critical bandwidth
-
-    # Set up the critical band filters.
-    # Note here that Gaussianly shaped filters are used.
-    # Also, the sum of the filter weights are equivalent for each critical band filter.
-    # Filter less than -30 dB and set to zero.
-    min_factor = np.exp(-30.0 / (2.0 * 2.303))  # -30 dB point of filter
-    crit_filter = np.empty((num_crit, n_fftby2))
-    for i in range(num_crit):
-        f0 = (cent_freq[i] / max_freq) * n_fftby2
-        bw = (bandwidth[i] / max_freq) * n_fftby2
-        norm_factor = np.log(bw_min) - np.log(bandwidth[i])
-        j = np.arange(n_fftby2)
-        crit_filter[i, :] = np.exp(-11 * np.square(np.divide(j - np.floor(f0), bw)) + norm_factor)
-        cond = np.greater(crit_filter[i, :], min_factor)
-        crit_filter[i, :] = np.where(cond, crit_filter[i, :], 0)
-    # For each frame of input speech, calculate the Weighted Spectral Slope Measure
-    num_frames = int(clean_length / skiprate - (winlength / skiprate))  # number of frames
-    start = 0  # starting sample
-    window = 0.5 * (1 - np.cos(2 * np.pi * np.arange(1, winlength + 1) / (winlength + 1)))
-
-    distortion = np.empty(num_frames)
-    for frame_count in range(num_frames):
-        # (1) Get the Frames for the test and reference speech. Multiply by Hanning Window.
-        clean_frame = clean_speech[start: start + winlength] / 32768
-        processed_frame = processed_speech[start: start + winlength] / 32768
-        clean_frame = np.multiply(clean_frame, window)
-        processed_frame = np.multiply(processed_frame, window)
-        # (2) Compute the Power Spectrum of Clean and Processed
-        # if USE_FFT_SPECTRUM:
-        clean_spec = np.square(np.abs(fft(clean_frame, n_fft)))
-        processed_spec = np.square(np.abs(fft(processed_frame, n_fft)))
-
-        # (3) Compute Filterbank Output Energies (in dB scale)
-        clean_energy = np.matmul(crit_filter, clean_spec[0:n_fftby2])
-        processed_energy = np.matmul(crit_filter, processed_spec[0:n_fftby2])
-
-        clean_energy = 10 * np.log10(np.maximum(clean_energy, 1E-10))
-        processed_energy = 10 * np.log10(np.maximum(processed_energy, 1E-10))
-
-        # (4) Compute Spectral Slope (dB[i+1]-dB[i])
-        clean_slope = clean_energy[1:num_crit] - clean_energy[0: num_crit - 1]
-        processed_slope = processed_energy[1:num_crit] - processed_energy[0: num_crit - 1]
-
-        # (5) Find the nearest peak locations in the spectra to each critical band.
-        #     If the slope is negative, we search to the left. If positive, we search to the right.
-        clean_loc_peak = np.empty(num_crit - 1)
-        processed_loc_peak = np.empty(num_crit - 1)
-
-        for i in range(num_crit - 1):
-            # find the peaks in the clean speech signal
-            if clean_slope[i] > 0:  # search to the right
-                n = i
-                while (n < num_crit - 1) and (clean_slope[n] > 0):
-                    n = n + 1
-                clean_loc_peak[i] = clean_energy[n - 1]
-            else:  # search to the left
-                n = i
-                while (n >= 0) and (clean_slope[n] <= 0):
-                    n = n - 1
-                clean_loc_peak[i] = clean_energy[n + 1]
-
-            # find the peaks in the processed speech signal
-            if processed_slope[i] > 0:  # search to the right
-                n = i
-                while (n < num_crit - 1) and (processed_slope[n] > 0):
-                    n = n + 1
-                processed_loc_peak[i] = processed_energy[n - 1]
-            else:  # search to the left
-                n = i
-                while (n >= 0) and (processed_slope[n] <= 0):
-                    n = n - 1
-                processed_loc_peak[i] = processed_energy[n + 1]
-
-        # (6) Compute the WSS Measure for this frame. This includes determination of the weighting function.
-        dBMax_clean = np.max(clean_energy)
-        dBMax_processed = np.max(processed_energy)
-        '''
-        The weights are calculated by averaging individual weighting factors from the clean and processed frame.
-        These weights W_clean and W_processed should range from 0 to 1 and place more emphasis on spectral peaks
-        and less emphasis on slope differences in spectral valleys.
-        This procedure is described on page 1280 of Klatt's 1982 ICASSP paper.
-        '''
-        Wmax_clean = np.divide(Kmax, Kmax + dBMax_clean - clean_energy[0: num_crit - 1])
-        Wlocmax_clean = np.divide(Klocmax, Klocmax + clean_loc_peak - clean_energy[0: num_crit - 1])
-        W_clean = np.multiply(Wmax_clean, Wlocmax_clean)
-
-        Wmax_processed = np.divide(Kmax, Kmax + dBMax_processed - processed_energy[0: num_crit - 1])
-        Wlocmax_processed = np.divide(Klocmax, Klocmax + processed_loc_peak - processed_energy[0: num_crit - 1])
-        W_processed = np.multiply(Wmax_processed, Wlocmax_processed)
-
-        W = np.divide(np.add(W_clean, W_processed), 2.0)
-        slope_diff = np.subtract(clean_slope, processed_slope)[0: num_crit - 1]
-        distortion[frame_count] = np.dot(W, np.square(slope_diff)) / np.sum(W)
-        # this normalization is not part of Klatt's paper, but helps to normalize the measure.
-        # Here we scale the measure by the sum of the weights.
-        start = start + skiprate
-    return distortion
-
-
-def calc_speech_metrics(hypothesis: np.ndarray,
-                        reference: np.ndarray) -> tuple[float, int, int, int, float]:
-    """
-    Calculate speech metrics pesq_mos, CSIG, CBAK, COVL, segSNR.  These are all related and thus included
-    in one function. Reference: matlab script "compute_metrics.m".
-
-    Usage:
-        pesq, csig, cbak, covl, ssnr = compute_metrics(hypothesis, reference, Fs, path)
-        reference: clean audio as array
-        hypothesis: enhanced audio as array
-        Audio must have sampling rate = 16000 Hz.
-
-    Example call:
-        pesq_output, csig_output, cbak_output, covl_output, ssnr_output = \
-                calc_speech_metrics(predicted_audio, target_audio)
-    """
-    from sonusai.metrics import calc_pesq
-
-    Fs = 16000
-
-    # compute the WSS measure
-    wss_dist_vec = wss(reference, hypothesis, Fs)
-    wss_dist_vec = np.sort(wss_dist_vec)
-    alpha = 0.95  # value from CMGAN ref implementation
-    wss_dist = np.mean(wss_dist_vec[0: round(np.size(wss_dist_vec) * alpha)])
-
-    # compute the LLR measure
-    llr_dist = llr(reference, hypothesis, Fs)
-    ll_rs = np.sort(llr_dist)
-    llr_len = round(np.size(llr_dist) * alpha)
-    llr_mean = np.mean(ll_rs[0: llr_len])
-
-    # compute the SNRseg
-    snr_dist, segsnr_dist = snr(reference, hypothesis, Fs)
-    snr_mean = snr_dist
-    segSNR = np.mean(segsnr_dist)
-
-    # compute the pesq (use Sonusai wrapper, only fs=16k, mode=wb support)
-    pesq_mos = calc_pesq(hypothesis=hypothesis, reference=reference)
-    # pesq_mos = pesq(sampling_rate1, data1, data2, 'wb')
-
-    # now compute the composite measures
-    CSIG = 3.093 - 1.029 * llr_mean + 0.603 * pesq_mos - 0.009 * wss_dist
-    CSIG = max(1, CSIG)
-    CSIG = min(5, CSIG)  # limit values to [1, 5]
-    CBAK = 1.634 + 0.478 * pesq_mos - 0.007 * wss_dist + 0.063 * segSNR
-    CBAK = max(1, CBAK)
-    CBAK = min(5, CBAK)  # limit values to [1, 5]
-    COVL = 1.594 + 0.805 * pesq_mos - 0.512 * llr_mean - 0.007 * wss_dist
-    COVL = max(1, COVL)
-    COVL = min(5, COVL)  # limit values to [1, 5]
-
-    return pesq_mos, CSIG, CBAK, COVL, segSNR
-
-
-def mean_square_error(hypothesis: np.ndarray,
-                      reference: np.ndarray,
-                      squared: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-    """Calculate root-mean-square error or mean square error
-
-    :param hypothesis: [frames, bins]
-    :param reference: [frames, bins]
-    :param squared: calculate mean square rather than root-mean-square
-    :return: mean, mean per bin, mean per frame
-    """
-    sq_err = np.square(reference - hypothesis)
-
-    # mean over frames for value per bin
-    err_b = np.mean(sq_err, axis=0)
-    # mean over bins for value per frame
-    err_f = np.mean(sq_err, axis=1)
-    # mean over all
-    err = np.mean(sq_err)
-
-    if not squared:
-        err_b = np.sqrt(err_b)
-        err_f = np.sqrt(err_f)
-        err = np.sqrt(err)
-
-    return err, err_b, err_f
-
-
-def mean_abs_percentage_error(hypothesis: np.ndarray,
-                              reference: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-    """Calculate mean abs percentage error
-
-    If inputs are complex, calculates average: mape(real)/2 + mape(imag)/2
-
-    :param hypothesis: [frames, bins]
-    :param reference: [frames, bins]
-    :return: mean, mean per bin, mean per frame
-    """
-    if not np.iscomplexobj(reference) and not np.iscomplexobj(hypothesis):
-        abs_err = 100 * np.abs((reference - hypothesis) / (reference + np.finfo(np.float32).eps))
-    else:
-        reference_r = np.real(reference)
-        reference_i = np.imag(reference)
-        hypothesis_r = np.real(hypothesis)
-        hypothesis_i = np.imag(hypothesis)
-        abs_err_r = 100 * np.abs((reference_r - hypothesis_r) / (reference_r + np.finfo(np.float32).eps))
-        abs_err_i = 100 * np.abs((reference_i - hypothesis_i) / (reference_i + np.finfo(np.float32).eps))
-        abs_err = (abs_err_r / 2) + (abs_err_i / 2)
-
-    # mean over frames for value per bin
-    err_b = np.around(np.mean(abs_err, axis=0), 3)
-    # mean over bins for value per frame
-    err_f = np.around(np.mean(abs_err, axis=1), 3)
-    # mean over all
-    err = np.around(np.mean(abs_err), 3)
-
-    return err, err_b, err_f
-
-
-def log_error(reference: np.ndarray, hypothesis: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-    """Calculate log error
-
-    :param reference: complex or real [frames, bins]
-    :param hypothesis: complex or real [frames, bins]
-    :return: mean, mean per bin, mean per frame
-    """
-    reference_sq = np.real(reference * np.conjugate(reference))
-    hypothesis_sq = np.real(hypothesis * np.conjugate(hypothesis))
-    log_err = abs(10 * np.log10((reference_sq + np.finfo(np.float32).eps) / (hypothesis_sq + np.finfo(np.float32).eps)))
-    # log_err = abs(10 * np.log10(reference_sq / (hypothesis_sq + np.finfo(np.float32).eps) + np.finfo(np.float32).eps))
-
-    # mean over frames for value per bin
-    err_b = np.around(np.mean(log_err, axis=0), 3)
-    # mean over bins for value per frame
-    err_f = np.around(np.mean(log_err, axis=1), 3)
-    # mean over all
-    err = np.around(np.mean(log_err), 3)
-
-    return err, err_b, err_f
-
-
-def phase_distance(reference: np.ndarray,
-                   hypothesis: np.ndarray,
-                   eps: float = 1e-9) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-    """Calculate weighted phase distance error (weight normalization over bins per frame)
-
-    :param reference: complex [frames, bins]
-    :param hypothesis: complex [frames, bins]
-    :param eps: epsilon value
-    :return: mean, mean per bin, mean per frame
-    """
-    ang_diff = np.angle(reference) - np.angle(hypothesis)
-    phd_mod = (ang_diff + np.pi) % (2 * np.pi) - np.pi
-    rh_angle_diff = phd_mod * 180 / np.pi  # angle diff in deg
-
-    # Use complex divide to intrinsically keep angle diff +/-180 deg, but avoid div by zero (real hyp)
-    # hyp_real = np.real(hypothesis)
-    # near_zeros = np.real(hyp_real) < eps
-    # hyp_real = hyp_real * (np.logical_not(near_zeros))
-    # hyp_real = hyp_real + (near_zeros * eps)
-    # hypothesis = hyp_real + 1j*np.imag(hypothesis)
-    # rh_angle_diff = np.angle(reference / hypothesis) * 180 / np.pi  # angle diff +/-180
-
-    # weighted mean over all (scalar)
-    reference_mag = np.abs(reference)
-    ref_weight = reference_mag / (np.sum(reference_mag) + eps)  # frames x bins
-    err = np.around(np.sum(ref_weight * rh_angle_diff), 3)
-
-    # weighted mean over frames (value per bin)
-    err_b = np.zeros(reference.shape[1])
-    for bi in range(reference.shape[1]):
-        ref_weight = reference_mag[:, bi] / (np.sum(reference_mag[:, bi], axis=0) + eps)
-        err_b[bi] = np.around(np.sum(ref_weight * rh_angle_diff[:, bi]), 3)
-
-    # weighted mean over bins (value per frame)
-    err_f = np.zeros(reference.shape[0])
-    for fi in range(reference.shape[0]):
-        ref_weight = reference_mag[fi, :] / (np.sum(reference_mag[fi, :]) + eps)
-        err_f[fi] = np.around(np.sum(ref_weight * rh_angle_diff[fi, :]), 3)
-
-    return err, err_b, err_f
-
-
-def plot_mixpred(mixture: AudioT,
-                 mixture_f: AudioF,
-                 target: Optional[AudioT] = None,
-                 feature: Optional[Feature] = None,
-                 predict: Optional[Predict] = None,
-                 tp_title: str = '') -> plt.Figure:
-    from sonusai.mixture import SAMPLE_RATE
-
-    num_plots = 2
-    if feature is not None:
-        num_plots += 1
-    if predict is not None:
-        num_plots += 1
-
-    fig, ax = plt.subplots(num_plots, 1, constrained_layout=True, figsize=(11, 8.5))
-
-    # Plot the waveform
-    p = 0
-    x_axis = np.arange(len(mixture), dtype=np.float32) / SAMPLE_RATE
-    ax[p].plot(x_axis, mixture, label='Mixture', color='mistyrose')
-    ax[0].set_ylabel('magnitude', color='tab:blue')
-    ax[p].set_xlim(x_axis[0], x_axis[-1])
-    # ax[p].set_ylim([-1.025, 1.025])
-    if target is not None:  # Plot target time-domain waveform on top of mixture
-        ax[0].plot(x_axis, target, label='Target', color='tab:blue')
-        # ax[0].tick_params(axis='y', labelcolor=color)
-    ax[p].set_title('Waveform')
-
-    # Plot the mixture spectrogram
-    p += 1
-    ax[p].imshow(np.transpose(mixture_f), aspect='auto', interpolation='nearest', origin='lower')
-    ax[p].set_title('Mixture')
-
-    if feature is not None:
-        p += 1
-        ax[p].imshow(np.transpose(feature), aspect='auto', interpolation='nearest', origin='lower')
-        ax[p].set_title('Feature')
-
-    if predict is not None:
-        p += 1
-        im = ax[p].imshow(np.transpose(predict), aspect='auto', interpolation='nearest', origin='lower')
-        ax[p].set_title('Predict ' + tp_title)
-        plt.colorbar(im, location='bottom')
-
-    return fig
-
-
-def plot_pdb_predtruth(predict: np.ndarray,
-                       truth_f: Optional[np.ndarray] = None,
-                       metric: Optional[np.ndarray] = None,
-                       tp_title: str = '') -> plt.Figure:
-    """Plot predict and optionally truth and a metric in power db, e.g. applies 10*log10(predict)"""
-    num_plots = 2
-    if truth_f is not None:
-        num_plots += 1
-
-    fig, ax = plt.subplots(num_plots, 1, constrained_layout=True, figsize=(11, 8.5))
-
-    # Plot the predict spectrogram
-    p = 0
-    tmp = 10 * np.log10(predict.transpose() + np.finfo(np.float32).eps)
-    im = ax[p].imshow(tmp, aspect='auto', interpolation='nearest', origin='lower')
-    ax[p].set_title('Predict')
-    plt.colorbar(im, location='bottom')
-
-    if truth_f is not None:
-        p += 1
-        tmp = 10 * np.log10(truth_f.transpose() + np.finfo(np.float32).eps)
-        im = ax[p].imshow(tmp, aspect='auto', interpolation='nearest', origin='lower')
-        ax[p].set_title('Truth')
-        plt.colorbar(im, location='bottom')
-
-    # Plot the predict avg, and optionally truth avg and metric lines
-    pred_avg = 10 * np.log10(np.mean(predict, axis=-1) + np.finfo(np.float32).eps)
-    p += 1
-    x_axis = np.arange(len(pred_avg), dtype=np.float32)  # / SAMPLE_RATE
-    ax[p].plot(x_axis, pred_avg, color='black', linestyle='dashed', label='Predict mean over freq.')
-    ax[p].set_ylabel('mean db', color='black')
-    ax[p].set_xlim(x_axis[0], x_axis[-1])
-    if truth_f is not None:
-        truth_avg = 10 * np.log10(np.mean(truth_f, axis=-1) + np.finfo(np.float32).eps)
-        ax[p].plot(x_axis, truth_avg, color='green', linestyle='dashed', label='Truth mean over freq.')
-
-    if metric is not None:  # instantiate 2nd y-axis that shares the same x-axis
-        ax2 = ax[p].twinx()
-        color2 = 'red'
-        ax2.plot(x_axis, metric, color=color2, label='sig distortion (mse db)')
-        ax2.set_xlim(x_axis[0], x_axis[-1])
-        ax2.set_ylim([0, np.max(metric)])
-        ax2.set_ylabel('spectral distortion (mse db)', color=color2)
-        ax2.tick_params(axis='y', labelcolor=color2)
-        ax[p].set_title('SNR and SNR mse (mean over freq. db)')
-    else:
-        ax[p].set_title('SNR (mean over freq. db)')
-        # ax[0].tick_params(axis='y', labelcolor=color)
-    return fig
-
-
-def plot_epredtruth(predict: np.ndarray,
-                    predict_wav: np.ndarray,
-                    truth_f: Optional[np.ndarray] = None,
-                    truth_wav: Optional[np.ndarray] = None,
-                    metric: Optional[np.ndarray] = None,
-                    tp_title: str = '') -> plt.Figure:
-    """Plot predict spectrogram and waveform and optionally truth and a metric)"""
-    num_plots = 2
-    if truth_f is not None:
-        num_plots += 1
-    if metric is not None:
-        num_plots += 1
-
-    fig, ax = plt.subplots(num_plots, 1, constrained_layout=True, figsize=(11, 8.5))
-
-    # Plot the predict spectrogram
-    p = 0
-    im = ax[p].imshow(predict.transpose(), aspect='auto', interpolation='nearest', origin='lower')
-    ax[p].set_title('Predict')
-    plt.colorbar(im, location='bottom')
-
-    if truth_f is not None:  # plot truth if provided and use same colormap as predict
-        p += 1
-        ax[p].imshow(truth_f.transpose(), im.cmap, aspect='auto', interpolation='nearest', origin='lower')
-        ax[p].set_title('Truth')
-
-    # Plot the predict wav, and optionally truth avg and metric lines
-    p += 1
-    x_axis = np.arange(len(predict_wav), dtype=np.float32)  # / SAMPLE_RATE
-    ax[p].plot(x_axis, predict_wav, color='black', linestyle='dashed', label='Speech Estimate')
-    ax[p].set_ylabel('Amplitude', color='black')
-    ax[p].set_xlim(x_axis[0], x_axis[-1])
-    if truth_wav is not None:
-        ntrim = len(truth_wav) - len(predict_wav)
-        if ntrim > 0:
-            truth_wav = truth_wav[0:-ntrim]
-        ax[p].plot(x_axis, truth_wav, color='green', linestyle='dashed', label='True Target')
-
-    # Plot the metric lines
-    if metric is not None:
-        p += 1
-        if metric.ndim > 1:  # if it has multiple dims, plot 1st
-            metric1 = metric[:, 0]
-        else:
-            metric1 = metric  # if single dim, plot it as 1st
-        x_axis = np.arange(len(metric1), dtype=np.float32)  # / SAMPLE_RATE
-        ax[p].plot(x_axis, metric1, color='red', label='Target LogErr')
-        ax[p].set_ylabel('log error db', color='red')
-        ax[p].set_xlim(x_axis[0], x_axis[-1])
-        ax[p].set_ylim([-0.01, np.max(metric1) + .01])
-        if metric.ndim > 1:
-            if metric.shape[1] > 1:
-                metr2 = metric[:, 1]
-                ax2 = ax[p].twinx()
-                color2 = 'blue'
-                ax2.plot(x_axis, metr2, color=color2, label='phase dist (deg)')
-                # ax2.set_ylim([-180.0, +180.0])
-                if np.max(metr2) - np.min(metr2) > .1:
-                    ax2.set_ylim([np.min(metr2), np.max(metr2)])
-                ax2.set_ylabel('phase dist (deg)', color=color2)
-                ax2.tick_params(axis='y', labelcolor=color2)
-                # ax[p].set_title('SNR and SNR mse (mean over freq. db)')
-
-    return fig
-
-
-def _process_mixture(mixid: int) -> tuple[pd.DataFrame, pd.DataFrame]:
-    from os.path import basename
-    from os.path import join
-    from os.path import splitext
-
-    import h5py
-    from numpy import inf
-    from pystoi import stoi
-
-    from sonusai import SonusAIError
-    from sonusai import logger
-    from sonusai.metrics import calc_pcm
-    from sonusai.metrics import calc_wer
-    from sonusai.metrics import calc_wsdr
-    from sonusai.mixture import forward_transform
-    from sonusai.mixture import inverse_transform
-    from sonusai.mixture import read_audio
-    from sonusai.utils import calc_asr
-    from sonusai.utils import float_to_int16
-    from sonusai.utils import reshape_outputs
-    from sonusai.utils import stack_complex
-    from sonusai.utils import unstack_complex
-    from sonusai.utils import write_wav
-
-    mixdb = MP_GLOBAL.mixdb
-    predict_location = MP_GLOBAL.predict_location
-    predwav_mode = MP_GLOBAL.predwav_mode
-    truth_est_mode = MP_GLOBAL.truth_est_mode
-    enable_plot = MP_GLOBAL.enable_plot
-    enable_wav = MP_GLOBAL.enable_wav
-    wer_method = MP_GLOBAL.wer_method
-    whisper_model = MP_GLOBAL.whisper_model
-
-    # 1)  Read predict data, var predict with shape [BatchSize,Classes] or [BatchSize,Tsteps,Classes]
-    output_name = join(predict_location, mixdb.mixture(mixid).name)
-    predict = None
-    if truth_est_mode:
-        # in truth estimation mode we use the truth in place of prediction to see metrics with perfect input
-        # don't bother to read prediction, and predict var will get assigned to truth later
-        # mark outputs with tru suffix, i.e. 0000_truest_*
-        base_name = splitext(output_name)[0] + '_truest'
-    else:
-        base_name, ext = splitext(output_name)  # base_name used later
-        if not predwav_mode:
-            try:
-                with h5py.File(output_name, 'r') as f:
-                    predict = np.array(f['predict'])
-            except Exception as e:
-                raise SonusAIError(f'Error reading {output_name}: {e}')
-            # reshape to always be [frames,classes] where ndim==3 case frames = batch * tsteps
-            if predict.ndim > 2:  # TBD generalize to somehow detect if timestep dim exists, some cases > 2 don't have
-                # logger.debug(f'Prediction reshape from {predict.shape} to remove timestep dimension.')
-                predict, _ = reshape_outputs(predict=predict, truth=None, timesteps=predict.shape[1])
-        else:
-            base_name, ext = splitext(output_name)
-            prfname = join(base_name + '.wav')
-            audio = read_audio(prfname)
-            predict = forward_transform(audio, mixdb.ft_config)
-            if mixdb.feature[0:1] == 'h':
-                predict = power_compress(predict)
-            predict = stack_complex(predict)
-
-    # 2) Collect true target, noise, mixture data, trim to predict size if needed
-    tmp = mixdb.mixture_targets(mixid)  # targets is list of pre-IR and pre-specaugment targets
-    target_f = mixdb.mixture_targets_f(mixid, targets=tmp)[0]
-    target = tmp[0]
-    mixture = mixdb.mixture_mixture(mixid)  # note: gives full reverberated/distorted target, but no specaugment
-    # noise_wodist = mixdb.mixture_noise(mixid)            # noise without specaugment and distortion
-    # noise_wodist_f = mixdb.mixture_noise_f(mixid, noise=noise_wodist)
-    noise = mixture - target  # has time-domain distortion (ir,etc.) but does not have specaugment
-    #noise_f = mixdb.mixture_noise_f(mixid, noise=noise)
-    segsnr_f = mixdb.mixture_segsnr(mixid, target=target, noise=noise)  # note: uses pre-IR, pre-specaug audio
-    mixture_f = mixdb.mixture_mixture_f(mixid, mixture=mixture)
-    noise_f = mixture_f - target_f  # true noise in freq domain includes specaugment and time-domain ir,distortions
-    #segsnr_f = mixdb.mixture_segsnr(mixid, target=target, noise=noise)
-    segsnr_f[segsnr_f == inf] = 7.944e8  # 99db
-    segsnr_f[segsnr_f == -inf] = 1.258e-10  # -99db
-    # need to use inv-tf to match #samples & latency shift properties of predict inv tf
-    targetfi = inverse_transform(target_f, mixdb.it_config)
-    noisefi = inverse_transform(noise_f, mixdb.it_config)
-    # mixturefi = mixdb.inverse_transform(mixture_f)
-
-    # gen feature, truth - note feature only used for plots
-    # TBD parse truth_f for different formats and also multi-truth
-    feature, truth_f = mixdb.mixture_ft(mixid, mixture=mixture)
-    truth_type = mixdb.target_file(mixdb.mixture(mixid).targets[0].file_id).truth_settings[0].function
-    if truth_type == 'target_mixture_f':
-        half = truth_f.shape[-1] // 2
-        truth_f = truth_f[..., :half]  # extract target_f only
-
-    if not truth_est_mode:
-        if predict.shape[0] < target_f.shape[0]:  # target_f, truth_f, mixture_f, etc. same size
-            trimf = target_f.shape[0] - predict.shape[0]
-            logger.debug(f'Warning: prediction frames less than mixture, trimming {trimf} frames from all truth.')
-            target_f = target_f[0:-trimf, :]
-            targetfi, _ = inverse_transform(target_f, mixdb.it_config)
-            trimt = target.shape[0] - targetfi.shape[0]
-            target = target[0:-trimt]
-            noise_f = noise_f[0:-trimf, :]
-            noise = noise[0:-trimt]
-            mixture_f = mixture_f[0:-trimf, :]
-            mixture = mixture[0:-trimt]
-            truth_f = truth_f[0:-trimf, :]
-        elif predict.shape[0] > target_f.shape[0]:
-            raise SonusAIError(
-                f'Error: prediction has more frames than true mixture {predict.shape[0]} vs {truth_f.shape[0]}')
-
-    # 3) Extraction - format proper complex and wav estimates and truth (unstack, uncompress, inv tf, etc.)
-    if truth_est_mode:
-        predict = truth_f  # substitute truth for the prediction (for test/debug)
-        predict_complex = unstack_complex(predict)  # unstack
-        # if feat has compressed mag and truth does not, compress it
-        if mixdb.feature[0:1] == 'h' and mixdb.target_file(1).truth_settings[0].function[0:10] != 'targetcmpr':
-            predict_complex = power_compress(predict_complex)  # from uncompressed truth
-    else:
-        predict_complex = unstack_complex(predict)
-
-    truth_f_complex = unstack_complex(truth_f)
-    if mixdb.feature[0:1] == 'h':  # 'hn' or 'ha' or 'hd', etc.:  # if feat has compressed mag
-        # estimate noise in uncompressed-mag domain
-        noise_est_complex = mixture_f - power_uncompress(predict_complex)
-        predict_complex = power_uncompress(predict_complex)  # uncompress if truth is compressed
-    else:  # cn, c8, ..
-        noise_est_complex = mixture_f - predict_complex
-
-    target_est_wav = inverse_transform(predict_complex, mixdb.it_config)
-    noise_est_wav = inverse_transform(noise_est_complex, mixdb.it_config)
-
-    # 4) Metrics
-    # Target/Speech logerr - PSD estimation accuracy symmetric mean log-spectral distortion
-    lerr_tg, lerr_tg_bin, lerr_tg_frame = log_error(reference=truth_f_complex, hypothesis=predict_complex)
-    # Noise logerr - PSD estimation accuracy
-    lerr_n, lerr_n_bin, lerr_n_frame = log_error(reference=noise_f, hypothesis=noise_est_complex)
-    # PCM loss metric
-    ytrue_f = np.concatenate((truth_f_complex[:, np.newaxis, :], noise_f[:, np.newaxis, :]), axis=1)
-    ypred_f = np.concatenate((predict_complex[:, np.newaxis, :], noise_est_complex[:, np.newaxis, :]), axis=1)
-    pcm, pcm_bin, pcm_frame = calc_pcm(hypothesis=ypred_f, reference=ytrue_f, with_log=True)
-
-    # Phase distance
-    phd, phd_bin, phd_frame = phase_distance(hypothesis=predict_complex, reference=truth_f_complex)
-
-    # Noise td logerr
-    # lerr_nt, lerr_nt_bin, lerr_nt_frame = log_error(noisefi, noise_truth_est_audio)
-
-    # # SA-SDR (time-domain source-aggragated SDR)
-    ytrue = np.concatenate((targetfi[:, np.newaxis], noisefi[:, np.newaxis]), axis=1)
-    ypred = np.concatenate((target_est_wav[:, np.newaxis], noise_est_wav[:, np.newaxis]), axis=1)
-    # # note: w/o scale is more pessimistic number
-    # sa_sdr, _ = calc_sa_sdr(hypothesis=ypred, reference=ytrue)
-    target_stoi = stoi(targetfi, target_est_wav, 16000, extended=False)
-
-    wsdr, wsdr_cc, wsdr_cw = calc_wsdr(hypothesis=ypred, reference=ytrue, with_log=True)
-    # logger.debug(f'wsdr weight sum for mixid {mixid} = {np.sum(wsdr_cw)}.')
-    # logger.debug(f'wsdr cweights = {wsdr_cw}.')
-    # logger.debug(f'wsdr ccoefs for mixid {mixid} = {wsdr_cc}.')
-
-    # Speech intelligibility measure - PESQ
-    if int(mixdb.mixture(mixid).snr) > -99:
-        # len = target_est_wav.shape[0]
-        pesq_speech, csig_tg, cbak_tg, covl_tg, sgsnr_tg = calc_speech_metrics(target_est_wav, targetfi)
-        pesq_mixture, csig_mx, cbak_mx, covl_mx, sgsnr_mx = calc_speech_metrics(mixture, target)
-        # pesq_speech_tst = calc_pesq(hypothesis=target_est_wav, reference=target)
-        # pesq_mixture_tst = calc_pesq(hypothesis=mixture, reference=target)
-        # pesq improvement
-        pesq_impr = pesq_speech - pesq_mixture
-        # pesq improvement %
-        pesq_impr_pc = pesq_impr / (pesq_mixture + np.finfo(np.float32).eps) * 100
-    else:
-        pesq_speech = 0
-        pesq_mixture = 0
-        pesq_impr_pc = np.float32(0)
-        csig_mx = 0
-        csig_tg = 0
-        cbak_mx = 0
-        cbak_tg = 0
-        covl_mx = 0
-        covl_tg = 0
-
-    # Calc WER
-    asr_tt = ''
-    asr_mx = ''
-    asr_tge = ''
-    if wer_method == 'none' or mixdb.mixture(mixid).snr == -99:  # noise only, ignore/reset target asr
-        wer_mx = float('nan')
-        wer_tge = float('nan')
-        wer_pi = float('nan')
-    else:
-        if MP_GLOBAL.mixdb.asr_manifests:
-            asr_tt = MP_GLOBAL.mixdb.mixture_asr_data(mixid)[0]  # ignore mixup
-        else:
-            asr_tt = calc_asr(target, engine=wer_method, whisper_model_name=whisper_model).text  # target truth
-
-        if asr_tt:
-            asr_mx = calc_asr(mixture, engine=wer_method, whisper_model=whisper_model).text
-            asr_tge = calc_asr(target_est_wav, engine=wer_method, whisper_model=whisper_model).text
-
-            wer_mx = calc_wer(asr_mx, asr_tt).wer * 100  # mixture wer
-            wer_tge = calc_wer(asr_tge, asr_tt).wer * 100  # target estimate wer
-            if wer_mx == 0.0:
-                if wer_tge == 0.0:
-                    wer_pi = 0.0
-                else:
-                    wer_pi = -999.0
-            else:
-                wer_pi = 100 * (wer_mx - wer_tge) / wer_mx
-        else:
-            print(f'Warning: mixid {mixid} asr truth is empty, setting to 0% wer')
-            wer_mx = float(0)
-            wer_tge = float(0)
-            wer_pi = float(0)
-
-    # 5) Save per mixture metric results
-    # Single row in table of scalar metrics per mixture
-    mtable1_col = ['MXSNR', 'MXPESQ', 'PESQ', 'PESQi%', 'MXWER', 'WER', 'WERi%', 'WSDR', 'STOI',
-                   'PCM', 'SPLERR', 'NLERR', 'PD', 'MXCSIG', 'CSIG', 'MXCBAK', 'CBAK', 'MXCOVL', 'COVL',
-                   'SPFILE', 'NFILE']
-    ti = mixdb.mixture(mixid).targets[0].file_id
-    ni = mixdb.mixture(mixid).noise.file_id
-    metr1 = [mixdb.mixture(mixid).snr, pesq_mixture, pesq_speech, pesq_impr_pc, wer_mx, wer_tge, wer_pi, wsdr,
-             target_stoi, pcm, lerr_tg, lerr_n, phd, csig_mx, csig_tg, cbak_mx, cbak_tg, covl_mx, covl_tg,
-             basename(mixdb.target_file(ti).name), basename(mixdb.noise_file(ni).name)]
-    mtab1 = pd.DataFrame([metr1], columns=mtable1_col, index=[mixid])
-
-    # Stats of per frame estimation metrics
-    metr2 = pd.DataFrame({'SSNR':  segsnr_f,
-                          'PCM':   pcm_frame,
-                          'SLERR': lerr_tg_frame,
-                          'NLERR': lerr_n_frame,
-                          'SPD':   phd_frame})
-    metr2 = metr2.describe()  # Use pandas stat function
-    # Change SSNR stats to dB, except count.  SSNR is index 0, pandas requires using iloc
-    # metr2['SSNR'][1:] = metr2['SSNR'][1:].apply(lambda x: 10 * np.log10(x + 1.01e-10))
-    metr2.iloc[1:, 0] = metr2['SSNR'][1:].apply(lambda x: 10 * np.log10(x + 1.01e-10))
-    # create a single row in multi-column header
-    new_labels = pd.MultiIndex.from_product([metr2.columns,
-                                             ['Avg', 'Min', 'Med', 'Max', 'Std']],
-                                            names=['Metric', 'Stat'])
-    dat1row = metr2.loc[['mean', 'min', '50%', 'max', 'std'], :].T.stack().to_numpy().reshape((1, -1))
-    mtab2 = pd.DataFrame(dat1row,
-                         index=[mixid],
-                         columns=new_labels)
-    mtab2.insert(0, 'MXSNR', mixdb.mixture(mixid).snr, False)  # add MXSNR as the first metric column
-
-    all_metrics_table_1 = mtab1  # return to be collected by process
-    all_metrics_table_2 = mtab2  # return to be collected by process
-
-    metric_name = base_name + '_metric_spenh.txt'
-    with open(metric_name, 'w') as f:
-        print('Speech enhancement metrics:', file=f)
-        print(mtab1.round(2).to_string(float_format=lambda x: "{:.2f}".format(x)), file=f)
-        print('', file=f)
-        print(f'Extraction statistics over {mixture_f.shape[0]} frames:', file=f)
-        print(metr2.round(2).to_string(float_format=lambda x: "{:.2f}".format(x)), file=f)
-        print('', file=f)
-        print(f'Target path: {mixdb.target_file(ti).name}', file=f)
-        print(f'Noise path: {mixdb.noise_file(ni).name}', file=f)
-        if wer_method != 'none':
-            print(f'WER method: {wer_method} and whisper model (if used):  {whisper_model}', file=f)
-            if mixdb.asr_manifests:
-                print(f'ASR truth from manifest:  {asr_tt}', file=f)
-            else:
-                print(f'ASR truth from wer method:  {asr_tt}', file=f)
-            print(f'ASR result for mixture:  {asr_mx}', file=f)
-            print(f'ASR result for prediction:  {asr_tge}', file=f)
-
-        print(f'Augmentations: {mixdb.mixture(mixid)}', file=f)
-
-    # 7) write wav files
-    if enable_wav:
-        write_wav(name=base_name + '_mixture.wav', audio=float_to_int16(mixture))
-        write_wav(name=base_name + '_target.wav', audio=float_to_int16(target))
-        # write_wav(name=base_name + '_targetfi.wav', audio=float_to_int16(targetfi))
-        write_wav(name=base_name + '_noise.wav', audio=float_to_int16(noise))
-        write_wav(name=base_name + '_target_est.wav', audio=float_to_int16(target_est_wav))
-        write_wav(name=base_name + '_noise_est.wav', audio=float_to_int16(noise_est_wav))
-
-        # debug code to test for perfect reconstruction of the extraction method
-        # note both 75% olsa-hanns and 50% olsa-hann modes checked to have perfect reconstruction
-        # target_r = mixdb.inverse_transform(target_f)
-        # noise_r = mixdb.inverse_transform(noise_f)
-        # _write_wav(name=base_name + '_target_r.wav', audio=float_to_int16(target_r))
-        # _write_wav(name=base_name + '_noise_r.wav', audio=float_to_int16(noise_r)) # chk perfect rec
-
-    # 8) Write out plot file
-    if enable_plot:
-        from matplotlib.backends.backend_pdf import PdfPages
-        plot_fname = base_name + '_metric_spenh.pdf'
-
-        # Reshape feature to eliminate overlap redundancy for easier to understand spectrogram view
-        # Original size (frames, stride, num_bands), decimates in stride dimension only if step is > 1
-        # Reshape to get frames*decimated_stride, num_bands
-        step = int(mixdb.feature_samples / mixdb.feature_step_samples)
-        if feature.ndim != 3:
-            raise SonusAIError(f'feature does not have 3 dimensions: frames, stride, num_bands')
-
-        # for feature cn*00n**
-        feat_sgram = unstack_complex(feature)
-        feat_sgram = 20 * np.log10(abs(feat_sgram) + np.finfo(np.float32).eps)
-        feat_sgram = feat_sgram[:, -step:, :]  # decimate,  Fx1xB
-        feat_sgram = np.reshape(feat_sgram, (feat_sgram.shape[0] * feat_sgram.shape[1], feat_sgram.shape[2]))
-
-        with PdfPages(plot_fname) as pdf:
-            # page1 we always have a mixture and prediction, target optional if truth provided
-            tfunc_name = mixdb.target_file(1).truth_settings[0].function  # first target, assumes all have same
-            if tfunc_name == 'mapped_snr_f':
-                # leave as unmapped snr
-                predplot = predict
-                tfunc_name = mixdb.target_file(1).truth_settings[0].function
-            elif tfunc_name == 'target_f' or 'target_mixture_f':
-                predplot = 20 * np.log10(abs(predict_complex) + np.finfo(np.float32).eps)
-            else:
-                # use dB scale
-                predplot = 10 * np.log10(predict + np.finfo(np.float32).eps)
-                tfunc_name = tfunc_name + ' (db)'
-
-            mixspec = 20 * np.log10(abs(mixture_f) + np.finfo(np.float32).eps)
-            pdf.savefig(plot_mixpred(mixture=mixture,
-                                     mixture_f=mixspec,
-                                     target=target,
-                                     feature=feat_sgram,
-                                     predict=predplot,
-                                     tp_title=tfunc_name))
-
-            # ----- page 2, plot unmapped predict, opt truth reconstructed and line plots of mean-over-f
-            # pdf.savefig(plot_pdb_predtruth(predict=pred_snr_f, tp_title='predict snr_f (db)'))
-
-            # page 3 speech extraction
-            tg_spec = 20 * np.log10(abs(target_f) + np.finfo(np.float32).eps)
-            tg_est_spec = 20 * np.log10(abs(predict_complex) + np.finfo(np.float32).eps)
-            # n_spec = np.reshape(n_spec,(n_spec.shape[0] * n_spec.shape[1], n_spec.shape[2]))
-            pdf.savefig(plot_epredtruth(predict=tg_est_spec,
-                                        predict_wav=target_est_wav,
-                                        truth_f=tg_spec,
-                                        truth_wav=targetfi,
-                                        metric=np.vstack((lerr_tg_frame, phd_frame)).T,
-                                        tp_title='speech estimate'))
-
-            # page 4 noise extraction
-            n_spec = 20 * np.log10(abs(noise_f) + np.finfo(np.float32).eps)
-            n_est_spec = 20 * np.log10(abs(noise_est_complex) + np.finfo(np.float32).eps)
-            pdf.savefig(plot_epredtruth(predict=n_est_spec,
-                                        predict_wav=noise_est_wav,
-                                        truth_f=n_spec,
-                                        truth_wav=noisefi,
-                                        metric=lerr_n_frame,
-                                        tp_title='noise estimate'))
-
-            # Plot error waveforms
-            # tg_err_wav = targetfi - target_est_wav
-            # tg_err_spec = 20*np.log10(np.abs(target_f - predict_complex))
-
-        plt.close('all')
-
-    return all_metrics_table_1, all_metrics_table_2
-
-
-def main():
-    from docopt import docopt
-
-    import sonusai
-    from sonusai.utils import trim_docstring
-
-    args = docopt(trim_docstring(__doc__), version=sonusai.__version__, options_first=True)
-
-    verbose = args['--verbose']
-    mixids = args['--mixid']
-    predict_location = args['PLOC']
-    wer_method = args['--wer-method'].lower()
-    truth_est_mode = args['--truth-est-mode']
-    enable_plot = args['--plot']
-    enable_wav = args['--wav']
-    enable_summary = args['--summary']
-    truth_location = args['TLOC']
-    whisper_model = args['--whisper-model'].lower()
-
-    import glob
-    from os.path import basename
-    from os.path import isdir
-    from os.path import join
-    from os.path import split
-
-    from tqdm import tqdm
-
-    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 DEFAULT_NOISE
-    from sonusai.mixture import MixtureDatabase
-    from sonusai.mixture import read_audio
-    from sonusai.utils import calc_asr
-    from sonusai.utils import pp_tqdm_imap
-
-    # Check prediction subdirectory
-    if not isdir(predict_location):
-        print(f'The specified predict location {predict_location} is not a valid subdirectory path, exiting ...')
-
-    # allpfiles = listdir(predict_location)
-    allpfiles = glob.glob(predict_location + "/*.h5")
-    predict_logfile = glob.glob(predict_location + "/*predict.log")
-    predwav_mode = False
-    if len(allpfiles) <= 0 and not truth_est_mode:
-        allpfiles = glob.glob(predict_location + "/*.wav")  # check for wav files
-        if len(allpfiles) <= 0:
-            print(f'Subdirectory {predict_location} has no .h5 or .wav files, exiting ...')
-        else:
-            logger.info(f'Found {len(allpfiles)} prediction .wav files.')
-            predwav_mode = True
-    else:
-        logger.info(f'Found {len(allpfiles)} prediction .h5 files.')
-
-    if len(predict_logfile) == 0:
-        logger.info(f'Warning, predict location {predict_location} has no prediction log files.')
-    else:
-        logger.info(f'Found predict log {basename(predict_logfile[0])} in predict location.')
-
-    # Setup logging file
-    create_file_handler(join(predict_location, 'calc_metric_spenh.log'))
-    update_console_handler(verbose)
-    initial_log_messages('calc_metric_spenh')
-
-    mixdb = MixtureDatabase(truth_location)
-    mixids = mixdb.mixids_to_list(mixids)
-    logger.info(
-        f'Found mixdb of {mixdb.num_mixtures} total mixtures, with {mixdb.num_classes} classes in {truth_location}')
-    logger.info(f'Only running specified subset of {len(mixids)} mixtures')
-
-    enable_asr_warmup = False
-    if wer_method == 'none':
-        fnb = 'metric_spenh_'
-    elif wer_method == 'google':
-        fnb = 'metric_spenh_ggl_'
-        logger.info(f'WER enabled with method {wer_method}')
-        enable_asr_warmup = True
-    elif wer_method == 'deepgram':
-        fnb = 'metric_spenh_dgram_'
-        logger.info(f'WER enabled with method {wer_method}')
-        enable_asr_warmup = True
-    elif wer_method == 'aixplain_whisper':
-        fnb = 'metric_spenh_whspx_' + whisper_model + '_'
-        logger.info(f'WER enabled with method {wer_method} and whisper model {whisper_model}')
-        enable_asr_warmup = True
-    elif wer_method == 'whisper':
-        fnb = 'metric_spenh_whspl_' + whisper_model + '_'
-        logger.info(f'WER enabled with method {wer_method} and whisper model {whisper_model}')
-        enable_asr_warmup = True
-    elif wer_method == 'aaware_whisper':
-        fnb = 'metric_spenh_whspaaw_' + whisper_model + '_'
-        logger.info(f'WER enabled with method {wer_method} and whisper model {whisper_model}')
-        enable_asr_warmup = True
-    elif wer_method == 'fastwhisper':
-        fnb = 'metric_spenh_fwhsp_' + whisper_model + '_'
-        logger.info(f'WER enabled with method {wer_method} and whisper model {whisper_model}')
-        enable_asr_warmup = True
-    else:
-        logger.error(f'Unrecognized WER method: {wer_method}')
-        return
-
-    if enable_asr_warmup:
-        DEFAULT_SPEECH = split(DEFAULT_NOISE)[0] + '/speech_ma01_01.wav'
-        audio = read_audio(DEFAULT_SPEECH)
-        logger.info(f'Warming up asr method, note for cloud service this could take up to a few min ...')
-        asr_chk = calc_asr(audio, engine=wer_method, whisper_model_name=whisper_model)
-        logger.info(f'Warmup completed, results {asr_chk}')
-
-    MP_GLOBAL.mixdb = mixdb
-    MP_GLOBAL.predict_location = predict_location
-    MP_GLOBAL.predwav_mode = predwav_mode
-    MP_GLOBAL.truth_est_mode = truth_est_mode
-    MP_GLOBAL.enable_plot = enable_plot
-    MP_GLOBAL.enable_wav = enable_wav
-    MP_GLOBAL.wer_method = wer_method
-    MP_GLOBAL.whisper_model = whisper_model
-
-    # Individual mixtures use pandas print, set precision to 2 decimal places
-    # pd.set_option('float_format', '{:.2f}'.format)
-    progress = tqdm(total=len(mixids), desc='calc_metric_spenh')
-    all_metrics_tables = pp_tqdm_imap(_process_mixture, mixids, progress=progress, num_cpus=8)
-    progress.close()
-
-    all_metrics_table_1 = pd.concat([item[0] for item in all_metrics_tables])
-    all_metrics_table_2 = pd.concat([item[1] for item in all_metrics_tables])
-
-    if not enable_summary:
-        return
-
-    # 9) Done with mixtures, write out summary metrics
-    # Calculate SNR summary avg of each non-random snr
-    all_mtab1_sorted = all_metrics_table_1.sort_values(by=['MXSNR', 'SPFILE'])
-    all_mtab2_sorted = all_metrics_table_2.sort_values(by=['MXSNR'])
-    mtab_snr_summary = None
-    mtab_snr_summary_em = None
-    for snri in range(0, len(mixdb.snrs)):
-        tmp = all_mtab1_sorted.query('MXSNR==' + str(mixdb.snrs[snri])).mean(numeric_only=True).to_frame().T
-        # avoid nan when subset of mixids specified
-        if ~np.isnan(tmp.iloc[0].to_numpy()[0]).any():
-            mtab_snr_summary = pd.concat([mtab_snr_summary, tmp])
-
-        tmp = all_mtab2_sorted[all_mtab2_sorted['MXSNR'] == mixdb.snrs[snri]].mean(numeric_only=True).to_frame().T
-        # avoid nan when subset of mixids specified (mxsnr will be nan if no data):
-        if ~np.isnan(tmp.iloc[0].to_numpy()[0]).any():
-            mtab_snr_summary_em = pd.concat([mtab_snr_summary_em, tmp])
-
-    mtab_snr_summary = mtab_snr_summary.sort_values(by=['MXSNR'], ascending=False)
-    # Correct percentages in snr summary table
-    mtab_snr_summary['PESQi%'] = 100 * (mtab_snr_summary['PESQ'] - mtab_snr_summary['MXPESQ']) / np.maximum(
-        mtab_snr_summary['MXPESQ'], 0.01)
-    for i in range(len(mtab_snr_summary)):
-        if mtab_snr_summary['MXWER'].iloc[i] == 0.0:
-            if mtab_snr_summary['WER'].iloc[i] == 0.0:
-                mtab_snr_summary['WERi%'].iloc[i] = 0.0
-            else:
-                mtab_snr_summary['WERi%'].iloc[i] = -999.0
-        else:
-            if ~np.isnan(mtab_snr_summary['WER'].iloc[i]) and ~np.isnan(mtab_snr_summary['MXWER'].iloc[i]):
-                # update WERi% in 6th col
-                mtab_snr_summary.iloc[i,6] = 100 * (mtab_snr_summary['MXWER'].iloc[i] -
-                                                    mtab_snr_summary['WER'].iloc[i]) / \
-                                                    mtab_snr_summary['MXWER'].iloc[i]
-
-
-    # Calculate avg metrics over all mixtures except -99
-    all_mtab1_sorted_nom99 = all_mtab1_sorted[all_mtab1_sorted.MXSNR != -99]
-    all_nom99_mean = all_mtab1_sorted_nom99.mean(numeric_only=True)
-
-    # correct the percentage averages with a direct calculation (PESQ% and WER%):
-    # ser.iloc[pos]
-    all_nom99_mean['PESQi%'] = (100 * (all_nom99_mean['PESQ'] - all_nom99_mean['MXPESQ'])
-                                / np.maximum(all_nom99_mean['MXPESQ'], 0.01))  # pesq%
-    # all_nom99_mean[3] = 100 * (all_nom99_mean[2] - all_nom99_mean[1]) / np.maximum(all_nom99_mean[1], 0.01)  # pesq%
-    if all_nom99_mean['MXWER'] == 0.0:
-        if all_nom99_mean['WER'] == 0.0:
-            all_nom99_mean['WERi%'] = 0.0
-        else:
-            all_nom99_mean['WERi%'] = -999.0
-    else:  # wer%
-        all_nom99_mean['WERi%'] = 100 * (all_nom99_mean['MXWER'] - all_nom99_mean['WER']) / all_nom99_mean['MXWER']
-
-    num_mix = len(mixids)
-    if num_mix > 1:
-        # Print pandas data to files using precision to 2 decimals
-        # pd.set_option('float_format', '{:.2f}'.format)
-        csp = 0
-
-        if not truth_est_mode:
-            ofname = join(predict_location, fnb + 'summary.txt')
-        else:
-            ofname = join(predict_location, fnb + 'summary_truest.txt')
-
-        with open(ofname, 'w') as f:
-            print(f'WER enabled with method {wer_method}, whisper model, if used: {whisper_model}', file=f)
-            print(f'Speech enhancement metrics avg over all {len(all_mtab1_sorted_nom99)} non -99 SNR mixtures:',
-                  file=f)
-            print(all_nom99_mean.to_frame().T.round(2).to_string(float_format=lambda x: "{:.2f}".format(x),
-                                                                 index=False), file=f)
-            print(f'\nSpeech enhancement metrics avg over each SNR:', file=f)
-            print(mtab_snr_summary.round(2).to_string(float_format=lambda x: "{:.2f}".format(x), index=False), file=f)
-            print('', file=f)
-            print(f'Extraction statistics stats avg over each SNR:', file=f)
-            # with pd.option_context('display.max_colwidth', 9):
-            # with pd.set_option('float_format', '{:.1f}'.format):
-            print(mtab_snr_summary_em.round(1).to_string(float_format=lambda x: "{:.1f}".format(x), index=False),
-                  file=f)
-            print('', file=f)
-            # pd.set_option('float_format', '{:.2f}'.format)
-
-            print(f'Speech enhancement metrics stats over all {num_mix} mixtures:', file=f)
-            print(all_metrics_table_1.describe().round(2).to_string(float_format=lambda x: "{:.2f}".format(x)), file=f)
-            print('', file=f)
-            print(f'Extraction statistics stats over all {num_mix} mixtures:', file=f)
-            print(all_metrics_table_2.describe().round(2).to_string(float_format=lambda x: "{:.1f}".format(x)), file=f)
-            print('', file=f)
-
-            print('Speech enhancement metrics all-mixtures list:', file=f)
-            # print(all_metrics_table_1.head().style.format(precision=2), file=f)
-            print(all_metrics_table_1.round(2).to_string(float_format=lambda x: "{:.2f}".format(x)), file=f)
-            print('', file=f)
-            print('Extraction statistics all-mixtures list:', file=f)
-            print(all_metrics_table_2.round(2).to_string(float_format=lambda x: "{:.1f}".format(x)), file=f)
-
-        # Write summary to .csv file
-        if not truth_est_mode:
-            csv_name = join(predict_location, fnb + 'summary.csv')
-        else:
-            csv_name = join(predict_location, fnb + 'summary_truest.csv')
-        header_args = {
-            'mode':     'a',
-            'encoding': 'utf-8',
-            'index':    False,
-            'header':   False,
-        }
-        table_args = {
-            'mode':     'a',
-            'encoding': 'utf-8',
-        }
-        label = f'Speech enhancement metrics avg over all {len(all_mtab1_sorted_nom99)} non -99 SNR mixtures:'
-        pd.DataFrame([label]).to_csv(csv_name, header=False, index=False)  # open as write
-        all_nom99_mean.to_frame().T.round(2).to_csv(csv_name, index=False, **table_args)
-        pd.DataFrame(['']).to_csv(csv_name, **header_args)
-        pd.DataFrame([f'Speech enhancement metrics avg over each SNR:']).to_csv(csv_name, **header_args)
-        mtab_snr_summary.round(2).to_csv(csv_name, index=False, **table_args)
-        pd.DataFrame(['']).to_csv(csv_name, **header_args)
-        pd.DataFrame([f'Extraction statistics stats avg over each SNR:']).to_csv(csv_name, **header_args)
-        mtab_snr_summary_em.round(2).to_csv(csv_name, index=False, **table_args)
-        pd.DataFrame(['']).to_csv(csv_name, **header_args)
-        pd.DataFrame(['']).to_csv(csv_name, **header_args)
-        label = f'Speech enhancement metrics stats over {num_mix} mixtures:'
-        pd.DataFrame([label]).to_csv(csv_name, **header_args)
-        all_metrics_table_1.describe().round(2).to_csv(csv_name, **table_args)
-        pd.DataFrame(['']).to_csv(csv_name, **header_args)
-        label = f'Extraction statistics stats over {num_mix} mixtures:'
-        pd.DataFrame([label]).to_csv(csv_name, **header_args)
-        all_metrics_table_2.describe().round(2).to_csv(csv_name, **table_args)
-        label = f'WER enabled with method {wer_method}, whisper model, if used: {whisper_model}'
-        pd.DataFrame([label]).to_csv(csv_name, **header_args)
-
-        if not truth_est_mode:
-            csv_name = join(predict_location, fnb + 'list.csv')
-        else:
-            csv_name = join(predict_location, fnb + 'list_truest.csv')
-        pd.DataFrame(['Speech enhancement metrics list:']).to_csv(csv_name, header=False, index=False)  # open as write
-        all_metrics_table_1.round(2).to_csv(csv_name, **table_args)
-
-        if not truth_est_mode:
-            csv_name = join(predict_location, fnb + 'estats_list.csv')
-        else:
-            csv_name = join(predict_location, fnb + 'estats_list_truest.csv')
-        pd.DataFrame(['Extraction statistics list:']).to_csv(csv_name, header=False, index=False)  # open as write
-        all_metrics_table_2.round(2).to_csv(csv_name, **table_args)
-
-
-if __name__ == '__main__':
-    try:
-        main()
-    except KeyboardInterrupt:
-        logger.info('Canceled due to keyboard interrupt')
-        exit()