nkululeko 0.87.0__py3-none-any.whl → 0.88.0__py3-none-any.whl

nkululeko/constants.py

@@ -1,2 +1,2 @@
-VERSION="0.87.0"
+VERSION="0.88.0"
 SAMPLING_RATE = 16000

nkululeko/demo.py

@@ -20,13 +20,14 @@ Options:   \n
 import argparse
 import configparser
 import os
+
 import pandas as pd
+from transformers import pipeline
 
+import nkululeko.glob_conf as glob_conf
 from nkululeko.constants import VERSION
 from nkululeko.experiment import Experiment
-import nkululeko.glob_conf as glob_conf
 from nkululeko.utils.util import Util
-from transformers import pipeline
 
 
 def main(src_dir):

nkululeko/ensemble.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+import configparser
+import time
+from argparse import ArgumentParser
+from pathlib import Path
+
+import pandas as pd
+
+from nkululeko.constants import VERSION
+from nkululeko.experiment import Experiment
+from nkululeko.utils.util import Util
+
+
+def ensemble_predictions(config_files, method, no_labels):
+    """
+    Ensemble predictions from multiple experiments.
+
+    Args:
+        config_files (list): List of configuration file paths.
+        method (str): Ensemble method to use. Options are 'majority_voting', 'mean', 'max', or 'sum'.
+        no_labels (bool): Flag indicating whether the predictions have labels or not.
+
+    Returns:
+        pandas.DataFrame: The ensemble predictions.
+
+    Raises:
+        ValueError: If an unknown ensemble method is provided.
+        AssertionError: If the number of config files is less than 2 for majority voting.
+
+    """
+    ensemble_preds = []
+    # labels = []
+    for config_file in config_files:
+        if no_labels:
+            # for ensembling results from Nkululeko.demo
+            pred = pd.read_csv(config_file)
+            labels = pred.columns[1:-2]
+        else:
+            # for ensembling results from Nkululeko.nkululeko
+            config = configparser.ConfigParser()
+            config.read(config_file)
+            expr = Experiment(config)
+            module = "ensemble"
+            expr.set_module(module)
+            util = Util(module, has_config=True)
+            util.debug(
+                f"running {expr.name} from config {config_file}, nkululeko version"
+                f" {VERSION}"
+            )
+
+            # get labels
+            labels = expr.util.get_labels()
+            # load the experiment
+            # get CSV files of predictions
+            pred = expr.util.get_pred_name()
+            print(f"Loading predictions from {pred}")
+            preds = pd.read_csv(pred)
+
+        ensemble_preds.append(preds)
+
+    # pd concate
+    ensemble_preds = pd.concat(ensemble_preds, axis=1)
+
+    if method == "majority_voting":
+        # majority voting, get mode, works for odd number of models
+        # raise error when number of configs only two:
+        assert (
+            len(config_files) > 2
+        ), "Majority voting only works for more than two models"
+        ensemble_preds["predicted"] = ensemble_preds.mode(axis=1)[0]
+
+    elif method == "mean":
+        for label in labels:
+            ensemble_preds[label] = ensemble_preds[label].mean(axis=1)
+
+    elif method == "max":
+        for label in labels:
+            ensemble_preds[label] = ensemble_preds[label].max(axis=1)
+            # get max value from all labels to inver that labels
+
+    elif method == "sum":
+        for label in labels:
+            ensemble_preds[label] = ensemble_preds[label].sum(axis=1)
+
+    else:
+        raise ValueError(f"Unknown ensemble method: {method}")
+
+    # get the highest value from all labels to inver that labels
+    # replace the old first predicted column
+    ensemble_preds["predicted"] = ensemble_preds[labels].idxmax(axis=1)
+
+    if no_labels:
+        return ensemble_preds
+
+    # Drop start, end columns
+    ensemble_preds = ensemble_preds.drop(columns=["start", "end"])
+
+    # Drop other column except until truth
+    ensemble_preds = ensemble_preds.iloc[:, : len(labels) + 3]
+
+    # calculate UAR from predicted and truth columns
+
+    truth = ensemble_preds["truth"]
+    predicted = ensemble_preds["predicted"]
+    uar = (truth == predicted).mean()
+    Util("ensemble").debug(f"UAR: {uar:.3f}")
+
+    # only return until 'predicted' column
+    return ensemble_preds
+
+
+def main(src_dir):
+    parser = ArgumentParser()
+    parser.add_argument(
+        "configs",
+        nargs="+",
+        help="Paths to the configuration files of the experiments to ensemble. \
+             Can be INI files for Nkululeko.nkululeo or CSV files from Nkululeko.demo.",
+    )
+    parser.add_argument(
+        "--method",
+        default="majority_voting",
+        choices=["majority_voting", "mean", "max", "sum"],
+        help="Ensemble method to use (default: majority_voting)",
+    )
+    parser.add_argument(
+        "--outfile",
+        default="ensemble_result.csv",
+        help="Output file path for the ensemble predictions (default: ensemble_predictions.csv)",
+    )
+
+    # add argument if true label is not available
+    parser.add_argument(
+        "--no_labels",
+        action="store_true",
+        help="True if true labels are not available. For Nkululeko.demo results.",
+    )
+
+    args = parser.parse_args()
+
+    start = time.time()
+
+    ensemble_preds = ensemble_predictions(args.configs, args.method, args.no_labels)
+
+    # save to csv
+    ensemble_preds.to_csv(args.outfile, index=False)
+    print(f"Ensemble predictions saved to: {args.outfile}")
+    print(f"Ensemble done, used {time.time()-start:.2f} seconds")
+
+    print("DONE")
+
+
+if __name__ == "__main__":
+    cwd = Path(__file__).parent
+    main(cwd)

