nkululeko 0.81.3__py3-none-any.whl → 0.81.6__py3-none-any.whl

nkululeko/reporter.py

@@ -0,0 +1,332 @@
+"""Reporter module.
+
+This module contains the Reporter class which is responsible for generating reports.
+"""
+
+
+import ast
+import glob
+import json
+import math
+
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy.stats import pearsonr
+from sklearn.metrics import (
+    ConfusionMatrixDisplay,
+    accuracy_score,
+    classification_report,
+    confusion_matrix,
+    mean_absolute_error,
+    mean_squared_error,
+    r2_score,
+    recall_score,
+)
+from sklearn.utils import resample
+
+import nkululeko.glob_conf as glob_conf
+from nkululeko.reporting.defines import Header
+from nkululeko.reporting.report_item import ReportItem
+from nkululeko.result import Result
+from nkululeko.utils.util import Util
+
+
+class Reporter:
+    def __set_measure(self):
+        if self.util.exp_is_classification():
+            self.MEASURE = "UAR"
+            self.result.measure = self.MEASURE
+            self.is_classification = True
+        else:
+            self.is_classification = False
+            self.measure = self.util.config_val("MODEL", "measure", "mse")
+            if self.measure == "mse":
+                self.MEASURE = "MSE"
+                self.result.measure = self.MEASURE
+            elif self.measure == "mae":
+                self.MEASURE = "MAE"
+                self.result.measure = self.MEASURE
+            elif self.measure == "ccc":
+                self.MEASURE = "CCC"
+                self.result.measure = self.MEASURE
+
+    def __init__(self, truths, preds, run, epoch):
+        """Initialization with ground truth und predictions vector"""
+        self.util = Util("reporter")
+        self.format = self.util.config_val("PLOT", "format", "png")
+        self.truths = truths
+        self.preds = preds
+        self.result = Result(0, 0, 0, 0, "unknown")
+        self.run = run
+        self.epoch = epoch
+        self.__set_measure()
+        self.cont_to_cat = False
+        if len(self.truths) > 0 and len(self.preds) > 0:
+            if self.util.exp_is_classification():
+                self.result.test = recall_score(
+                    self.truths, self.preds, average="macro"
+                )
+                self.result.loss = 1 - accuracy_score(self.truths, self.preds)
+            else:
+                # regression experiment
+                if self.measure == "mse":
+                    self.result.test = mean_squared_error(
+                        self.truths, self.preds)
+                elif self.measure == "mae":
+                    self.result.test = mean_absolute_error(
+                        self.truths, self.preds)
+                elif self.measure == "ccc":
+                    self.result.test = self.ccc(self.truths, self.preds)
+                    if math.isnan(self.result.test):
+                        self.util.debug(f"Truth: {self.truths}")
+                        self.util.debug(f"Predict.: {self.preds}")
+                        self.util.debug(f"Result is NAN: setting to -1")
+                        self.result.test = -1
+                else:
+                    self.util.error(f"unknown measure: {self.measure}")
+
+                # train and loss are being set by the model
+
+    def set_id(self, run, epoch):
+        """Make the report identifiable with run and epoch index"""
+        self.run = run
+        self.epoch = epoch
+
+    def continuous_to_categorical(self):
+        if self.cont_to_cat:
+            return
+        self.cont_to_cat = True
+        bins = ast.literal_eval(glob_conf.config["DATA"]["bins"])
+        self.truths = np.digitize(self.truths, bins) - 1
+        self.preds = np.digitize(self.preds, bins) - 1
+
+    def plot_confmatrix(self, plot_name, epoch):
+        if not self.util.exp_is_classification():
+            self.continuous_to_categorical()
+        self._plot_confmat(self.truths, self.preds, plot_name, epoch)
+
+
+def plot_per_speaker(self, result_df, plot_name, function):
+    """Plot a confusion matrix with the mode category per speakers.
+
+    This function creates a confusion matrix for each speaker in the result_df.
+    The result_df should contain the columns: preds, truths and speaker.
+
+    Args:
+        * result_df: a pandas dataframe with columns: preds, truths and speaker
+        * plot_name: a string with the name of the plot
+        * function: a string with the function to use for each speaker, 
+        can be 'mode' or 'mean'
+
+    Returns:
+        * None
+    """
+    # Initialize empty arrays for predictions and truths
+    pred = np.zeros(0)
+    truth = np.zeros(0)
+
+    # Iterate over each speaker
+    for s in result_df.speaker.unique():
+        # Filter the dataframe for the current speaker
+        s_df = result_df[result_df.speaker == s]
+
+        # Get the mode or mean prediction for the current speaker
+        mode = s_df.pred.mode().iloc[-1]
+        mean = s_df.pred.mean()
+        if function == "mode":
+            s_df.pred = mode
+        elif function == "mean":
+            s_df.pred = mean
+        else:
+            self.util.error(f"unknown function {function}")
+
+        # Append the current speaker's predictions and truths to the arrays
+        pred = np.append(pred, s_df.pred.values)
+        truth = np.append(truth, s_df["truth"].values)
+
+    # If the experiment is not a classification or continuous to categorical conversion was performed,
+    # convert the truths and predictions to categorical
+    if not (self.is_classification or self.cont_to_cat):
+        bins = ast.literal_eval(glob_conf.config["DATA"]["bins"])
+        truth = np.digitize(truth, bins) - 1
+        pred = np.digitize(pred, bins) - 1
+
+    # Plot the confusion matrix for the speakers
+    self._plot_confmat(truth, pred.astype("int"), plot_name, 0)
+
+    def _plot_confmat(self, truths, preds, plot_name, epoch):
+        # print(truths)
+        # print(preds)
+        fig_dir = self.util.get_path("fig_dir")
+        labels = glob_conf.labels
+        fig = plt.figure()  # figsize=[5, 5]
+        uar = recall_score(truths, preds, average="macro")
+        acc = accuracy_score(truths, preds)
+        cm = confusion_matrix(
+            truths, preds, normalize=None
+        )  # normalize must be one of {'true', 'pred', 'all', None}
+        if cm.shape[0] != len(labels):
+            self.util.error(
+                f"mismatch between confmatrix dim ({cm.shape[0]}) and labels"
+                f" length ({len(labels)}: {labels})"
+            )
+        try:
+            disp = ConfusionMatrixDisplay(
+                confusion_matrix=cm, display_labels=labels
+            ).plot(cmap="Blues")
+        except ValueError:
+            disp = ConfusionMatrixDisplay(
+                confusion_matrix=cm,
+                display_labels=list(labels).remove("neutral"),
+            ).plot(cmap="Blues")
+
+        reg_res = ""
+        if not self.is_classification:
+            reg_res = f", {self.MEASURE}: {self.result.test:.3f}"
+
+        if epoch != 0:
+            plt.title(
+                f"Confusion Matrix, UAR: {uar:.3f}{reg_res}, Epoch: {epoch}")
+        else:
+            plt.title(f"Confusion Matrix, UAR: {uar:.3f}{reg_res}")
+        img_path = f"{fig_dir}{plot_name}.{self.format}"
+        plt.savefig(img_path)
+        fig.clear()
+        plt.close(fig)
+        plt.savefig(img_path)
+        plt.close(fig)
+        glob_conf.report.add_item(
+            ReportItem(
+                Header.HEADER_RESULTS,
+                self.util.get_model_description(),
+                "Confusion matrix",
+                img_path,
+            )
+        )
+
+        res_dir = self.util.get_path("res_dir")
+        uar = int(uar * 1000) / 1000.0
+        acc = int(acc * 1000) / 1000.0
+        rpt = f"epoch: {epoch}, UAR: {uar}, ACC: {acc}"
+        # print(rpt)
+        self.util.debug(rpt)
+        file_name = f"{res_dir}{self.util.get_exp_name()}_conf.txt"
+        with open(file_name, "w") as text_file:
+            text_file.write(rpt)
+
+    def print_results(self, epoch):
+        """Print all evaluation values to text file"""
+        res_dir = self.util.get_path("res_dir")
+        file_name = f"{res_dir}{self.util.get_exp_name()}_{epoch}.txt"
+        if self.util.exp_is_classification():
+            labels = glob_conf.labels
+            try:
+                rpt = classification_report(
+                    self.truths,
+                    self.preds,
+                    target_names=labels,
+                    output_dict=True,
+                )
+            except ValueError as e:
+                self.util.debug(
+                    "Reporter: caught a ValueError when trying to get"
+                    " classification_report: " + e
+                )
+                rpt = self.result.to_string()
+            with open(file_name, "w") as text_file:
+                c_ress = list(range(len(labels)))
+                for i, l in enumerate(labels):
+                    c_res = rpt[l]["f1-score"]
+                    c_ress[i] = float(f"{c_res:.3f}")
+                self.util.debug(f"labels: {labels}")
+                f1_per_class = f"result per class (F1 score): {c_ress}"
+                self.util.debug(f1_per_class)
+                rpt_str = f"{json.dumps(rpt)}\n{f1_per_class}"
+                text_file.write(rpt_str)
+                glob_conf.report.add_item(
+                    ReportItem(
+                        Header.HEADER_RESULTS,
+                        f"Classification result {self.util.get_model_description()}",
+                        rpt_str,
+                    )
+                )
+
+        else:  # regression
+            result = self.result.test
+            r2 = r2_score(self.truths, self.preds)
+            pcc = pearsonr(self.truths, self.preds)[0]
+            measure = self.util.config_val("MODEL", "measure", "mse")
+            with open(file_name, "w") as text_file:
+                text_file.write(
+                    f"{measure}: {result:.3f}, r_2: {r2:.3f}, pcc {pcc:.3f}"
+                )
+
+    def make_conf_animation(self, out_name):
+        import imageio
+
+        fig_dir = self.util.get_path("fig_dir")
+        filenames = glob.glob(
+            fig_dir + f"{self.util.get_plot_name()}*_?_???_cnf.png")
+        images = []
+        for filename in filenames:
+            images.append(imageio.imread(filename))
+        fps = self.util.config_val("PLOT", "fps", "1")
+        try:
+            imageio.mimsave(fig_dir + out_name, images, fps=int(fps))
+        except RuntimeError as e:
+            self.util.error("error writing anim gif: " + e)
+
+    def get_result(self):
+        return self.result
+
+    def plot_epoch_progression(self, reports, out_name):
+        fig_dir = self.util.get_path("fig_dir")
+        results, losses, train_results, losses_eval = [], [], [], []
+        for r in reports:
+            results.append(r.get_result().test)
+            losses.append(r.get_result().loss)
+            train_results.append(r.get_result().train)
+            losses_eval.append(r.get_result().loss_eval)
+
+        # do a plot per run
+        # scale the losses so they fit on the picture
+        losses, results, train_results, losses_eval = (
+            np.asarray(losses),
+            np.asarray(results),
+            np.asarray(train_results),
+            np.asarray(losses_eval),
+        )
+
+        if np.all((results > 1)):
+            # scale down values
+            results = results / 100.0
+            train_results = train_results / 100.0
+        # if np.all((losses < 1)):
+        # scale up values
+        plt.figure(dpi=200)
+        plt.plot(train_results, "green", label="train set")
+        plt.plot(results, "red", label="dev set")
+        plt.plot(losses, "black", label="losses")
+        plt.plot(losses_eval, "grey", label="losses_eval")
+        plt.xlabel("epochs")
+        plt.ylabel(f"{self.MEASURE}")
+        plt.legend()
+        plt.savefig(f"{fig_dir}{out_name}.{self.format}")
+        plt.close()
+
+    @staticmethod
+    def ccc(ground_truth, prediction):
+        mean_gt = np.mean(ground_truth, 0)
+        mean_pred = np.mean(prediction, 0)
+        var_gt = np.var(ground_truth, 0)
+        var_pred = np.var(prediction, 0)
+        v_pred = prediction - mean_pred
+        v_gt = ground_truth - mean_gt
+        cor = sum(v_pred * v_gt) / \
+            (np.sqrt(sum(v_pred**2)) * np.sqrt(sum(v_gt**2)))
+        sd_gt = np.std(ground_truth)
+        sd_pred = np.std(prediction)
+        numerator = 2 * cor * sd_gt * sd_pred
+        denominator = var_gt + var_pred + (mean_gt - mean_pred) ** 2
+        ccc = numerator / denominator
+        return ccc

