nkululeko 0.93.15__py3-none-any.whl → 0.94.0__py3-none-any.whl

nkululeko/feat_extract/feats_opensmile.py

@@ -1,93 +1,240 @@
 # opensmileset.py
+"""Module for extracting OpenSMILE features from audio files.
+OpenSMILE is an audio feature extraction toolkit supporting various feature sets.
+"""
 import os
+import logging
+from typing import Optional, Union, List, Any, Dict
 
 import opensmile
 import pandas as pd
+import numpy as np
 
 import nkululeko.glob_conf as glob_conf
 from nkululeko.feat_extract.featureset import Featureset
 
 
 class Opensmileset(Featureset):
-    def __init__(self, name, data_df, feats_type=None, config_file=None):
+    """Class for extracting OpenSMILE features from audio files.
+
+    This class provides methods to extract various OpenSMILE feature sets like eGeMAPSv02,
+    ComParE_2016, etc. at different feature levels (LowLevelDescriptors or Functionals).
+
+    Attributes:
+        featset (str): The OpenSMILE feature set to extract (e.g., 'eGeMAPSv02')
+        feature_set: The OpenSMILE feature set object
+        featlevel (str): The feature level ('LowLevelDescriptors' or 'Functionals')
+        feature_level: The OpenSMILE feature level object
+    """
+
+    # Available feature sets for validation
+    AVAILABLE_FEATURE_SETS = ["eGeMAPSv02", "ComParE_2016", "GeMAPSv01a", "eGeMAPSv01a"]
+
+    # Available feature levels for validation
+    AVAILABLE_FEATURE_LEVELS = ["LowLevelDescriptors", "Functionals"]
+
+    def __init__(
+        self,
+        name: str,
+        data_df: pd.DataFrame,
+        feats_type: Optional[str] = None,
+        config_file: Optional[str] = None,
+    ):
+        """Initialize the Opensmileset class.
+
+        Args:
+            name (str): Name of the feature set
+            data_df (pd.DataFrame): DataFrame containing audio file paths
+            feats_type (Optional[str]): Type of features to extract
+            config_file (Optional[str]): Configuration file path
+        """
         super().__init__(name, data_df, feats_type)
+
+        # Get feature set configuration
         self.featset = self.util.config_val("FEATS", "set", "eGeMAPSv02")
+
+        # Validate and set feature set
+        if self.featset not in self.AVAILABLE_FEATURE_SETS:
+            self.util.warning(
+                f"Feature set '{self.featset}' might not be supported. "
+                f"Available sets: {', '.join(self.AVAILABLE_FEATURE_SETS)}"
+            )
+
         try:
             self.feature_set = eval(f"opensmile.FeatureSet.{self.featset}")
-            # 'eGeMAPSv02, ComParE_2016, GeMAPSv01a, eGeMAPSv01a':
-        except AttributeError:
-            self.util.error(f"something is wrong with feature set: {self.featset}")
+        except (AttributeError, SyntaxError) as e:
+            self.util.error(f"Invalid feature set: {self.featset}. Error: {str(e)}")
+            raise ValueError(f"Invalid feature set: {self.featset}")
+
+        # Get feature level configuration
         self.featlevel = self.util.config_val("FEATS", "level", "functionals")
+
+        # Convert shorthand names to full OpenSMILE names
+        if self.featlevel == "lld":
+            self.featlevel = "LowLevelDescriptors"
+        elif self.featlevel == "functionals":
+            self.featlevel = "Functionals"
+
+        # Validate and set feature level
+        if self.featlevel not in self.AVAILABLE_FEATURE_LEVELS:
+            self.util.warning(
+                f"Feature level '{self.featlevel}' might not be supported. "
+                f"Available levels: {', '.join(self.AVAILABLE_FEATURE_LEVELS)}"
+            )
+
         try:
-            self.featlevel = self.featlevel.replace("lld", "LowLevelDescriptors")
-            self.featlevel = self.featlevel.replace("functionals", "Functionals")
             self.feature_level = eval(f"opensmile.FeatureLevel.{self.featlevel}")