nkululeko/feat_extract/feats_ast.py

@@ -0,0 +1,118 @@
+# feats_ast.py
+import os
+
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn.functional as F
+import torchaudio
+from tqdm import tqdm
+from transformers import AutoProcessor, ASTModel
+
+import nkululeko.glob_conf as glob_conf
+from nkululeko.feat_extract.featureset import Featureset
+
+
+class Ast(Featureset):
+    """Class to extract AST (Audio Spectrogram Transformer) embeddings"""
+
+    def __init__(self, name, data_df, feat_type):
+        super().__init__(name, data_df, feat_type)
+        cuda = "cuda" if torch.cuda.is_available() else "cpu"
+        self.device = self.util.config_val("MODEL", "device", cuda)
+        self.model_initialized = False
+        self.feat_type = feat_type
+
+    def init_model(self):
+        self.util.debug("loading AST model...")
+        model_path = self.util.config_val(
+            "FEATS", "ast.model", "MIT/ast-finetuned-audioset-10-10-0.4593"
+        )
+        self.processor = AutoProcessor.from_pretrained(model_path)
+        self.model = ASTModel.from_pretrained(model_path).to(self.device)
+        print(f"initialized AST model on {self.device}")
+        self.model.eval()
+        self.model_initialized = True
+
+
+    def extract(self):
+        """Extract the features or load them from disk if present."""
+        store = self.util.get_path("store")
+        storage = f"{store}{self.name}.pkl"
+        extract = self.util.config_val("FEATS", "needs_feature_extraction", False)
+        no_reuse = eval(self.util.config_val("FEATS", "no_reuse", "False"))
+        if extract or no_reuse or not os.path.isfile(storage):
+            if not self.model_initialized:
+                self.init_model()
+            self.util.debug("extracting wavlm embeddings, this might take a while...")
+            emb_series = pd.Series(index=self.data_df.index, dtype=object)
+            length = len(self.data_df.index)
+            for idx, (file, start, end) in enumerate(
+                tqdm(self.data_df.index.to_list())
+            ):
+                signal, sampling_rate = torchaudio.load(
+                    file,
+                    frame_offset=int(start.total_seconds() * 16000),
+                    num_frames=int((end - start).total_seconds() * 16000),
+                )
+                # make mono if stereo
+                if signal.shape[0] == 2:
+                    signal = torch.mean(signal, dim=0, keepdim=True)
+
+                assert (
+                    sampling_rate == 16000
+                ), f"sampling rate should be 16000 but is {sampling_rate}"
+                emb = self.get_embeddings(signal, sampling_rate, file)
+                emb_series.iloc[idx] = emb
+            self.df = pd.DataFrame(emb_series.values.tolist(), index=self.data_df.index)
+            self.df.to_pickle(storage)
+            try:
+                glob_conf.config["DATA"]["needs_feature_extraction"] = "false"
+            except KeyError:
+                pass
+        else:
+            self.util.debug(f"reusing extracted {self.feat_type} embeddings")
+            self.df = pd.read_pickle(storage)
+            if self.df.isnull().values.any():
+                # nanrows = self.df.columns[self.df.isna().any()].tolist()
+                # print(nanrows)
+                self.util.error(
+                    f"got nan: {self.df.shape} {self.df.isnull().sum().sum()}"
+                )
+
+
+    def get_embeddings(self, signal, sampling_rate, file):
+        """Extract embeddings from raw audio signal."""
+        try:
+            inputs = self.processor(signal.numpy(), sampling_rate=sampling_rate, return_tensors="pt")
+
+            inputs = {k: v.to(self.device) for k, v in inputs.items()}
+
+            with torch.no_grad():
+                # Get the hidden states
+                outputs = self.model(**inputs)
+
+            # Get the hidden states from the last layer
+            last_hidden_state = outputs.last_hidden_state
+
+            # print(f"last_hidden_state shape: {last_hidden_state.shape}")
+            # Average pooling over the time dimension
+            embeddings = torch.mean(last_hidden_state, dim=1)
+            embeddings = embeddings.cpu().numpy()
+
+            # convert the same from (768,) to (1, 768)
+            # embeddings = embeddings.reshape(1, -1)
+            print(f"hs shape: {embeddings.shape}")
+            
+        
+        except Exception as e:
+            self.util.error(f"Error extracting embeddings for file {file}: {str(e)}, fill with")
+            return np.zeros(
+                self.model.config.hidden_size
+            )  # Return zero vector on error
+        return embeddings.ravel()
+    
+    def extract_sample(self, signal, sr):
+        self.init_model()
+        feats = self.get_embeddings(signal, sr, "no file")
+        return feats