nkululeko/resample.py

@@ -1,19 +1,23 @@
 # resample.py
 # change the sampling rate for train and test splits
 
-from nkululeko.experiment import Experiment
-import configparser
-from nkululeko.utils.util import Util
-from nkululeko.constants import VERSION
 import argparse
+import configparser
 import os
+
 import pandas as pd
+
 from nkululeko.augmenting.resampler import Resampler
+from nkululeko.constants import VERSION
+from nkululeko.experiment import Experiment
+from nkululeko.utils.util import Util
 
 
 def main(src_dir):
-    parser = argparse.ArgumentParser(description="Call the nkululeko framework.")
-    parser.add_argument("--config", default="exp.ini", help="The base configuration")
+    parser = argparse.ArgumentParser(
+        description="Call the nkululeko RESAMPLE  framework.")
+    parser.add_argument("--config", default="exp.ini",
+                        help="The base configuration")
     args = parser.parse_args()
     if args.config is not None:
         config_file = args.config
@@ -48,7 +52,8 @@ def main(src_dir):
 
     # split into train and test
     expr.fill_train_and_tests()
-    util.debug(f"train shape : {expr.df_train.shape}, test shape:{expr.df_test.shape}")
+    util.debug(
+        f"train shape : {expr.df_train.shape}, test shape:{expr.df_test.shape}")
 
     sample_selection = util.config_val("RESAMPLE", "sample_selection", "all")
     if sample_selection == "all":