-        except AttributeError:
-            self.util.error(f"something is wrong with feature level: {self.featlevel}")
+        except (AttributeError, SyntaxError) as e:
+            self.util.error(f"Invalid feature level: {self.featlevel}. Error: {str(e)}")
+            raise ValueError(f"Invalid feature level: {self.featlevel}")
+
+    def extract(self) -> pd.DataFrame:
+        """Extract the features based on the initialized dataset or load them from disk if available.
+
+        This method checks if features are already stored on disk and loads them if available,
+        otherwise it extracts features using OpenSMILE.
 
-    def extract(self):
-        """Extract the features based on the initialized dataset or re-open them when found on disk."""
+        Returns:
+            pd.DataFrame: DataFrame containing the extracted features
+
+        Raises:
+            RuntimeError: If feature extraction fails
+        """
         store = self.util.get_path("store")
         store_format = self.util.config_val("FEATS", "store_format", "pkl")
         storage = f"{store}{self.name}.{store_format}"
+
+        # Check if we need to extract features or use existing ones
         extract = eval(
             self.util.config_val("FEATS", "needs_feature_extraction", "False")
         )
         no_reuse = eval(self.util.config_val("FEATS", "no_reuse", "False"))
+
         if extract or not os.path.isfile(storage) or no_reuse:
-            self.util.debug("extracting openSmile features, this might take a while...")
+            self.util.debug("Extracting OpenSMILE features, this might take a while...")
+
+            try:
+                smile = opensmile.Smile(
+                    feature_set=self.feature_set,
+                    feature_level=self.feature_level,
+                    num_workers=self.n_jobs,
+                    verbose=True,
+                )
+
+                # Extract features based on index type
+                if isinstance(self.data_df.index, pd.MultiIndex):
+                    self.df = smile.process_index(self.data_df.index)
+                    self.df = self.df.set_index(self.data_df.index)
+                else:
+                    self.df = smile.process_files(self.data_df.index)
+                    # Clean up the index
+                    if self.df.index.nlevels > 1:
+                        self.df.index = self.df.index.droplevel(1)
+                        self.df.index = self.df.index.droplevel(1)
+
+                # Save extracted features
+                self.util.write_store(self.df, storage, store_format)
+
+                # Update configuration to avoid re-extraction
+                try:
+                    glob_conf.config["DATA"]["needs_feature_extraction"] = "False"
+                except KeyError:
+                    pass
+
+            except Exception as e:
+                self.util.error(f"Feature extraction failed: {str(e)}")
+                raise RuntimeError(f"Feature extraction failed: {str(e)}")
+
+        else:
+            self.util.debug(f"Reusing extracted OpenSMILE features from: {storage}")
+            try:
+                self.df = self.util.get_store(storage, store_format)
+            except Exception as e:
+                self.util.error(f"Failed to load stored features: {str(e)}")
+                raise RuntimeError(f"Failed to load stored features: {str(e)}")
+
+        return self.df
+
+    def extract_sample(self, signal: np.ndarray, sr: int) -> np.ndarray:
+        """Extract features from a single audio sample.
+
+        Args:
+            signal (np.ndarray): Audio signal as numpy array
+            sr (int): Sample rate of the audio signal
+
+        Returns:
+            np.ndarray: Extracted features as numpy array
+
+        Raises:
+            ValueError: If signal or sample rate is invalid
+        """
+        if signal is None or len(signal) == 0:
+            raise ValueError("Empty or invalid audio signal provided")
+
+        if sr <= 0:
+            raise ValueError(f"Invalid sample rate: {sr}")
+
+        try:
             smile = opensmile.Smile(
                 feature_set=self.feature_set,
-                feature_level=self.feature_level,
-                num_workers=self.n_jobs,
-                verbose=True,
+                feature_level=opensmile.FeatureLevel.Functionals,
             )