nkululeko/feat_extract/feats_wav2vec2.py

@@ -47,9 +47,7 @@ class Wav2vec2(Featureset):
         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
-        )
+        self.model = Wav2Vec2Model.from_pretrained(model_path, config=config).to(self.device)
         print(f"intialized Wav2vec model on {self.device}")
         self.model.eval()
         self.model_initialized = True
@@ -90,7 +88,7 @@ class Wav2vec2(Featureset):
             self.util.debug("reusing extracted wav2vec2 embeddings")
             self.df = pd.read_pickle(storage)
             if self.df.isnull().values.any():
-                nanrows = self.df.columns[self.df.isna().any()].tolist()
+                # nanrows = self.df.columns[self.df.isna().any()].tolist()
                 # print(nanrows)
                 self.util.error(
                     f"got nan: {self.df.shape} {self.df.isnull().sum().sum()}"

nkululeko/feat_extract/feats_wavlm.py

@@ -79,8 +79,8 @@ class Wavlm(Featureset):
             self.util.debug(f"reusing extracted {self.feat_type} embeddings")
             self.df = pd.read_pickle(storage)
             if self.df.isnull().values.any():
-                nanrows = self.df.columns[self.df.isna().any()].tolist()
-                print(nanrows)
+                # nanrows = self.df.columns[self.df.isna().any()].tolist()
+                # print(nanrows)
                 self.util.error(
                     f"got nan: {self.df.shape} {self.df.isnull().sum().sum()}"
                 )
@@ -104,11 +104,14 @@ class Wavlm(Featureset):
                 # pool result and convert to numpy
                 y = torch.mean(y, dim=1)
                 y = y.detach().cpu().numpy()
+
+                # print(f"hs shape: {y.shape}")
+
         except RuntimeError as re:
             print(str(re))
-            self.util.error(f"couldn't extract file: {file}")
+            self.util.error(f"Couldn't extract file: {file}")
 
-        return y.flatten()
+        return y.ravel()
 
     def extract_sample(self, signal, sr):
         self.init_model()

nkululeko/feature_extractor.py

@@ -39,12 +39,10 @@ class FeatureExtractor:
         self.feats = pd.DataFrame()
         for feats_type in self.feats_types:
             store_name = f"{self.data_name}_{feats_type}"
-            self.feat_extractor = self._get_feat_extractor(
-                store_name, feats_type)
+            self.feat_extractor = self._get_feat_extractor(store_name, feats_type)
             self.feat_extractor.extract()
             self.feat_extractor.filter()
-            self.feats = pd.concat(
-                [self.feats, self.feat_extractor.df], axis=1)
+            self.feats = pd.concat([self.feats, self.feat_extractor.df], axis=1)
         return self.feats
 
     def extract_sample(self, signal, sr):
@@ -77,7 +75,7 @@ class FeatureExtractor:
             return TRILLset
 
         elif feats_type.startswith(
-            ("wav2vec2", "hubert", "wavlm", "spkrec", "whisper")
+            ("wav2vec2", "hubert", "wavlm", "spkrec", "whisper", "ast")
         ):
             return self._get_feat_extractor_by_prefix(feats_type)
 
@@ -107,15 +105,13 @@ class FeatureExtractor:
         prefix, _, ext = feats_type.partition("-")
         from importlib import import_module
 
-        module = import_module(
-            f"nkululeko.feat_extract.feats_{prefix.lower()}")
+        module = import_module(f"nkululeko.feat_extract.feats_{prefix.lower()}")
         class_name = f"{prefix.capitalize()}"
         return getattr(module, class_name)
 
     def _get_feat_extractor_by_name(self, feats_type):
         from importlib import import_module
 
-        module = import_module(
-            f"nkululeko.feat_extract.feats_{feats_type.lower()}")
+        module = import_module(f"nkululeko.feat_extract.feats_{feats_type.lower()}")
         class_name = f"{feats_type.capitalize()}Set"
         return getattr(module, class_name)

nkululeko/test_predictor.py

@@ -6,13 +6,12 @@
 
 import ast
 
-import numpy as np
 import pandas as pd
 from sklearn.preprocessing import LabelEncoder
 
+import nkululeko.glob_conf as glob_conf
 from nkululeko.data.dataset import Dataset
 from nkululeko.feature_extractor import FeatureExtractor
-import nkululeko.glob_conf as glob_conf
 from nkululeko.scaler import Scaler
 from nkululeko.utils.util import Util
 
@@ -42,7 +41,6 @@ class TestPredictor:
             scale = self.util.config_val("FEATS", "scale", False)
             labelenc = LabelEncoder()
             data_df[self.target] = labelenc.fit_transform(data_df[self.target])
-            #            data_df[self.target] = self.label_encoder.fit_transform(data_df[self.target])
             if scale:
                 self.scaler = Scaler(data_df, None, feats_df, None, scale)
                 feats_df, _ = self.scaler.scale()

nkululeko/utils/util.py

@@ -37,8 +37,7 @@ class Util:
                 import nkululeko.glob_conf as glob_conf
 
                 self.config = glob_conf.config
-                self.got_data_roots = self.config_val(
-                    "DATA", "root_folders", False)
+                self.got_data_roots = self.config_val("DATA", "root_folders", False)
                 if self.got_data_roots:
                     # if there is a global data rootfolder file, read from
                     # there
@@ -108,19 +107,17 @@ class Util:
             if self.got_data_roots:
                 try:
                     if len(key) > 0:
-                        return self.data_roots["DATA"][dataset +
-                                                       "." + key].strip("'\"")
+                        return self.data_roots["DATA"][dataset + "." + key].strip("'\"")
                     else:
                         return self.data_roots["DATA"][dataset].strip("'\"")
                 except KeyError:
                     if default not in self.stopvals:
                         self.debug(
-                            f"value for {key} not found, using default:"
-                            f" {default}")
+                            f"value for {key} not found, using default:" f" {default}"
+                        )
                     return default
             if default not in self.stopvals:
-                self.debug(
-                    f"value for {key} not found, using default: {default}")
+                self.debug(f"value for {key} not found, using default: {default}")
             return default
 
     def set_config(self, config):
@@ -131,6 +128,10 @@ class Util:
         store = self.get_path("store")
         return f"{store}/{self.get_exp_name()}.pkl"
 
+    def get_pred_name(self):
+        store = self.get_path("store")
+        return f"{store}/pred_df.csv"
+
     def is_categorical(self, pd_series):
         """Check if a dataframe column is categorical"""
         return pd_series.dtype.name == "object" or isinstance(
@@ -163,10 +164,8 @@ class Util:
         if len(df) == 0:
             return df
         if not isinstance(df.index, pd.MultiIndex):
-            self.debug(
-                "converting to segmented index, this might take a while...")
-            df.index = audformat.utils.to_segmented_index(
-                df.index, allow_nat=False)
+            self.debug("converting to segmented index, this might take a while...")
+            df.index = audformat.utils.to_segmented_index(df.index, allow_nat=False)
         return df
 
     def _get_value_descript(self, section, name):
@@ -209,7 +208,11 @@ class Util:
         mt = f'{self.config["MODEL"]["type"]}'
         # ft = "_".join(ast.literal_eval(self.config["FEATS"]["type"]))
         ft_value = self.config["FEATS"]["type"]
-        if isinstance(ft_value, str) and ft_value.startswith("[") and ft_value.endswith("]"):
+        if (
+            isinstance(ft_value, str)
+            and ft_value.startswith("[")
+            and ft_value.endswith("]")
+        ):
             ft = "_".join(ast.literal_eval(ft_value))
         else:
             ft = ft_value
@@ -237,8 +240,9 @@ class Util:
             ["FEATS", "wav2vec2.layer"],
         ]
         for option in options:
-            return_string += self._get_value_descript(
-                option[0], option[1]).replace(".", "-")
+            return_string += self._get_value_descript(option[0], option[1]).replace(
+                ".", "-"
+            )
         return return_string
 
     def get_plot_name(self):
@@ -284,8 +288,7 @@ class Util:
             return self.config[section][key]
         except KeyError:
             if default not in self.stopvals:
-                self.debug(
-                    f"value for {key} not found, using default: {default}")
+                self.debug(f"value for {key} not found, using default: {default}")
             return default
 
     def config_val_list(self, section, key, default):
@@ -293,10 +296,12 @@ class Util:
             return ast.literal_eval(self.config[section][key])
         except KeyError:
             if default not in self.stopvals:
-                self.debug(
-                    f"value for {key} not found, using default: {default}")
+                self.debug(f"value for {key} not found, using default: {default}")
             return default
 
+    def get_labels(self):
+        return ast.literal_eval(self.config["DATA"]["labels"])
+
     def continuous_to_categorical(self, series):
         """
         discretize a categorical variable.

{nkululeko-0.87.0.dist-info → nkululeko-0.88.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nkululeko
-Version: 0.87.0
+Version: 0.88.0
 Summary: Machine learning audio prediction experiments based on templates
 Home-page: https://github.com/felixbur/nkululeko
 Author: Felix Burkhardt
@@ -201,6 +201,11 @@ Here is an overview of the interfaces/modules:
 All of them take *--config <my_config.ini>* as an argument.
 
 * **nkululeko.nkululeko**: do machine learning experiments combining features and learners
+* **nkululeko.ensemble**: combine several nkululeko experiments and report on late fusion results
+  * *configurations*: which experiments to combine
+  * *--method* (optional): majority_voting, mean, max, sum
+  * *--outfile* (optional): name of CSV file for output
+  * *--no_labels* (optional): indicate that no ground truth is given 
 * **nkululeko.multidb**: do [multiple experiments](http://blog.syntheticspeech.de/2024/01/02/nkululeko-compare-several-databases/), comparing several databases cross and in itself
 * **nkululeko.demo**: [demo the current best model](http://blog.syntheticspeech.de/2022/01/24/nkululeko-try-out-demo-a-trained-model/) on the command line
   * *--list* (optional) list of input files
@@ -351,6 +356,10 @@ F. Burkhardt, Johannes Wagner, Hagen Wierstorf, Florian Eyben and Björn Schulle
 Changelog
 =========
 
+Version 0.88.0
+--------------
+* added ensemble late fusion and AST features
+
 Version 0.87.0
 --------------
 * added class probability output and uncertainty analysis

{nkululeko-0.87.0.dist-info → nkululeko-0.88.0.dist-info}/RECORD

@@ -2,14 +2,15 @@ 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=qVowcvAZL-g-Bsp_4yBCOQDkCoW-S-1wrRG5XgnjnX0,39
-nkululeko/demo.py,sha256=Sqbu3o6Pzdr_UlYxWM8Mn3l5uCXsw429yJbtkVDUYHU,5087
+nkululeko/constants.py,sha256=KhD5BoAv4ItEdg4vSAq1wew4zjdCOGPQxR6syd9NoEo,39
+nkululeko/demo.py,sha256=bLuHkeEl5rOfm7ecGHCcWATiPK7-njNbtrGljxzNzFs,5088
 nkululeko/demo_feats.py,sha256=sAeGFojhEj9WEDFtG3SzPBmyYJWLF2rkbpp65m8Ujo4,2025
 nkululeko/demo_predictor.py,sha256=es56xbT8ifkS_vnrlb5NTZT54gNmeUtNlA4zVA_gnN8,4757
+nkululeko/ensemble.py,sha256=huRbXUuabm6QYxGBHjkwEU95e-0qxtO0Z6UdXFgtaMY,4947
 nkululeko/experiment.py,sha256=s9PIjm45dR9yzmHu_69JpBjX9qMVzi5wIgPfMR3F44A,31530
 nkululeko/explore.py,sha256=lDzRoW_Taa5u4BBABZLD89BcQWnYlrftJR4jgt1yyj0,2609
 nkululeko/export.py,sha256=mHeEAAmtZuxdyebLlbSzPrHSi9OMgJHbk35d3DTxRBc,4632
-nkululeko/feature_extractor.py,sha256=rL-TybLmjZz5uxT9LNTORaDat9FKp_1qloxbyMrinyE,4141
+nkululeko/feature_extractor.py,sha256=UnspIWz3XrNhKnBBhWZkH2bHvD-sROtrQVqB1JvkUyw,4088
 nkululeko/file_checker.py,sha256=LoLnL8aHpW-axMQ46qbqrManTs5otG9ShpEZuz9iRSk,3474
 nkululeko/filter_data.py,sha256=w-X2mhKdYr5DxDIz50E5yzO6Jmzk4jjDBoXsgOOVtcA,7222
 nkululeko/glob_conf.py,sha256=KL9YJQTHvTztxo1vr25qRRgaPnx4NTg0XrdbovKGMmw,525
@@ -25,7 +26,7 @@ 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=1w624vo5KTzmFC8BUStGlLDmIEAFuJUz7J0W-gp7AxI,1677
-nkululeko/test_predictor.py,sha256=KaGef_r4mXW89f0aUiYDw8IiBe2ciGt14HNkR-S14lU,2985
+nkululeko/test_predictor.py,sha256=DEHE_D3A6m6KJTrpDKceA1n655t_UZV3WQd57K4a3Ho,2863
 nkululeko/test_pretrain.py,sha256=ZWl-bR6nmeSmXkGAIE6zyfQEjN8Zg0rIxfaS-O6Zbas,8465
 nkululeko/augmenting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nkululeko/augmenting/augmenter.py,sha256=XAt0dpmlnKxqyysqCgV3rcz-pRIvOz7rU7dmGDCVAzs,2905
@@ -51,6 +52,7 @@ nkululeko/feat_extract/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 nkululeko/feat_extract/feats_agender.py,sha256=Qm69G4kqAyTVVk7wwRgrXlNwGaDMGRYyKGpuf0vOEgM,3113
 nkululeko/feat_extract/feats_agender_agender.py,sha256=tgH2BnwcxpvuLmOkrMbVdBSX0Onfz2MG12FsddalRKI,3424
 nkululeko/feat_extract/feats_analyser.py,sha256=Y9hMpZ9WsQOrxTP3B1diHnzMeOgwbVpVFWVlIyhHMJs,12722
+nkululeko/feat_extract/feats_ast.py,sha256=LolDaRTfNB9L8-CUqz9tOfkXntL8c9GJs4kqMmg5BSo,4724
 nkululeko/feat_extract/feats_auddim.py,sha256=VlzKKXTXa5kjLgQBWyEFy-daIyU1SkOwCCOIhKsWCvE,3162
 nkululeko/feat_extract/feats_audmodel.py,sha256=VjBNgAoxsHJhwr6Kwt9CxX6SaCM4RK_OV-GU2W5-bhU,3187
 nkululeko/feat_extract/feats_clap.py,sha256=nR6eEIRdsMHcfmD1bNtt5WfDvkxKjvEbukSSrXHm-HU,3489
@@ -66,8 +68,8 @@ nkululeko/feat_extract/feats_spectra.py,sha256=5Pex8awIQC3cjQRHSu4NQFmg4quamG0RL
 nkululeko/feat_extract/feats_spkrec.py,sha256=VK4ma3uWzM0YZStsgRTirfkbzjWIfRWSgsYI038QlRY,4803
 nkululeko/feat_extract/feats_squim.py,sha256=Y31YmDmscuG0YozvxyBZIutO3id8t7IZJWCfKucw-6M,4617
 nkululeko/feat_extract/feats_trill.py,sha256=K2ahhdpwpjgg3WZS1POg3UMP2U44i8cLZZvn5Rq7fUI,3228
-nkululeko/feat_extract/feats_wav2vec2.py,sha256=9WUMfyddB_3nx79g7mZoQrRynhM1uEBWuOotRq8bxoU,5268
-nkululeko/feat_extract/feats_wavlm.py,sha256=ulxpGjifUFx2ZgGmY32SmBJGIuvkYHoLb2n1LZ8KMwA,4703
+nkululeko/feat_extract/feats_wav2vec2.py,sha256=XyxD4NcrF4VFWSeHkXCKWdEOdr8VMzgVUz8N4mwhdyo,5248
+nkululeko/feat_extract/feats_wavlm.py,sha256=O9cfc39VF5aPJRRATKb37pHT4W11i2cu5O1mY9LOjIA,4755
 nkululeko/feat_extract/feats_whisper.py,sha256=0N7Vj65OVi2PNoB_NrDjWT5lP6xZNKxFOZZIoxkJvcA,4533
 nkululeko/feat_extract/featureset.py,sha256=ll7tyKAdr--TDShyOYJg0FB4I9NqBq0Ni1k_kUJ-2Vw,1541
 nkululeko/feat_extract/feinberg_praat.py,sha256=EP9pMALjlKdiYInLQdrZ7MmE499Mq-ISRCgqbqL3Rxc,21304
@@ -104,9 +106,9 @@ nkululeko/segmenting/seg_silero.py,sha256=lLytS38KzARS17omwv8VBw-zz60RVSXGSvZ5Ev
 nkululeko/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nkululeko/utils/files.py,sha256=UiGAtZRWYjHSvlmPaTMtzyNNGE6qaLaxQkybctS7iRM,4021
 nkululeko/utils/stats.py,sha256=eC9dMO-by6CDnGLHDBQu-2B4-BudZNJ0nnWGhKYdUMA,2968
-nkululeko/utils/util.py,sha256=ZCS02mE2c3_h9_q4hpsSm4XAooCranqRF_5pY-6055E,14432
-nkululeko-0.87.0.dist-info/LICENSE,sha256=0zGP5B_W35yAcGfHPS18Q2B8UhvLRY3dQq1MhpsJU_U,1076
-nkululeko-0.87.0.dist-info/METADATA,sha256=DPO61pORcuEhRsDwB5S5VJ8CK_piJeh-I5kKJc8eNJE,38442
-nkululeko-0.87.0.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
-nkululeko-0.87.0.dist-info/top_level.txt,sha256=DPFNNSHPjUeVKj44dVANAjuVGRCC3MusJ08lc2a8xFA,10
-nkululeko-0.87.0.dist-info/RECORD,,
+nkululeko/utils/util.py,sha256=eQkfd_3MO2JYis5QbROnCmhglQGkl4-F9TLCT1uiQH0,14514
+nkululeko-0.88.0.dist-info/LICENSE,sha256=0zGP5B_W35yAcGfHPS18Q2B8UhvLRY3dQq1MhpsJU_U,1076
+nkululeko-0.88.0.dist-info/METADATA,sha256=RTWqGxR2H8T7hM_h8PFAqnssBdfPxEjmB289vVMoEyo,38853
+nkululeko-0.88.0.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
+nkululeko-0.88.0.dist-info/top_level.txt,sha256=DPFNNSHPjUeVKj44dVANAjuVGRCC3MusJ08lc2a8xFA,10
+nkululeko-0.88.0.dist-info/RECORD,,

{nkululeko-0.87.0.dist-info → nkululeko-0.88.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.1.0)
+Generator: setuptools (70.1.1)
 Root-Is-Purelib: true
 Tag: py3-none-any