nkululeko 0.93.12__py3-none-any.whl → 0.93.14__py3-none-any.whl

nkululeko/constants.py

@@ -1,2 +1,2 @@
-VERSION="0.93.12"
+VERSION="0.93.14"
 SAMPLING_RATE = 16000

nkululeko/data/dataset.py

@@ -34,11 +34,9 @@ class Dataset:
         self.plot = Plots()
         self.limit = int(self.util.config_val_data(self.name, "limit", 0))
         self.target_tables_append = eval(
-            self.util.config_val_data(
-                self.name, "target_tables_append", "False")
+            self.util.config_val_data(self.name, "target_tables_append", "False")
         )
-        self.start_fresh = eval(
-            self.util.config_val("DATA", "no_reuse", "False"))
+        self.start_fresh = eval(self.util.config_val("DATA", "no_reuse", "False"))
         self.is_labeled, self.got_speaker, self.got_gender, self.got_age = (
             False,
             False,
@@ -72,8 +70,7 @@ class Dataset:
         try:
             self.db = audformat.Database.load(root)
         except FileNotFoundError:
-            self.util.error(
-                f"{self.name}: no audformat database found at {root}")
+            self.util.error(f"{self.name}: no audformat database found at {root}")
         return root
 
     def _check_cols(self, df):
@@ -95,8 +92,7 @@ class Dataset:
         )
         self.util.debug(r_string)
         if glob_conf.report.initial:
-            glob_conf.report.add_item(ReportItem(
-                "Data", "Load report", r_string))
+            glob_conf.report.add_item(ReportItem("Data", "Load report", r_string))
             glob_conf.report.initial = False
 
     def load(self):
@@ -107,8 +103,7 @@ class Dataset:
         store_file = f"{store}{self.name}.{store_format}"
         self.root = self._load_db()
         if not self.start_fresh and os.path.isfile(store_file):
-            self.util.debug(
-                f"{self.name}: reusing previously stored file {store_file}")
+            self.util.debug(f"{self.name}: reusing previously stored file {store_file}")
             self.df = self.util.get_store(store_file, store_format)
             self.is_labeled = self.target in self.df
             self.got_gender = "gender" in self.df
@@ -123,12 +118,10 @@ class Dataset:
         # map the audio file paths
         self.db.map_files(lambda x: os.path.join(self.root, x))
         # the dataframes (potentially more than one) with at least the file names
-        df_files = self.util.config_val_data(
-            self.name, "files_tables", "['files']")
+        df_files = self.util.config_val_data(self.name, "files_tables", "['files']")
         df_files_tables = ast.literal_eval(df_files)
         # The label for the target column