nkululeko/runmanager.py

@@ -1,9 +1,13 @@
-# runmanager.py
+"""Runmanager module.
+
+This module contains the Runmanager class which is responsible for managing the 
+runs of the experiment.
+"""
 
-from nkululeko.reporting.reporter import Reporter
-from nkululeko.utils.util import Util
 import nkululeko.glob_conf as glob_conf
 from nkululeko.modelrunner import Modelrunner
+from nkululeko.reporting.reporter import Reporter
+from nkululeko.utils.util import Util
 
 
 class Runmanager:
@@ -59,7 +63,8 @@ class Runmanager:
             )
             self.reports, last_epoch = self.modelrunner.do_epochs()
             # wrap up the run
-            plot_anim_progression = self.util.config_val("PLOT", "anim_progression", 0)
+            plot_anim_progression = self.util.config_val(
+                "PLOT", "anim_progression", 0)
             if plot_anim_progression:
                 plot_name_suggest = self.util.get_exp_name()
                 plot_name = (
@@ -83,7 +88,8 @@ class Runmanager:
                     + "_epoch_progression"
                 )
                 self.util.debug(f"plotting progression to {plot_name}")
-                self.reports[-1].plot_epoch_progression(self.reports, plot_name)
+                self.reports[-1].plot_epoch_progression(
+                    self.reports, plot_name)
             # remember the best run
             best_report = self.get_best_result(self.reports)
             plot_best_model = self.util.config_val("PLOT", "best_model", False)