-            if isinstance(self.data_df.index, pd.MultiIndex):
-                self.df = smile.process_index(self.data_df.index)
-                self.df = self.df.set_index(self.data_df.index)
-            else:
-                self.df = smile.process_files(self.data_df.index)
-                self.df.index = self.df.index.droplevel(1)
-                self.df.index = self.df.index.droplevel(1)
-            self.util.write_store(self.df, storage, store_format)
+            feats = smile.process_signal(signal, sr)
+            return feats.to_numpy()
+        except Exception as e:
+            self.util.error(f"Failed to extract features from sample: {str(e)}")
+            raise RuntimeError(f"Failed to extract features from sample: {str(e)}")
+
+    def filter_features(self, feature_list: List[str] = None) -> pd.DataFrame:
+        """Filter the extracted features to keep only the specified ones.
+
+        Args:
+            feature_list (List[str], optional): List of feature names to keep.
+                If None, uses the list from config.
+
+        Returns:
+            pd.DataFrame: Filtered features DataFrame
+        """
+        # First ensure we're only using features indexed in the target dataframes
+        self.df = self.df[self.df.index.isin(self.data_df.index)]
+
+        if feature_list is None:
+            try:
+                # Try to get feature list from config
+                import ast
+
+                feature_list = ast.literal_eval(
+                    glob_conf.config["FEATS"]["os.features"]
+                )
+            except (KeyError, ValueError, SyntaxError):
+                self.util.debug("No feature list specified, using all features")
+                return self.df
+
+        if not feature_list:
+            return self.df
+
+        self.util.debug(f"Selecting features from OpenSMILE: {feature_list}")
+        sel_feats_df = pd.DataFrame(index=self.df.index)
+        hit = False
+
+        for feat in feature_list:
             try:
-                glob_conf.config["DATA"]["needs_feature_extraction"] = "False"
+                sel_feats_df[feat] = self.df[feat]
+                hit = True
             except KeyError:
-                pass
-        else:
-            self.util.debug(f"reusing extracted OS features: {storage}.")
-            self.df = self.util.get_store(storage, store_format)
+                self.util.warning(f"Feature '{feat}' not found in extracted features")
 
-    def extract_sample(self, signal, sr):
-        smile = opensmile.Smile(
-            feature_set=self.feature_set,
-            feature_level=opensmile.FeatureLevel.Functionals,
-        )
-        feats = smile.process_signal(signal, sr)
-        return feats.to_numpy()
-
-    # def filter(self):
-    #     # use only the features that are indexed in the target dataframes
-    #     self.df = self.df[self.df.index.isin(self.data_df.index)]
-    #     try:
-    #         # use only some features
-    #         selected_features = ast.literal_eval(
-    #             glob_conf.config["FEATS"]["os.features"]
-    #         )
-    #         self.util.debug(f"selecting features from opensmile: {selected_features}")
-    #         sel_feats_df = pd.DataFrame()
-    #         hit = False
-    #         for feat in selected_features:
-    #             try:
-    #                 sel_feats_df[feat] = self.df[feat]
-    #                 hit = True
-    #             except KeyError:
-    #                 pass
-    #         if hit:
-    #             self.df = sel_feats_df
-    #             self.util.debug(
-    #                 "new feats shape after selecting opensmile features:"
-    #                 f" {self.df.shape}"
-    #             )
-    #     except KeyError:
-    #         pass
+        if hit:
+            self.df = sel_feats_df
+            self.util.debug(f"New feature shape after selection: {self.df.shape}")
+
+        return self.df
+
+    @staticmethod
+    def get_available_feature_sets() -> List[str]:
+        """Get a list of available OpenSMILE feature sets.
+
+        Returns:
+            List[str]: List of available feature sets
+        """
+        return Opensmileset.AVAILABLE_FEATURE_SETS

nkululeko/feat_extract/feats_trill.py

@@ -4,8 +4,8 @@ import os
 import audiofile as af
 import pandas as pd
 
-# import tensorflow as tf
-# import tensorflow_hub as hub
+import tensorflow as tf
+import tensorflow_hub as hub
 from tqdm import tqdm
 
 import nkululeko.glob_conf as glob_conf

nkululeko/modelrunner.py

@@ -53,8 +53,6 @@ class Modelrunner:
             # epochs are handled by Huggingface API
             self.model.train()
             report = self.model.predict()
-            # todo: findout the best epoch -> no need
-            # since load_best_model_at_end is given in training args
             epoch = epoch_num
             report.set_id(self.run, epoch)
             plot_name = self.util.get_plot_name() + f"_{self.run}_{epoch:03d}_cnf"
@@ -118,16 +116,31 @@ class Modelrunner:
                             f"reached patience ({str(patience)}): early stopping"
                         )
                         break