-        self.col_label = self.util.config_val_data(
-            self.name, "label", self.target)
+        self.col_label = self.util.config_val_data(self.name, "label", self.target)
         (
             df,
             self.is_labeled,
@@ -164,8 +157,7 @@ class Dataset:
                 self.got_age = got_age2 or self.got_age
                 if audformat.is_filewise_index(df_target.index):
                     try:
-                        df_target = df_target.loc[df.index.get_level_values(
-                            "file")]
+                        df_target = df_target.loc[df.index.get_level_values("file")]
                         df_target = df_target.set_index(df.index)
                     except KeyError:
                         # just a try...
@@ -214,8 +206,7 @@ class Dataset:
             end = self.df.index.get_level_values(2)
             self.df["duration"] = (end - start).total_seconds()
         elif self.df.duration.dtype == "timedelta64[ns]":
-            self.df["duration"] = self.df["duration"].map(
-                lambda x: x.total_seconds())
+            self.df["duration"] = self.df["duration"].map(lambda x: x.total_seconds())
         # Perform some filtering if desired
         required = self.util.config_val_data(self.name, "required", False)
         if required:
@@ -245,18 +236,15 @@ class Dataset:
                 res.append(abs(n - max))
             return res
 
-        reverse = eval(self.util.config_val_data(
-            self.name, "reverse", "False"))
+        reverse = eval(self.util.config_val_data(self.name, "reverse", "False"))
         if reverse:
-            max = eval(self.util.config_val_data(
-                self.name, "reverse.max", "False"))
+            max = eval(self.util.config_val_data(self.name, "reverse.max", "False"))
             if max:
                 max = float(max)
             else:
                 max = self.df[self.target].values.max()
             self.util.debug(f"reversing target numbers with max values: {max}")
-            self.df[self.target] = reverse_array(
-                self.df[self.target].values, max)
+            self.df[self.target] = reverse_array(self.df[self.target].values, max)
 
         # check if the target variable should be scaled (z-transformed)
         scale = self.util.config_val_data(self.name, "scale", False)
@@ -329,15 +317,13 @@ class Dataset:
                 pass
             try:
                 # also it might be possible that the age is part of the speaker description
-                df_local["age"] = db[table]["speaker"].get(
-                    map="age").astype(int)
+                df_local["age"] = db[table]["speaker"].get(map="age").astype(int)
                 got_age = True
             except (ValueError, audformat.errors.BadKeyError):
                 pass
             try:
                 # same for the target, e.g. "age"
-                df_local[self.target] = db[table]["speaker"].get(
-                    map=self.target)
+                df_local[self.target] = db[table]["speaker"].get(map=self.target)
                 is_labeled = True
             except (ValueError, audformat.core.errors.BadKeyError):
                 pass
@@ -398,10 +384,8 @@ class Dataset:
             testdf = self.db.tables[self.target + ".test"].df
             traindf = self.db.tables[self.target + ".train"].df
             # use only the train and test samples that were not perhaps filtered out by an earlier processing step
-            self.df_test = self.df.loc[self.df.index.intersection(
-                testdf.index)]
-            self.df_train = self.df.loc[self.df.index.intersection(
-                traindf.index)]
+            self.df_test = self.df.loc[self.df.index.intersection(testdf.index)]
+            self.df_train = self.df.loc[self.df.index.intersection(traindf.index)]
         elif split_strategy == "train":
             self.df_train = self.df
             self.df_test = pd.DataFrame()
@@ -424,23 +408,18 @@ class Dataset:
             if entry_train_tables:
                 train_tables = ast.literal_eval(entry_train_tables)
                 for train_table in train_tables:
-                    traindf = pd.concat(
-                        [traindf, self.db.tables[train_table].df])
+                    traindf = pd.concat([traindf, self.db.tables[train_table].df])
             # use only the train and test samples that were not perhaps filtered out by an earlier processing step
             # testdf.index.map(lambda x: os.path.join(self.root, x))
             #            testdf.index = testdf.index.to_series().apply(lambda x: self.root+x)
             testdf = testdf.set_index(
-                audformat.utils.to_segmented_index(
-                    testdf.index, allow_nat=False)
+                audformat.utils.to_segmented_index(testdf.index, allow_nat=False)
             )
             traindf = traindf.set_index(
-                audformat.utils.to_segmented_index(
-                    traindf.index, allow_nat=False)
+                audformat.utils.to_segmented_index(traindf.index, allow_nat=False)
             )
-            self.df_test = self.df.loc[self.df.index.intersection(
-                testdf.index)]
-            self.df_train = self.df.loc[self.df.index.intersection(
-                traindf.index)]
+            self.df_test = self.df.loc[self.df.index.intersection(testdf.index)]
+            self.df_train = self.df.loc[self.df.index.intersection(traindf.index)]
             # it might be necessary to copy the target values
             try:
                 self.df_test[self.target] = testdf[self.target]
@@ -467,12 +446,10 @@ class Dataset:
             self.util.error(f"unknown split strategy: {split_strategy}")
 
         # check if train or test set should be ignored
-        as_test = eval(self.util.config_val_data(
-            self.name, "as_test", "False"))
+        as_test = eval(self.util.config_val_data(self.name, "as_test", "False"))
         if as_test:
             self.df_train = pd.DataFrame()
-        as_train = eval(self.util.config_val_data(
-            self.name, "as_train", "False"))
+        as_train = eval(self.util.config_val_data(self.name, "as_train", "False"))
         if as_train:
             self.df_test = pd.DataFrame()
 
@@ -503,8 +480,7 @@ class Dataset:
 
         seed = 42
         k = 30
-        test_size = int(self.util.config_val_data(
-            self.name, "test_size", 20)) / 100.0
+        test_size = int(self.util.config_val_data(self.name, "test_size", 20)) / 100.0
         df = self.df
         # split target
         targets = df[self.target].to_numpy()
@@ -520,8 +496,7 @@ class Dataset:
         stratif_vars = self.util.config_val("DATA", "balance", False)
         stratif_vars_array = {}
         if not stratif_vars:
-            self.util.error(
-                "balanced split needs stratif_vars to stratify the splits")
+            self.util.error("balanced split needs stratif_vars to stratify the splits")
         else:
             stratif_vars = ast.literal_eval(stratif_vars)
             for stratif_var in stratif_vars.keys():
@@ -530,8 +505,7 @@ class Dataset:
                     continue
                 else:
                     data = df[stratif_var].to_numpy()
-                    bins = self.util.config_val(
-                        "DATA", f"{stratif_var}_bins", False)
+                    bins = self.util.config_val("DATA", f"{stratif_var}_bins", False)
                     if bins:
                         data = binning(data, nbins=int(bins))
                     stratif_vars_array[stratif_var] = data
@@ -582,8 +556,7 @@ class Dataset:
 
     def split_speakers(self):
         """One way to split train and eval sets: Specify percentage of evaluation speakers"""
-        test_percent = int(self.util.config_val_data(
-            self.name, "test_size", 20))
+        test_percent = int(self.util.config_val_data(self.name, "test_size", 20))
         df = self.df
         s_num = df.speaker.nunique()
         test_num = int(s_num * (test_percent / 100))
@@ -602,8 +575,7 @@ class Dataset:
 
     def random_split(self):
         """One way to split train and eval sets: Specify percentage of random samples"""
-        test_percent = int(self.util.config_val_data(
-            self.name, "test_size", 20))
+        test_percent = int(self.util.config_val_data(self.name, "test_size", 20))
         df = self.df
         s_num = len(df)
         test_num = int(s_num * (test_percent / 100))
@@ -707,8 +679,7 @@ class Dataset:
         if df.empty:
             return
         if self.check_continuous_classification():
-            self.util.debug(
-                f"{self.name}: binning continuous variable to categories")
+            self.util.debug(f"{self.name}: binning continuous variable to categories")
             cat_vals = self.util.continuous_to_categorical(df[self.target])
             df[self.target] = cat_vals.values
             labels = ast.literal_eval(glob_conf.config["DATA"]["labels"])

nkululeko/data/dataset_csv.py

@@ -3,19 +3,20 @@ import ast
 import os
 import os.path
 
-import audformat.utils
 import pandas as pd
 
-import nkululeko.glob_conf as glob_conf
+import audformat.utils
+
 from nkululeko.data.dataset import Dataset
+import nkululeko.glob_conf as glob_conf
 from nkululeko.reporting.report_item import ReportItem
 
 
 class Dataset_CSV(Dataset):
-    """Class to represent datasets stored as a csv file"""
+    """Class to represent datasets stored as a csv file."""
 
     def load(self):
-        """Load the dataframe with files, speakers and task labels"""
+        """Load the dataframe with files, speakers and task labels."""
         self.util.debug(f"loading {self.name}")
         self.got_target, self.got_speaker, self.got_gender = False, False, False
         data_file = self.util.config_val_data(self.name, "", "")

nkululeko/feat_extract/feats_analyser.py

@@ -4,8 +4,10 @@ import ast
 import matplotlib.pyplot as plt
 import pandas as pd
 from sklearn.inspection import permutation_importance
-from sklearn.linear_model import LinearRegression, LogisticRegression
-from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
+from sklearn.linear_model import LinearRegression
+from sklearn.linear_model import LogisticRegression
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.tree import DecisionTreeRegressor
 
 import nkululeko.glob_conf as glob_conf
 from nkululeko.plots import Plots

nkululeko/feat_extract/feats_wav2vec2.py

@@ -49,6 +49,7 @@ class Wav2vec2(Featureset):
         hidden_layer = int(self.util.config_val("FEATS", "wav2vec2.layer", "0"))
         config.num_hidden_layers = layer_num - hidden_layer
         self.util.debug(f"using hidden layer #{config.num_hidden_layers}")
+
         self.processor = Wav2Vec2FeatureExtractor.from_pretrained(model_path)
         self.model = Wav2Vec2Model.from_pretrained(model_path, config=config).to(
             self.device

nkululeko/plots.py

@@ -24,8 +24,10 @@ class Plots:
         self.format = self.util.config_val("PLOT", "format", "png")
         self.target = self.util.config_val("DATA", "target", "emotion")
         self.with_ccc = eval(self.util.config_val("PLOT", "ccc", "False"))
+        self.type_s = "samples"
 
     def plot_distributions_speaker(self, df):
+        self.type_s = "speaker"
         df_speakers = pd.DataFrame()
         pd.options.mode.chained_assignment = None  # default='warn'
         for s in df.speaker.unique():
@@ -297,12 +299,22 @@ class Plots:
         if cat_col == "class_label":
             plot_df = plot_df.rename(columns={cat_col: self.target})
             cat_col = self.target
+        elif cont_col == "class_label":
+            plot_df = plot_df.rename(columns={cont_col: self.target})
+            cont_col = self.target
         dist_type = self.util.config_val("EXPL", "dist_type", "kde")
-        cats, cat_str, es = su.get_effect_size(plot_df, cat_col, cont_col)
+        max_cat, cat_str, effect_results = su.get_effect_size(
+            plot_df, cat_col, cont_col
+        )
+        self.util.debug(effect_results)
+        self.util.print_results_to_store(
+            f"cohens-d_{self.type_s}", str(effect_results) + "\n"
+        )
+        es = effect_results[max_cat]
         model_type = self.util.get_model_type()
         if dist_type == "hist" and model_type != "tree":
             ax = sns.histplot(plot_df, x=cont_col, hue=cat_col, kde=True)
-            caption = f"{ylab} {plot_df.shape[0]}. {cat_str} ({cats}):" f" {es}"
+            caption = f"{ylab} {plot_df.shape[0]}. {cat_str} ({max_cat}):" f" {es}"
             ax.set_title(caption)
             ax.set_xlabel(f"{cont_col}")
             ax.set_ylabel(f"number of {ylab}")
@@ -316,7 +328,7 @@ class Plots:
                 warn_singular=False,
             )
             ax.set(xlabel=f"{cont_col}")
-            caption = f"{ylab} {plot_df.shape[0]}. {cat_str} ({cats}):" f" {es}"
+            caption = f"{ylab} {plot_df.shape[0]}. {cat_str} ({max_cat}):" f" {es}"
             ax.figure.suptitle(caption)
         return ax, caption
 
@@ -327,7 +339,7 @@ class Plots:
         if col2 == "class_label":
             plot_df = plot_df.rename(columns={col2: self.target})
             col2 = self.target
-        if col1 == "class_label":
+        elif col1 == "class_label":
             plot_df = plot_df.rename(columns={col1: self.target})
             col1 = self.target
         crosstab = pd.crosstab(index=plot_df[col1], columns=plot_df[col2])

nkululeko/utils/stats.py

@@ -1,7 +1,8 @@
-import math
 from itertools import combinations
+import math
 
 import numpy as np
+import pandas as pd
 
 
 def check_na(a):
@@ -14,9 +15,8 @@ def check_na(a):
         return a
 
 
-def cohen_d(d1, d2):
-    """
-    Compute Cohen's d from two distributions of real valued arrays.
+def cohen_d(d1: np.array, d2: np.array) -> float:
+    """Compute Cohen's d from two distributions of real valued arrays.
 
     Args:
         d1: one array
@@ -50,7 +50,9 @@ def all_combinations(items_list):
     return result
 
 
-def get_effect_size(df, target, variable):
+def get_effect_size(
+    df: pd.DataFrame, target: str, variable: str
+) -> tuple[str, str, dict]:
     """Get the effect size as Cohen's D.
 
     Effect size is computed  from a real numbered variable on a categorical target.
@@ -68,10 +70,10 @@ def get_effect_size(df, target, variable):
     for c in categories:
         cats[c] = df[df[target] == c][variable].values
     combos = all_combinations(categories)
-    results = {}
+    results = {categories[0]: 0}
     if len(categories) == 1:
         cat_s = cohens_D_to_string(0)
-        return categories[0], cat_s, 0
+        return categories[0], cat_s, results
     else:
         for combo in combos:
             one = combo[0]
@@ -79,10 +81,10 @@ def get_effect_size(df, target, variable):
             results[f"{one}-{other}"] = cohen_d(cats[one], cats[other])
         max_cat = max(results, key=results.get)
         cat_s = cohens_D_to_string(float(results[max_cat]))
-    return max_cat, cat_s, results[max_cat]
+    return max_cat, cat_s, results
 
 
-def cohens_D_to_string(val):
+def cohens_D_to_string(val: float) -> str:
     if val < 0.2:
         rval = "no effect"
     elif val < 0.2:

nkululeko/utils/util.py

@@ -160,6 +160,21 @@ class Util:
         pred_name = self.get_model_description()
         return f"{results_dir}/pred_{target}_{pred_name}.csv"
 
+    def print_results_to_store(self, name: str, contents: str) -> str:
+        """Write contents to a result file.
+
+        Args:
+            name (str): the (sub) name of the file_
+
+        Returns:
+            str: The path to the file
+        """
+        results_dir = self.get_path("res_dir")
+        pred_name = self.get_model_description()
+        path = os.path.join(results_dir, f"{name}_{pred_name}.txt")
+        with open(path, "a") as f:
+            f.write(contents)
+
     def is_categorical(self, pd_series):
         """Check if a dataframe column is categorical."""
         return pd_series.dtype.name == "object" or isinstance(

nkululeko-0.93.14.dist-info/METADATA

@@ -0,0 +1,39 @@
+Metadata-Version: 2.2
+Name: nkululeko
+Version: 0.93.14
+Summary: Machine learning audio prediction experiments based on templates
+Home-page: https://github.com/felixbur/nkululeko
+Author: Felix Burkhardt
+Author-email: fxburk@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.9
+License-File: LICENSE
+Requires-Dist: audeer
+Requires-Dist: audformat
+Requires-Dist: audinterface
+Requires-Dist: audiofile
+Requires-Dist: audiomentations
+Requires-Dist: audmetric
+Requires-Dist: audonnx
+Requires-Dist: confidence_intervals
+Requires-Dist: datasets
+Requires-Dist: imageio
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: opensmile
+Requires-Dist: pandas
+Requires-Dist: praat-parselmouth
+Requires-Dist: scikit_learn
+Requires-Dist: scipy
+Requires-Dist: seaborn
+Requires-Dist: sounddevice
+Requires-Dist: torch
+Requires-Dist: torchvision
+Requires-Dist: transformers
+Requires-Dist: umap-learn
+Requires-Dist: xgboost
+Requires-Dist: pylatex

{nkululeko-0.93.12.dist-info → nkululeko-0.93.14.dist-info}/RECORD

@@ -2,7 +2,7 @@ nkululeko/__init__.py,sha256=62f8HiEzJ8rG2QlTFJXUCMpvuH3fKI33DoJSj33mscc,63
 nkululeko/aug_train.py,sha256=FoMbBrfyOZd4QAw7oIHl3X6-UpsqAKWVDIolCA7qOWs,3196
 nkululeko/augment.py,sha256=3RzaxB3gRxovgJVjHXi0glprW01J7RaHhUkqotW2T3U,2955
 nkululeko/cacheddataset.py,sha256=XFpWZmbJRg0pvhnIgYf0TkclxllD-Fctu-Ol0PF_00c,969
-nkululeko/constants.py,sha256=T9YZzqdg_ltKpuIf2XZdrqFmmlZQmhak97DpM5GQQhI,40
+nkululeko/constants.py,sha256=o5ER1luWQ6hCEUmTnLGYzK-uGjv9VCnzzDYq2KIxo0o,40
 nkululeko/demo-ft.py,sha256=iD9Pzp9QjyAv31q1cDZ75vPez7Ve8A4Cfukv5yfZdrQ,770
 nkululeko/demo.py,sha256=4Yzhg6pCPBYPGJrP7JX2TysVosl_R1llpVDKc2P_gUA,4955
 nkululeko/demo_feats.py,sha256=BvZjeNFTlERIRlq34OHM4Z96jdDQAhB01BGQAUcX9dM,2026
@@ -20,7 +20,7 @@ nkululeko/modelrunner.py,sha256=lJy-xM4QfDDWeL0dLTE_VIb4sYrnd_Z_yJRK3wwohQA,1119
 nkululeko/multidb.py,sha256=sO6OwJn8sn1-C-ig3thsIL8QMWHdV9SnJhDodKjeKrI,6876
 nkululeko/nkuluflag.py,sha256=PGWSmZz-PiiHLgcZJAoGOI_Y-sZDVI1ksB8p5r7riWM,3725
 nkululeko/nkululeko.py,sha256=M7baIq2nAoi6dEoBL4ATEuqAs5U1fvl_hyqAl5DybAQ,2040
-nkululeko/plots.py,sha256=Mm30pDLBb55iE9SYaSg76KFBKnebZTlypFQIBo26wuY,25991
+nkululeko/plots.py,sha256=jutO1nC7EMXGEPXCivVGhgrk3I0WrYrvIWyClm7ASaE,26440
 nkululeko/predict.py,sha256=MLnHEyFmSiHLLs-HDczag8Vu3zKF5T1rXLKdZZJ6py8,2083
 nkululeko/resample.py,sha256=rn3-M1A-iwVGibfQNGyeYNa7briD24lIN9Szq_1uTJo,5194
 nkululeko/runmanager.py,sha256=AswmORVUkCIH0gTx6zEyufvFATQBS8C5TXo2erSNdVg,7611
@@ -49,12 +49,12 @@ nkululeko/autopredict/ap_stoi.py,sha256=UEQg1ZV0meAsxgdWB8ieRs9GPXHqArmsaOyCGRwp
 nkululeko/autopredict/ap_valence.py,sha256=WrW4Ltqi_odW49_4QEVKkfnrcztLIVZ4cXIEHu4dBN8,1026
 nkululeko/autopredict/estimate_snr.py,sha256=1k9-XadABudnsNOeFZD_Fg0E64-GUQVS7JEp82MLQS4,4995
 nkululeko/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nkululeko/data/dataset.py,sha256=H65rvQ8sPwEwv_T-FqOEa7FeQ3JBn88v3xOzBOjARe4,30582
-nkululeko/data/dataset_csv.py,sha256=p2b4eS5R2Q5zdOIc56NRRU2PTFXSRt0qrdHGafHkWKo,4830
+nkululeko/data/dataset.py,sha256=G6RFK2msSVHxpzDm8gZSAD4GK6ieMS5fTbqVS-NOFuY,30081
+nkululeko/data/dataset_csv.py,sha256=AIbtB6pGk5BSQGIgfokZ7tEGFjmuOq5w2XumRSimVWs,4833
 nkululeko/feat_extract/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nkululeko/feat_extract/feats_agender.py,sha256=onfAQ6-xx_mFMJXEF1IX8cHBmGtGeX6weJmxbkfh1_o,3184
 nkululeko/feat_extract/feats_agender_agender.py,sha256=_YQv1qw--3uQfnyTQDCwlmPRnrhdMhgXbYK2yQtseW0,3464
-nkululeko/feat_extract/feats_analyser.py,sha256=luTV2-yw7rk0aQPI88vvtW1GLV8cGypp7LJW1v_YBrw,13450
+nkululeko/feat_extract/feats_analyser.py,sha256=txuIEgO4uprle35RzBczvZm5Hc7iUl2p9oBEfdrvg_I,13506
 nkululeko/feat_extract/feats_ast.py,sha256=w62xEoLiFtU-rj6SXkqXAktmoFaXcAcAWpUyEjp8JWo,4652
 nkululeko/feat_extract/feats_auddim.py,sha256=CGLp_aYhudfwoU5522vjrvjPxfZcyw593A8xLjYefV8,3134
 nkululeko/feat_extract/feats_audmodel.py,sha256=OsZyB1rdcG0Fai2gAwBlbuubmWor1_-P4IDkZLqgPKE,3161
@@ -71,7 +71,7 @@ nkululeko/feat_extract/feats_spectra.py,sha256=6WhFUpB0WTutg7OFMlAw9lSwVU5OBYCDc
 nkululeko/feat_extract/feats_spkrec.py,sha256=o_6bdU4lIkj64S5Kdjf1iyuo1VASeYxE4XdxV94a8gE,4732
 nkululeko/feat_extract/feats_squim.py,sha256=yJifsp9kj9iJjW_UAKr3LlvVhX5rv7el4bepn0wN2a8,4578
 nkululeko/feat_extract/feats_trill.py,sha256=JgyUQ8ihIL5PlUpxjchlbC9547GI0SyUwkFEquya85Q,3197
-nkululeko/feat_extract/feats_wav2vec2.py,sha256=WYB9XlRzgDi8cGSKzhV5jahA0GZ_SiWgaQ25IcEemto,5296
+nkululeko/feat_extract/feats_wav2vec2.py,sha256=q1QzMD3KbhF2SOmxdwI7CiViRmhlFRyghxN_6SmUc0E,5297
 nkululeko/feat_extract/feats_wavlm.py,sha256=O9cfc39VF5aPJRRATKb37pHT4W11i2cu5O1mY9LOjIA,4755
 nkululeko/feat_extract/feats_whisper.py,sha256=n3ESZtva7wshs8E8diBlQYa9xCH_P0UY1DncSrxz-FY,4508
 nkululeko/feat_extract/featureset.py,sha256=clcBv9rzBRW-bfw7JC_FYTjU5uUS-c0UE1XtQLYYRiE,1615
@@ -110,11 +110,11 @@ nkululeko/segmenting/seg_pyannote.py,sha256=6IPbgjnGOz9juzEKDTZN3PSipX4t6Mz-DILA
 nkululeko/segmenting/seg_silero.py,sha256=ulodnvtRq5MLHDxy_RmAK4tJg6h1d-mPq-uCPFkGVKg,4258
 nkululeko/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nkululeko/utils/files.py,sha256=SrrYaU7AB80MZHiV1jcB0h_zigvYLYgSVNTXV4ao38g,4593
-nkululeko/utils/stats.py,sha256=vCRzhCR0Gx5SiJyAGbj1TIto8ocGz58CM5Pr3LltagA,2948
-nkululeko/utils/util.py,sha256=wFDslqxpCVDwi6LBakIFDDy1kYsxt5G7ykE38CocmtA,16880
-nkululeko-0.93.12.dist-info/LICENSE,sha256=0zGP5B_W35yAcGfHPS18Q2B8UhvLRY3dQq1MhpsJU_U,1076
-nkululeko-0.93.12.dist-info/METADATA,sha256=jjO-vG0POWF3v_v3QfliA4uT8jzZPikwmEj2O6v6rhg,42823
-nkululeko-0.93.12.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-nkululeko-0.93.12.dist-info/entry_points.txt,sha256=lNTkFEdh6Kjo5o95ZAWf_0Lq-4ztGoAoMVSDuPtuyS0,442
-nkululeko-0.93.12.dist-info/top_level.txt,sha256=DPFNNSHPjUeVKj44dVANAjuVGRCC3MusJ08lc2a8xFA,10
-nkululeko-0.93.12.dist-info/RECORD,,
+nkululeko/utils/stats.py,sha256=3Fyx8q8BSKYmiufT6OkRug9RATWmGrr9BaX_y8jziWo,3074
+nkululeko/utils/util.py,sha256=J_dmqkOVAW63Q7IFUBj0BgygKzMXA0nORxY62-o8z_g,17360
+nkululeko-0.93.14.dist-info/LICENSE,sha256=0zGP5B_W35yAcGfHPS18Q2B8UhvLRY3dQq1MhpsJU_U,1076
+nkululeko-0.93.14.dist-info/METADATA,sha256=2cqjRLPed00dMPGG8SDMHG9k0w1gx0bItfrYsGk4rR4,1148
+nkululeko-0.93.14.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+nkululeko-0.93.14.dist-info/entry_points.txt,sha256=lNTkFEdh6Kjo5o95ZAWf_0Lq-4ztGoAoMVSDuPtuyS0,442
+nkululeko-0.93.14.dist-info/top_level.txt,sha256=DPFNNSHPjUeVKj44dVANAjuVGRCC3MusJ08lc2a8xFA,10
+nkululeko-0.93.14.dist-info/RECORD,,