@@ -122,7 +128,8 @@ class Runmanager:
         self.print_model(best_report, plot_name)
 
     def print_given_result(self, run, epoch):
-        """Print a result (confusion matrix) for a given epoch and run
+        """Print a result (confusion matrix) for a given epoch and run.
+
         Args:
             run: for which run
             epoch: for which epoch
@@ -139,7 +146,8 @@ class Runmanager:
         self.print_model(report, plot_name)
 
     def print_model(self, report, plot_name):
-        """Print a confusion matrix for a special report
+        """Print a confusion matrix for a special report.
+
         Args:
             report: for which report (will be computed newly from model)
             plot_name: name of plot file
@@ -152,7 +160,8 @@ class Runmanager:
         report.print_results(epoch)
 
     def load_model(self, report):
-        """Load a model from disk for a specific run and epoch and evaluate
+        """Load a model from disk for a specific run and epoch and evaluate it.
+
         Args:
             report: for which report (will be re-evaluated)
 

nkululeko/test.py

@@ -1,17 +1,20 @@
 # test.py
 # Just use a database as test
 
-from nkululeko.experiment import Experiment
-import configparser
-from nkululeko.utils.util import Util
-from nkululeko.constants import VERSION
 import argparse
+import configparser
 import os
 
+from nkululeko.constants import VERSION
+from nkululeko.experiment import Experiment
+from nkululeko.utils.util import Util
+
 
 def main(src_dir):