-        # After training, report the best performance and epoch
-        last_report = reports[-1]
-        # self.util.debug(f"Best score at epoch: {self.best_epoch}, UAR: {self.best_performance}") # move to reporter below
-
-        if not plot_epochs:
-            # Do at least one confusion matrix plot
-            self.util.debug(f"plotting last confusion matrix to {plot_name}")
-            last_report.plot_confmatrix(plot_name, epoch_index)
         return reports, epoch
 
+    def eval_last_model(self, df_test, feats_test):
+        self.model.reset_test(df_test, feats_test)
+        report = self.model.predict()
+        report.set_id(self.run, 0)
+        return report
+
+    def eval_specific_model(self, model, df_test, feats_test):
+        self.model = model
+        self.util.debug(f"evaluating model: {self.model.store_path}")
+        self.model.reset_test(df_test, feats_test)
+        report = self.model.predict()
+        report.set_id(self.run, 0)
+        return report
+
+    def _check_balancing(self):
+        if self.util.config_val("EXP", "balancing", False):
+            self.util.debug("balancing data")
+            self.df_train, self.df_test = self.util.balance_data(
+                self.df_train, self.df_test
+            )
+            self.util.debug(f"new train size: {self.df_train.shape}")
+            self.util.debug(f"new test size: {self.df_test.shape}")
+
     def _select_model(self, model_type):
         self._check_balancing()
 

nkululeko/models/model_mlp.py

@@ -95,6 +95,8 @@ class MLPModel(Model):
 
     def reset_test(self, df_test, feats_test):
         self.testloader = self.get_loader(feats_test, df_test, False)
+        self.df_test = df_test
+        self.feats_test = feats_test
 
     def train(self):
         self.model.train()

nkululeko/nkululeko.py

@@ -41,7 +41,6 @@ def doit(config_file):
 
     # 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}")
 
     # extract features
     expr.extract_feats()

nkululeko/plots.py

@@ -303,6 +303,7 @@ class Plots:
             plot_df = plot_df.rename(columns={cont_col: self.target})
             cont_col = self.target
         dist_type = self.util.config_val("EXPL", "dist_type", "kde")
+        fill_areas = eval(self.util.config_val("PLOT", "fill_areas", "False"))
         max_cat, cat_str, effect_results = su.get_effect_size(
             plot_df, cat_col, cont_col
         )
@@ -324,7 +325,7 @@ class Plots:
                 x=cont_col,
                 hue=cat_col,
                 kind="kde",
-                fill=True,
+                fill=fill_areas,
                 warn_singular=False,
             )
             ax.set(xlabel=f"{cont_col}")
@@ -604,9 +605,17 @@ class Plots:
             df_plot = pd.DataFrame(
                 {label: df_labels[label], feature: df_features[feature]}
             )
+            p_val = ""
+            if df_labels[label].nunique() == 2:
+                label_1 = df_labels[label].unique()[0]
+                label_2 = df_labels[label].unique()[1]
+                vals_1 = df_plot[df_plot[label] == label_1][feature].values
+                vals_2 = df_plot[df_plot[label] == label_2][feature].values
+                r_stats = stats.mannwhitneyu(vals_1, vals_2, alternative="two-sided")
+                p_val = f", Mann-Whitney p-val: {r_stats.pvalue:.3f}"
             ax = sns.violinplot(data=df_plot, x=label, y=feature)
             label = self.util.config_val("DATA", "target", "class_label")
-            ax.set(title=f"{title} samples", xlabel=label)
+            ax.set(title=f"{title} samples {p_val}", xlabel=label)
         else:
             plot_df = pd.concat([df_labels, df_features], axis=1)
             ax, caption = self._plot2cont(plot_df, label, feature, feature)

nkululeko/reporting/reporter.py

@@ -138,7 +138,7 @@ class Reporter:
             self.util.error(f"unknown metric: {self.metric}")
         return test_result, upper, lower
 
-    def print_probabilities(self):
+    def print_probabilities(self, file_name = None):
         """Print the probabilities per class to a file in the store."""
         if (
             self.util.exp_is_classification()
@@ -168,11 +168,11 @@ class Reporter:
             )
             probas["uncertainty"] = uncertainty
             probas["correct"] = probas.predicted == probas.truth