-    parser = argparse.ArgumentParser(description="Call the nkululeko framework.")
-    parser.add_argument("--config", default="exp.ini", help="The base configuration")
+    parser = argparse.ArgumentParser(
+        description="Call the nkululeko TEST framework.")
+    parser.add_argument("--config", default="exp.ini",
+                        help="The base configuration")
     parser.add_argument(
         "--outfile",
         default="my_results.csv",

nkululeko/test_predictor.py

@@ -62,3 +62,4 @@ class Test_predictor:
                 df = df.drop(columns=[target])
                 df = df.rename(columns={"class_label": target})
             df.to_csv(self.name)
+        self.util.debug(f"results stored in {self.name}")

nkululeko/utils/stats.py

@@ -1,5 +1,6 @@
-from itertools import combinations
 import math
+from itertools import combinations
+
 import numpy as np
 import pandas as pd
 
@@ -16,7 +17,8 @@ def check_na(a):
 
 def cohen_d(d1, d2):
     """
-    Compute Cohen's d from two distributions of real valued arrays
+    Compute Cohen's d from two distributions of real valued arrays.
+
     Args:
         d1: one array
         d2: the other array
@@ -50,8 +52,10 @@ def all_combinations(items_list):
 
 
 def get_effect_size(df, target, variable):
-    """
-    Get the effect size as Cohen's D from a real numbered variable on a categorical target.
+    """Get the effect size as Cohen's D.
+
+    Effect size is computed  from a real numbered variable on a categorical target.
+
     Args:
         df: a pd.Dataframe with at least target and variable as columns
         target: the categorical target, e.g. emotion
@@ -88,7 +92,10 @@ def cohens_D_to_string(val):
 
 
 def normalize(values):
-    """Do a z-transformation of a distribution, so that mean = 0 and variance = 1"""
+    """Do a z-transformation of a distribution. 
+
+    So that mean = 0 and variance = 1
+    """
     from sklearn.preprocessing import StandardScaler
 
     scaler = StandardScaler()

{nkululeko-0.81.3.dist-info → nkululeko-0.81.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nkululeko
-Version: 0.81.3
+Version: 0.81.6
 Summary: Machine learning audio prediction experiments based on templates
 Home-page: https://github.com/felixbur/nkululeko
 Author: Felix Burkhardt
@@ -323,6 +323,21 @@ F. Burkhardt, Johannes Wagner, Hagen Wierstorf, Florian Eyben and Björn Schulle
 Changelog
 =========
 
+Version 0.81.6
+--------------
+* updated documentation
+* updated crema-d
+* updated tests
+
+Version 0.81.5
+--------------
+* added sex=gender for speaker mappings
+
+Version 0.81.4
+--------------
+* fixed bug in demo module
+* removed [MODEL] save
+
 Version 0.81.3
 --------------
 * added confidence intervals to result reporting

{nkululeko-0.81.3.dist-info → nkululeko-0.81.6.dist-info}/RECORD

@@ -2,29 +2,30 @@ nkululeko/__init__.py,sha256=62f8HiEzJ8rG2QlTFJXUCMpvuH3fKI33DoJSj33mscc,63
 nkululeko/aug_train.py,sha256=YhuZnS_WVWnun9G-M6g5n6rbRxoVREz6Zh7k6qprFNQ,3194
 nkululeko/augment.py,sha256=4MG0apTAG5RgkuJrYEjGgDdbodZWi_HweSPNI1JJ5QA,3051
 nkululeko/cacheddataset.py,sha256=lIJ6hUo5LoxSrzXtWV8mzwO7wRtUETWnOQ4ws2XfL1E,969
-nkululeko/constants.py,sha256=hx9HFHOlApn60yieWI1qr4PbrKeT3EFK1aaDMxlt5xU,39
-nkululeko/demo.py,sha256=me8EdjN-zrzClVy9FEmqbTQyDDON88W8vPpWEE8T0cI,2500
+nkululeko/constants.py,sha256=QwuK_rtVCEaN-oZZnh3s104ROC_O7hpEGY_ZMDKtRcw,39
+nkululeko/demo.py,sha256=55kNFA2helMhOxD4yZuKg1JWDtlUUpxm-6uAnroIydI,3264
 nkululeko/demo_feats.py,sha256=sAeGFojhEj9WEDFtG3SzPBmyYJWLF2rkbpp65m8Ujo4,2025
-nkululeko/demo_predictor.py,sha256=CQL6DO7QxwmwoB_6DlgDS-pdG1KuvemYJ1NEpMjmMk8,4733
-nkululeko/experiment.py,sha256=NVhtywaGT5vtreJNlrezp4sq-KIN_gxOjUChvBa7Z38,29575
-nkululeko/explore.py,sha256=5c89hGpjt5mRMN7w2Ajjnr2VjoFF0hOFs0O1BQruw80,2250
+nkululeko/demo_predictor.py,sha256=-ggSHc3DXxRzjzcGB4qFBOMvKsfUdTkkde50BDrS9dA,4755
+nkululeko/experiment.py,sha256=CSEvQxK2_tzJyND5sUHQSc6MkRp1g6EVam8JX8txqps,29576
+nkululeko/explore.py,sha256=2wdoGRqldvsN1zCiWk0quSDgHHHUoF2UZOWQ1r-2OLM,2310
 nkululeko/export.py,sha256=mHeEAAmtZuxdyebLlbSzPrHSi9OMgJHbk35d3DTxRBc,4632
-nkululeko/feature_extractor.py,sha256=tKv1b1-o7xNMgBavTR8VY8_H5HKoJEnnosS-KcjmOEU,7281
+nkululeko/feature_extractor.py,sha256=4UIvfh0m54286Y8q28aYBy-ojTFi3bWiActwBeAg_yE,3814
 nkululeko/file_checker.py,sha256=LoLnL8aHpW-axMQ46qbqrManTs5otG9ShpEZuz9iRSk,3474
 nkululeko/filter_data.py,sha256=w-X2mhKdYr5DxDIz50E5yzO6Jmzk4jjDBoXsgOOVtcA,7222
 nkululeko/glob_conf.py,sha256=iHiVSxDYgmYwdx6z0HuGUMSWrfZfufPHxHb60q2dLRY,453
-nkululeko/modelrunner.py,sha256=cU6FHbpI2mrG0BY7pn5UgFFpYh3u-v_GH7q73Kknhug,9337
-nkululeko/multidb.py,sha256=4ceCu9LFrMGlrcgtz4pWuOQb2KA3jR5uo3FjZgAEBD4,5732
+nkululeko/modelrunner.py,sha256=GuYsmUGSmJ0QxXxR8k0TZ47IDMtdGIMbm5nMq4Ix6tU,9335
+nkululeko/multidb.py,sha256=b49C6HjywWgs-GBZgOPufTknL9zBnl5IofSJjUrOIuY,5825
 nkululeko/nkululeko.py,sha256=Ty8cdusXUec9BHml8Gsp1r7DXuvIBMFXUckMpzILBnQ,1966
 nkululeko/plots.py,sha256=K88ZRPFGX_r03BT742H06Dde20xZYdltv7dxjgUiAFA,23025
-nkululeko/predict.py,sha256=dRXX-sQVESa7cNi_56S6UkUOa_pV1g_K4xYtYVM1SJs,1876
-nkululeko/resample.py,sha256=Yzfr_rInG9afPZFnEjiQ3EKRdMSwyYKVQwt9-yNGJn8,2233
-nkululeko/runmanager.py,sha256=JNBm7JJN8QU8qEqfWr4eS6rkPnBWoVdIUTynHctCPpw,7461
+nkululeko/predict.py,sha256=sF091sSSLnEWcISx9ZcULLie3tY5XeFsQJd6b3vrxFg,2409
+nkululeko/reporter.py,sha256=mCy8er8z4e5hJ7XbOyy6BgZYZM6Lz-EKXHh4zlT0Zc8,12427
+nkululeko/resample.py,sha256=3WbxkwgyTe_fW38046Rjxk3knOkFdhqn2C4nfhbUurQ,2287
+nkululeko/runmanager.py,sha256=eTM1DNQKt1lxYhzt4vZyZluPXW9sWlIJHNQzex4lkJU,7624
 nkululeko/scaler.py,sha256=4nkIqoajkIkuTPK0Z02ifMN_awl6fP_i-GBYdoGYgGM,4101
 nkululeko/segment.py,sha256=YLKckX44tbvTb3LrdgYw9X4guzuF27sutl92z9DkpZU,4835
 nkululeko/syllable_nuclei.py,sha256=Sky-C__MeUDaxqHnDl2TGLLYOYvsahD35TUjWGeG31k,10047
-nkululeko/test.py,sha256=Io6Lslr8qR8kfmXTypkn4xnxvKJ1oYF4tWQXDZcYm8w,1486
-nkululeko/test_predictor.py,sha256=2j7snBzhdWKSrz5Z1XViiCrFBXJdLS_uhMbGhOBb_qY,2695
+nkululeko/test.py,sha256=JRoLgqQJEhAIGetw-qlOUihSTTQ7O8DYafB0FlQESIQ,1525
+nkululeko/test_predictor.py,sha256=L2njNydYTX85_7RhHjfk1MN4JwE21tsBVuX4fY-XEjc,2753
 nkululeko/augmenting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nkululeko/augmenting/augmenter.py,sha256=XAt0dpmlnKxqyysqCgV3rcz-pRIvOz7rU7dmGDCVAzs,2905
 nkululeko/augmenting/randomsplicer.py,sha256=Z5rxdKKUpuncLWuTS6xVfVKUeVbeiYU_dLRHQ5fcg4Y,2669
@@ -41,28 +42,28 @@ nkululeko/autopredict/ap_sdr.py,sha256=qpgvJGl0NYMa8o7zHS4qU4dfY1Ey_R1p-0T8BnX3u
 nkululeko/autopredict/ap_snr.py,sha256=xHb7mmGfa4wF1r0GK7dIZ1d9m4cEz0LcpK0n3sLF9pQ,1107
 nkululeko/autopredict/ap_stoi.py,sha256=It0Lk-ki-gohA2AzD8nkLAN2WahYvD9rPDGTQuvdLRA,1184
 nkululeko/autopredict/ap_valence.py,sha256=n-hctRKySzhmJtowuMOTUu0T_ld3uK5pnfOzWeWW4VM,1024
-nkululeko/autopredict/estimate_snr.py,sha256=kJbvkt2alMN5ouS03USheU7hJ2l7U9JF0s9AtNT1Vx0,4818
+nkululeko/autopredict/estimate_snr.py,sha256=S-bpS0xFkwWc4Ch75UrjbS8y538lQ0U3g_iLRFXureY,5048
 nkululeko/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nkululeko/data/dataset.py,sha256=n6v_vVdA0EsZ-NaTgnYfPlCT4QCcD02mJJb-oD7SaSU,27265
+nkululeko/data/dataset.py,sha256=JGzMD6HIvkFkYBekmbmslIKc5ADaCj06T-8gpqH_kFo,27650
 nkululeko/data/dataset_csv.py,sha256=v3lSjF23EVjoP460QOfhdcqbWAlBQWlBOuaYujZoS4s,3407
 nkululeko/feat_extract/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nkululeko/feat_extract/feats_agender.py,sha256=_lAL6IxJDJH2bhIvd7yarTqQryx7FjbQXAgY0mJP-KI,3192
+nkululeko/feat_extract/feats_agender.py,sha256=w13UsYsUTzMe5B2Rkg0sfvBXrVBBo0-Ljo532zkDXgM,3043
 nkululeko/feat_extract/feats_agender_agender.py,sha256=5dA7YA-YGxODovMC7ynMk3bnpPjfs0ApvSfjqvoSZY0,3346
 nkululeko/feat_extract/feats_analyser.py,sha256=_5oz4y-NZCEBgfNP2GZ9WNqQR50Hbykm0TvDVomWP0U,11399
-nkululeko/feat_extract/feats_audmodel.py,sha256=TRCkLqPgnyWN-OAcO69pPZF2FIbBy5ERb5ZY22qh6iA,3108
-nkululeko/feat_extract/feats_audmodel_dim.py,sha256=yg39CSR0b54AJyOAlXO3M1ohyY9Rbrjf18pllsoQ03g,3078
+nkululeko/feat_extract/feats_auddim.py,sha256=lMhKbEfnA0qKjRgMFx1xYpEhKCB8TZeFn8AJs_oqkvE,3083
+nkululeko/feat_extract/feats_audmodel.py,sha256=AO5BcrZ0QRD7--64WZq73KWvInM-8dVfgrLDQfq4sZ0,3109
 nkululeko/feat_extract/feats_clap.py,sha256=v82mbjdjGDSKUUBggttw7jW0oka22fWAmfUf-4VmaDU,3379
 nkululeko/feat_extract/feats_hubert.py,sha256=uL-9mgQHuGPQi1nuUaw6aNU9DscsO89uJAmBdmnCegM,5205
-nkululeko/feat_extract/feats_import.py,sha256=m7Yh1sj7C1yrDDbZAqS75oMMF5rAtO7XC_sdWdQN5Iw,1598
+nkululeko/feat_extract/feats_import.py,sha256=LMxFXSO2Ui7Jj2t9oBotqWe-je8rnDgkX4ay6StNrGk,1598
 nkululeko/feat_extract/feats_mld.py,sha256=Vvu7GZOkn7Vda8eIOXqHjg78zegkFe3vTUaCXyVM0eA,2021
-nkululeko/feat_extract/feats_mos.py,sha256=XZI7U99QcSuzd1v5pVAo0JwdcrXrRICUNt_K5G6eRPU,4149
+nkululeko/feat_extract/feats_mos.py,sha256=SgsEw6_niVTUNO1tj92eUHBxKOeIcSHpYJBuHFvbJY8,4150
 nkululeko/feat_extract/feats_opensmile.py,sha256=yDRGSiUQV3K3oLxVqq8Cxj5bkc-RiLzDYbAGKC9I5vc,4140
 nkululeko/feat_extract/feats_oxbow.py,sha256=7W26NbEJnSckZzedolsIW1PJPSdCHhuh8YM19kOxaMA,4734
-nkululeko/feat_extract/feats_praat.py,sha256=dqPhAUceze_6LN6vivXJFT2PPDXZKjmzYx0XnYKYGE8,3039
-nkululeko/feat_extract/feats_snr.py,sha256=T2ID_AtlSg8QA086ys4gg83Z4MzMTThhGToGEpHU8eo,2771
+nkululeko/feat_extract/feats_praat.py,sha256=6VCEU264bV-1lTuwfn0oCbQJ96J2WbyOU724Opg2_Ms,3037
+nkululeko/feat_extract/feats_snr.py,sha256=9dqZ-4RpK98iJEssM3ttozNd18LWlZYM_QVXvp5xDcs,2829
 nkululeko/feat_extract/feats_spectra.py,sha256=PLKoc_S3v3wibodUCiOnFFdF87U2rk2sfndRo2mmG64,3656
 nkululeko/feat_extract/feats_spkrec.py,sha256=VK4ma3uWzM0YZStsgRTirfkbzjWIfRWSgsYI038QlRY,4803
-nkululeko/feat_extract/feats_squim.py,sha256=ofVgth8hFIoiXY0pT9sgWQfn23dmo7mMuS_p_WLJol8,4521
+nkululeko/feat_extract/feats_squim.py,sha256=dDsWlTfXJeUnUD5XSVw4cfuf3XJ-MHfBHxx3xyFR5mE,4504
 nkululeko/feat_extract/feats_trill.py,sha256=PpygJK_W6QoBNeSah9npQPiQlJxLWFn6TSOaZUYehNU,3211
 nkululeko/feat_extract/feats_wav2vec2.py,sha256=sFf-WkLUgKUQsFxGO9m2hS3uYoGkv95mZavCEZyWFGA,5072
 nkululeko/feat_extract/feats_wavlm.py,sha256=RhI0oWIsknnxTVmdnNS_xJO1NnUUR0CUNDWH1yTpNLk,4683
@@ -72,7 +73,7 @@ nkululeko/losses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 nkululeko/losses/loss_ccc.py,sha256=NOK0y0fxKUnU161B5geap6Fmn8QzoPl2MqtPiV8IuJE,976
 nkululeko/losses/loss_softf1loss.py,sha256=5gW-PuiqeAZcRgfwjueIOQtMokOjZWgQnVIv59HKTCo,1309
 nkululeko/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nkululeko/models/model.py,sha256=8gjRsjSYLWZvfcyTCWhbZ741rkHhx8lxCS2NlSOLP1Y,11648
+nkululeko/models/model.py,sha256=oAdKq2wY5lYKfpZkQwO46ojYRsj_Z-FR56oR1uHAWI0,11569
 nkululeko/models/model_bayes.py,sha256=wI7-sCwibqXMCHviu349TYjgJXXNXym-Z6ZM83uxlFQ,378
 nkululeko/models/model_cnn.py,sha256=j4NTp7quWqInzOPfpiMrTcfMbXkOsdlFF9ns0tW_ld4,9726
 nkululeko/models/model_gmm.py,sha256=onovzGBeguwZ-upXtuDLaBw9sd6fDDQslVBOrz1Z8TE,645
@@ -81,7 +82,7 @@ nkululeko/models/model_knn_reg.py,sha256=Fbuk6Ku6eyrbbMEk7rB5dwfhvQOMsdZk6HI_0T0
 nkululeko/models/model_lin_reg.py,sha256=NBTnY2ULuhUBt5ArYQwskZ2Vq4BBDGkqd9SYBFl7Ql4,392
 nkululeko/models/model_mlp.py,sha256=lYhGrkqEj6fa6a_tcPrqEoorOpM7t7bjSfFLKEV6pu4,9107
 nkululeko/models/model_mlp_regression.py,sha256=NP1yEsqvpDcDBWWzDq7W4SHnXC1kE4fAo4A9aBCq3cY,10083
-nkululeko/models/model_svm.py,sha256=dqDQbfRCtlW3RNqpHDGVsj3ikc131gKURHj5VzAcCr0,867
+nkululeko/models/model_svm.py,sha256=QqwRjfG9I5y-57CcJAMUSbvYzV0DOlDcpDK5f4yQ_qw,914
 nkululeko/models/model_svr.py,sha256=p-Mb4Bn54yOe1upuHQKNpfj4ttOmQnm9pCB7ECkJkJQ,699
 nkululeko/models/model_tree.py,sha256=soXjV523eRvRZ-jbX7X_3S73Wto1B9bm7ZzzDmgYzTc,390
 nkululeko/models/model_tree_reg.py,sha256=QxkQEz3LOuCLkXw5xH9IwFg4IcTL3Y5RK03qKe4TtGQ,397
@@ -99,10 +100,10 @@ nkululeko/segmenting/seg_inaspeechsegmenter.py,sha256=pmLHuXsaqvcdYxB4PSW9l1mbQW
 nkululeko/segmenting/seg_silero.py,sha256=lLytS38KzARS17omwv8VBw-zz60RVSXGSvZ5EvWlcWQ,3301
 nkululeko/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nkululeko/utils/files.py,sha256=UiGAtZRWYjHSvlmPaTMtzyNNGE6qaLaxQkybctS7iRM,4021
-nkululeko/utils/stats.py,sha256=29otJpUp1VqbtDKmlLkPPzBmVfTFiHZ70rUdR4860rM,2788
+nkululeko/utils/stats.py,sha256=1yUq0FTOyqkU8TwUocJRYdJaqMU5SlOBBRUun9STo2M,2829
 nkululeko/utils/util.py,sha256=_Z6OMJ3f-8TdETW9eqJYY5hwNRS5XCt9azzRnqoTTZE,12330
-nkululeko-0.81.3.dist-info/LICENSE,sha256=0zGP5B_W35yAcGfHPS18Q2B8UhvLRY3dQq1MhpsJU_U,1076
-nkululeko-0.81.3.dist-info/METADATA,sha256=72Q5q8KeaEP3I0TrVzswdI4g0Fc0hnCG-kPFZke8YM8,34664
-nkululeko-0.81.3.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-nkululeko-0.81.3.dist-info/top_level.txt,sha256=DPFNNSHPjUeVKj44dVANAjuVGRCC3MusJ08lc2a8xFA,10
-nkululeko-0.81.3.dist-info/RECORD,,
+nkululeko-0.81.6.dist-info/LICENSE,sha256=0zGP5B_W35yAcGfHPS18Q2B8UhvLRY3dQq1MhpsJU_U,1076
+nkululeko-0.81.6.dist-info/METADATA,sha256=zYBbwBbVfPQFWfN8yjyjNGYmI6GMYsyeRoeb8FfS3gs,34905
+nkululeko-0.81.6.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+nkululeko-0.81.6.dist-info/top_level.txt,sha256=DPFNNSHPjUeVKj44dVANAjuVGRCC3MusJ08lc2a8xFA,10
+nkululeko-0.81.6.dist-info/RECORD,,