-            sp = self.util.get_pred_name()
-
+            if file_name is None:
+                file_name = self.util.get_pred_name()+".csv"
             self.probas = probas
-            probas.to_csv(sp)
-            self.util.debug(f"Saved probabilities to {sp}")
+            probas.to_csv(file_name)
+            self.util.debug(f"Saved probabilities to {file_name}")
             plots = Plots()
             ax, caption = plots.plotcatcont(
                 probas, "correct", "uncertainty", "uncertainty", "correct"
@@ -182,7 +182,7 @@ class Reporter:
                 caption,
                 "Uncertainty",
                 "uncertainty_samples",
-                self.util.get_exp_name(),
+                file_name,
             )
 
     def set_id(self, run, epoch):
@@ -368,7 +368,7 @@ class Reporter:
 
         res_dir = self.util.get_path("res_dir")
         rpt = (
-            f"Best score at epoch: {epoch}, UAR: {uar_str}"
+            f"Confusion matrix result for epoch: {epoch}, UAR: {uar_str}"
             + f", (+-{up_str}/{low_str}), ACC: {acc_str}"
         )
         # print(rpt)
@@ -392,13 +392,16 @@ class Reporter:
             text_file.write(result_str)
         self.util.debug(result_str)
 
-    def print_results(self, epoch=None):
+    def print_results(self, epoch=None, file_name = None):
         if epoch is None:
             epoch = self.epoch
         """Print all evaluation values to text file."""
         res_dir = self.util.get_path("res_dir")
-        fig_dir = self.util.get_path("fig_dir")
-        file_name = f"{res_dir}{self.util.get_exp_name()}_{epoch}{self.filenameadd}.txt"
+        if file_name is None:
+            file_name = f"{res_dir}{self.util.get_exp_name()}_{epoch}{self.filenameadd}.txt"
+        else:
+            self.util.debug(f"####->{file_name}<-####")
+            file_name = f"{res_dir}{file_name}{self.filenameadd}.txt"
         if self.util.exp_is_classification():
             labels = glob_conf.labels
             try:
@@ -427,25 +430,6 @@ class Reporter:
                 f1_per_class = (
                     f"result per class (F1 score): {c_ress} from epoch: {epoch}"
                 )
-                # the following auc is buggy, preds should be probabilities
-                # if len(np.unique(self.truths)) == 2:
-                #     fpr, tpr, _ = roc_curve(self.truths, self.preds)
-                #     auc_score = auc(fpr, tpr)
-                #     plot_path = f"{fig_dir}{self.util.get_exp_name()}_{epoch}{self.filenameadd}_roc.{self.format}"
-                #     plt.figure()
-                #     display = RocCurveDisplay(
-                #         fpr=fpr,
-                #         tpr=tpr,
-                #         roc_auc=auc_score,
-                #         estimator_name=f"{self.model_type} estimator",
-                #     )
-                #     display.plot(ax=None)
-                #     plt.savefig(plot_path)
-                #     plt.close()
-                #     self.util.debug(f"Saved ROC curve to {plot_path}")
-                #     pauc_score = roc_auc_score(self.truths, self.preds, max_fpr=0.1)
-                #     auc_pauc = f"auc: {auc_score:.3f}, pauc: {pauc_score:.3f} from epoch: {epoch}"
-                #     self.util.debug(auc_pauc)
                 self.util.debug(f1_per_class)
                 rpt_str = f"{json.dumps(rpt)}\n{f1_per_class}"
                 # rpt_str += f"\n{auc_auc}"
@@ -514,18 +498,12 @@ class Reporter:
         # 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),
+            self._scaleresults(np.asarray(losses)),
+            self._scaleresults(np.asarray(results)),
+            self._scaleresults(np.asarray(train_results)),
+            self._scaleresults(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")
@@ -536,3 +514,11 @@ class Reporter:
         plt.legend()
         plt.savefig(f"{fig_dir}{out_name}.{self.format}")
         plt.close()
+
+    def _scaleresults(self, results:np.ndarray) -> np.ndarray:
+        results = results.copy()
+        """Scale results to fit on the plot."""
+        if np.any((results > 1)):
+        # scale down values
+            results = results / 100.0
+        return results